Updating session route.

Combining chat route with it.
Splitting summarise into its own route.

src/api/routes/chat.py

@@ -1,134 +0,0 @@
-# api/routes/chat.py
-
-import time
-from datetime import datetime, timezone
-
-from fastapi import APIRouter, Depends, HTTPException
-
-from src.core.state import MedicalState, get_state
-from src.models.chat import ChatRequest, ChatResponse, SummariseRequest
-from src.services.medical_response import generate_medical_response
-from src.services.summariser import summarise_title_with_nvidia
-from src.utils.logger import logger
-
-router = APIRouter(tags=["Chat"])
-
-@router.post("/chat", response_model=ChatResponse)
-async def chat_endpoint(
-	request: ChatRequest,
-	state: MedicalState = Depends(get_state)
-):
-	"""
-	Process a chat message, generate response, and persist short-term cache + long-term Mongo.
-	"""
-	start_time = time.time()
-
-	logger().info(f"POST /chat user={request.account_id} session={request.session_id} patient={request.patient_id}")
-	logger().info(f"Message: {request.message[:100]}...")  # Log first 100 chars of message
-
-	# Currently completely pointless
-	#user_profile = state.memory_system.get_user(request.account_id)
-	#if not user_profile:
-	#	state.memory_system.create_user()
-
-	session = None
-	session_id = request.session_id
-
-	#if request.session_id != "default":
-	if session_id:
-		try:
-			session = state.memory_system.get_session(session_id)
-		except Exception as e:
-			logger().error(f"Error retrieving session: {e}")
-			raise HTTPException(status_code=400, detail=f"Invalid session ID ({session_id}): {str(e)}")
-
-	if not session:
-		if not request.patient_id:
-			raise HTTPException(status_code=400, detail="patient_id required for new sessions")
-
-		session = state.memory_system.create_session(
-			request.account_id,
-			request.patient_id,
-			"New Chat"
-		)
-
-		logger().info(f"Created new session: {session.session_id}")
-
-	session_id = session.session_id
-
-	try:
-		# Get enhanced medical context with STM + LTM semantic search + NVIDIA reasoning
-		medical_context = await state.history_manager.get_enhanced_conversation_context(
-			request.account_id,
-			session_id,
-			request.message,
-			state.nvidia_rotator,
-			patient_id=request.patient_id
-		)
-	except Exception as e:
-		logger().error(f"Error getting medical context: {e}")
-		logger().error(f"Request data: {request.model_dump()}")
-		raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
-
-	try:
-		# Generate response using Gemini AI
-		logger().info(f"Generating medical response using Gemini AI for user {request.account_id}")
-		response = await generate_medical_response(
-			request.message,
-			"Medical Professional",
-			"",
-			state.gemini_rotator,
-			medical_context
-		)
-
-		# Process and store the exchange
-		try:
-			await state.history_manager.process_medical_exchange(
-				request.account_id,
-				session_id,
-				request.message,
-				response,
-				state.gemini_rotator,
-				state.nvidia_rotator,
-				patient_id=request.patient_id,
-				doctor_id=request.account_id,
-				session_title="New Chat"
-			)
-		except Exception as e:
-			logger().warning(f"Failed to process medical exchange: {e}")
-			# Continue without storing if there's an error
-
-		# Calculate response time
-		response_time = time.time() - start_time
-
-		logger().info(f"Generated response in {response_time:.2f}s for user {request.account_id}")
-		logger().info(f"Response length: {len(response)} characters")
-
-		return ChatResponse(
-			response=response,
-			session_id=session_id,
-			timestamp=datetime.now(timezone.utc).isoformat(),
-			medical_context=medical_context if medical_context else None
-		)
-
-	except Exception as e:
-		logger().error(f"Error in chat endpoint: {e}")
-		logger().error(f"Request data: {request.model_dump()}")
-		raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
-
-@router.post("/summarise")
-async def summarise_endpoint(
-	req: SummariseRequest,
-	state: MedicalState = Depends(get_state)
-):
-	"""Summarise a text into a short 3-5 word title using NVIDIA if available."""
-	try:
-		title = await summarise_title_with_nvidia(
-			req.text,
-			state.nvidia_rotator,
-			max_words=min(max(req.max_words or 5, 3), 7)
-		)
-		return {"title": title}
-	except Exception as e:
-		logger().error(f"Error summarising title: {e}")
-		raise HTTPException(status_code=500, detail=str(e))

src/api/routes/session.py

@@ -1,87 +1,132 @@
-# api/routes/session.py
+# src/api/routes/chat.py
 
-from datetime import datetime
+from datetime import datetime, timezone
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, status
 
-from src.core.state import MedicalState, get_state
-from src.data.repositories.session import delete_session, get_session_messages
-from src.models.chat import SessionRequest
+from src.core.state import AppState, get_state
+from src.models.session import (ChatRequest, ChatResponse, Message, Session,
+                                SessionCreateRequest)
+from src.services.medical_response import generate_medical_response
 from src.utils.logger import logger
 
-router = APIRouter(prefix="/session", tags=["Session"])
+router = APIRouter(prefix="/session", tags=["Session & Chat"])
 
-@router.post("")
+
+@router.post("", response_model=Session, status_code=status.HTTP_201_CREATED)
 async def create_chat_session(
-	request: SessionRequest,
-	state: MedicalState = Depends(get_state)
+	req: SessionCreateRequest,
+	state: AppState = Depends(get_state)
 ):
-	"""Create a new chat session (cache + Mongo)"""
-	try:
-		logger().info(f"POST /session user_id={request.account_id} patient_id={request.patient_id}")
-		session_id = state.memory_system.create_session(request.account_id, request.title or "New Chat")
-		# Also ensure in Mongo with patient/doctor
-		#ensure_session(session_id=session_id, patient_id=request.patient_id, doctor_id=request.doctor_id, title=request.title or "New Chat")
-		return {"session_id": session_id, "message": "Session created successfully"}
-	except Exception as e:
-		logger().error(f"Error creating session: {e}")
-		raise HTTPException(status_code=500, detail=str(e))
+	"""Creates a new, empty chat session."""
+	logger().info(f"POST /session for patient_id={req.patient_id}")
+	session = state.memory_manager.create_session(
+		user_id=req.account_id,
+		patient_id=req.patient_id,
+		title=req.title or "New Chat"
+	)
+	if not session:
+		raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to create session.")
+	return session
 
-@router.get("/{session_id}")
+
+@router.get("/{session_id}", response_model=Session)
 async def get_chat_session(
 	session_id: str,
-	state: MedicalState = Depends(get_state)
+	state: AppState = Depends(get_state)
 ):
-	"""Get session from cache (for quick preview)"""
-	try:
-		session = state.memory_system.get_session(session_id)
-		if not session:
-			raise HTTPException(status_code=404, detail="Session not found")
+	"""Retrieves a session's metadata and all its messages."""
+	logger().info(f"GET /session/{session_id}")
+	session = state.memory_manager.get_session(session_id)
+	if not session:
+		raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Session not found")
+	return session
 
-		return session.to_dict()
-	except HTTPException:
-		raise
-	except Exception as e:
-		logger().error(f"Error getting session: {e}")
-		raise HTTPException(status_code=500, detail=str(e))
 
-@router.get("/{session_id}/messages")
-async def list_messages_for_session(session_id: str, limit: int | None = None):
-	"""List messages for a session from Mongo, verified to belong to the patient"""
-	try:
-		logger().info(f"GET /session/{session_id}/messages limit={limit}")
-		msgs = get_session_messages(session_id, limit)
-		# ensure JSON-friendly timestamps
-		for m in msgs:
-			if isinstance(m.get("timestamp"), datetime):
-				m["timestamp"] = m["timestamp"].isoformat()
-			m["_id"] = str(m["_id"]) if "_id" in m else None
-		return {"messages": msgs}
-	except Exception as e:
-		logger().error(f"Error listing messages: {e}")
-		raise HTTPException(status_code=500, detail=str(e))
-
-@router.delete("/{session_id}")
+@router.delete("/{session_id}", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_chat_session(
 	session_id: str,
-	state: MedicalState = Depends(get_state)
+	state: AppState = Depends(get_state)
 ):
-	"""Delete a chat session from both memory system and MongoDB"""
-	try:
-		logger().info(f"DELETE /session/{session_id}")
+	"""Deletes a chat session permanently."""
+	logger().info(f"DELETE /session/{session_id}")
+	# UPDATED CALL
+	success = state.memory_manager.delete_session(session_id)
+	if not success:
+		raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Session not found or already deleted")
+	return None
+
 
-		# Delete from memory system
-		state.memory_system.delete_session(session_id)
+@router.get("/{session_id}/messages", response_model=list[Message])
+async def list_messages_for_session(
+	session_id: str,
+	limit: int | None = None,
+	state: AppState = Depends(get_state)
+):
+	"""Lists all messages for a specific session from the database."""
+	logger().info(f"GET /session/{session_id}/messages limit={limit}")
+	if not state.memory_manager.get_session(session_id):
+		raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Session not found")
+
+	# UPDATED CALL
+	messages = state.memory_manager.get_session_messages(session_id, limit)
+	return messages
 
-		# Delete from MongoDB
-		session_deleted = delete_session(session_id)
 
-		logger().info(f"Deleted session {session_id}: session={session_deleted}")
+@router.post("/{session_id}/messages", response_model=ChatResponse)
+async def post_chat_message(
+	session_id: str,
+	req: ChatRequest,
+	state: AppState = Depends(get_state)
+):
+	"""
+	Posts a message to a session, gets a generated medical response,
+	and persists the full exchange to long-term memory.
+	"""
+	logger().info(f"POST /session/{session_id}/messages")
 
-		return {
-			"message": "Session deleted successfully",
-			"session_deleted": session_deleted
-		}
+	# 1. Get Enhanced Context
+	try:
+		medical_context = await state.memory_manager.get_enhanced_context(
+			session_id=session_id,
+			patient_id=req.patient_id,
+			question=req.message,
+			nvidia_rotator=state.nvidia_rotator
+		)
 	except Exception as e:
-		logger().error(f"Error deleting session: {e}")
-		raise HTTPException(status_code=500, detail=str(e))
+		logger().error(f"Error getting medical context: {e}")
+		raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to build medical context.")
+
+	# 2. Generate AI Response
+	try:
+		# In a real app, user role/specialty would come from the authenticated user
+		response_text = await generate_medical_response(
+			user_message=req.message,
+			user_role="Medical Professional",
+			user_specialty="",
+			rotator=state.gemini_rotator,
+			medical_context=medical_context
+		)
+	except Exception as e:
+		logger().error(f"Error generating medical response: {e}")
+		raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to generate AI response.")
+
+	# 3. Process and Store the Exchange
+	summary = await state.memory_manager.process_medical_exchange(
+		session_id=session_id,
+		patient_id=req.patient_id,
+		doctor_id=req.account_id,
+		question=req.message,
+		answer=response_text,
+		gemini_rotator=state.gemini_rotator,
+		nvidia_rotator=state.nvidia_rotator
+	)
+	if not summary:
+		logger().warning(f"Failed to process and store medical exchange for session {session_id}")
+
+	return ChatResponse(
+		response=response_text,
+		session_id=session_id,
+		timestamp=datetime.now(timezone.utc),
+		medical_context=medical_context
+	)

src/api/routes/summarise.py

@@ -0,0 +1,40 @@
+# src/api/route/summarise.py
+
+from fastapi import APIRouter, Depends, HTTPException, status
+
+from src.core.state import AppState, get_state
+from src.models.summarise import SummariseRequest, SummariseResponse
+from src.services import summariser
+from src.utils.logger import logger
+
+router = APIRouter(prefix="/summarise", tags=["Utilities"])
+
+
+@router.post("", response_model=SummariseResponse)
+async def summarise_text_endpoint(
+	req: SummariseRequest,
+	state: AppState = Depends(get_state)
+):
+	"""
+	Summarises a given text into a short title using an available AI model.
+	"""
+	logger().info(f"POST /summarise for text starting with: '{req.text[:50]}...'")
+	try:
+		title = await summariser.summarise_title_with_nvidia(
+			text=req.text,
+			rotator=state.nvidia_rotator,
+			max_words=req.max_words
+		)
+		if not title:
+			raise HTTPException(
+				status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+				detail="Failed to generate a summary title."
+			)
+
+		return SummariseResponse(title=title)
+	except Exception as e:
+		logger().error(f"Error summarising title: {e}")
+		raise HTTPException(
+			status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+			detail="An unexpected error occurred while generating the summary."
+		)

src/core/memory_manager.py

@@ -7,7 +7,7 @@ from src.data.repositories import patient as patient_repo
 from src.data.repositories import session as session_repo
 from src.models.account import Account
 from src.models.patient import Patient
-from src.models.session import Session
+from src.models.session import Message, Session
 from src.services import summariser
 from src.services.nvidia import nvidia_chat
 from src.utils.embeddings import EmbeddingClient
@@ -62,6 +62,7 @@ class MemoryManager:
 		except ActionFailed as e:
 			logger().error(f"Failed to search accounts in MemoryManager: {e}")
 			return []
+
 	# --- Patient Management Facade ---
 
 	def create_patient(self, **kwargs) -> str | None:
@@ -138,6 +139,22 @@ class MemoryManager:
 			logger().error(f"Failed to get sessions for patient '{patient_id}': {e}")
 			return []
 
+	def delete_session(self, session_id: str) -> bool:
+		"""Deletes a chat session."""
+		try:
+			return session_repo.delete_session(session_id)
+		except ActionFailed as e:
+			logger().error(f"Failed to delete session '{session_id}' in MemoryManager: {e}")
+			return False
+
+	def get_session_messages(self, session_id: str, limit: int | None = None) -> list[Message]:
+		"""Gets messages from a specific chat session."""
+		try:
+			return session_repo.get_session_messages(session_id, limit)
+		except ActionFailed as e:
+			logger().error(f"Failed to get messages for session '{session_id}': {e}")
+			return []
+
 	# --- Core Business Logic ---
 
 	async def process_medical_exchange(

src/main.py

@@ -26,11 +26,11 @@ except Exception as e:
 # Import project modules after trying to load environment variables
 from src.api.routes import account as account_route
 from src.api.routes import audio as audio_route
-from src.api.routes import chat as chat_route
 from src.api.routes import patient as patients_route
 from src.api.routes import session as session_route
 from src.api.routes import static as static_route
 from src.api.routes import system as system_route
+from src.api.routes import summarise as summarise_route
 from src.core.state import AppState, get_state
 from src.data.repositories import account as account_repo
 from src.data.repositories import medical_memory as medical_memory_repo
@@ -125,12 +125,12 @@ app.add_middleware(
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
 # Include routers
-app.include_router(chat_route.router)
+app.include_router(static_route.router)
 app.include_router(session_route.router)
 app.include_router(patients_route.router)
 app.include_router(account_route.router)
+app.include_router(summarise_route.router)
 app.include_router(system_route.router)
-app.include_router(static_route.router)
 app.include_router(audio_route.router)
 app.include_router(emr_route.router)
 

src/models/chat.py

@@ -1,25 +0,0 @@
-# models/chat.py
-
-from pydantic import BaseModel
-
-
-class ChatRequest(BaseModel):
-	account_id: str
-	patient_id: str
-	session_id: str | None = None
-	message: str
-
-class ChatResponse(BaseModel):
-	response: str
-	session_id: str
-	timestamp: str
-	medical_context: str | None = None
-
-class SessionRequest(BaseModel):
-	account_id: str
-	patient_id: str
-	title: str | None = "New Chat"
-
-class SummariseRequest(BaseModel):
-	text: str
-	max_words: int | None = 5

src/models/session.py

@@ -26,3 +26,26 @@ class Session(BaseMongoModel):
 	created_at: datetime
 	updated_at: datetime
 	messages: list[Message] = Field(default_factory=list)
+
+# --- API Request Models ---
+
+class SessionCreateRequest(BaseModel):
+	account_id: str
+	patient_id: str
+	title: str | None = "New Chat"
+
+
+class ChatRequest(BaseModel):
+	"""Request model for sending a message to a session."""
+	account_id: str # For context, though session_id implies this
+	patient_id: str # For context, though session_id implies this
+	message: str
+
+# --- API Response Models ---
+
+class ChatResponse(BaseModel):
+	"""Response model for a chat interaction."""
+	response: str
+	session_id: str
+	timestamp: datetime
+	medical_context: str | None = None

src/models/summarise.py

@@ -0,0 +1,14 @@
+# src/models/summarise.py
+
+from pydantic import BaseModel, Field
+
+
+class SummariseRequest(BaseModel):
+	"""Request model for the text summarisation endpoint."""
+	text: str
+	max_words: int = Field(default=5, ge=3, le=10) # Enforce reasonable limits
+
+
+class SummariseResponse(BaseModel):
+	"""Response model for the text summarisation endpoint."""
+	title: str

src/services/medical_response.py

@@ -1,4 +1,4 @@
-# services/medical_response.py
+# src/services/medical_response.py
 
 from src.core import prompt_builder
 from src.data.medical_kb import search_medical_kb