chat history ready for frontend integration, me endpoint

src/api/routers/sessions.py

@@ -0,0 +1,61 @@
+from fastapi import APIRouter, Depends, Query
+from typing import Annotated, List
+from src.api.models.user import User
+from src.api.models.chat import ChatMessageRole
+from src.api.dependencies.auth import get_current_user_required, get_current_user_optional
+from src.api.dependencies.clients import get_db, get_chat_history_service
+from sqlmodel.ext.asyncio.session import AsyncSession
+from src.api.selectors.chat.get_session import get_chat_sessions
+from src.api.schemas.session import ChatSessionList, ChatMessageRead
+from src.api.services.chat_history_service import ChatHistoryService
+from llama_index.core.llms import MessageRole
+import uuid
+
+router = APIRouter(
+    prefix="/api/v1",
+    tags=["Sessions"],
+)
+
+def _llama_role_to_chat_role(role: MessageRole) -> ChatMessageRole:
+    mapping = {
+        MessageRole.USER: ChatMessageRole.USER,
+        MessageRole.ASSISTANT: ChatMessageRole.ASSISTANT,
+        MessageRole.SYSTEM: ChatMessageRole.SYSTEM,
+    }
+    return mapping.get(role, ChatMessageRole.USER)
+
+@router.get("/sessions", response_model=List[ChatSessionList])
+async def list_sessions(
+    user: Annotated[User, Depends(get_current_user_required)],
+    db: Annotated[AsyncSession, Depends(get_db)],
+    limit: Annotated[int, Query(default=20, le=100)] = 20,
+    offset: Annotated[int, Query(default=0)] = 0
+):
+    return await get_chat_sessions(
+        user_id=user.id, 
+        db=db, 
+        limit=limit, 
+        offset=offset
+    )
+
+@router.get("/sessions/{session_id}/messages", response_model=List[ChatMessageRead])
+async def get_messages(
+    session_id: uuid.UUID,
+    chat_history_service: Annotated[ChatHistoryService, Depends(get_chat_history_service)],
+    user: Annotated[User, Depends(get_current_user_optional)],
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    messages = await chat_history_service.get_messages(
+        session_id=session_id,
+        user=user,
+        db=db
+    )
+    return [
+        ChatMessageRead(
+            role=_llama_role_to_chat_role(msg.role),
+            content=str(msg.content)
+        )
+        for msg in messages
+    ]
+
+    

src/api/routers/user.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter, Depends
+from src.api.dependencies.auth import get_current_user_required
+from src.api.models.user import User
+from src.api.schemas.user import UserRead
+from typing import Annotated
+
+router = APIRouter(
+    prefix="/api/v1/user",
+    tags=["User"],
+)
+
+@router.get("/me", response_model=UserRead)
+async def get_me(
+    user: Annotated[User, Depends(get_current_user_required)],
+):
+    return user

src/api/schemas/session.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel
+import uuid
+from datetime import datetime
+from src.api.models.chat import ChatMessageRole
+
+class ChatSessionList(BaseModel):
+    id: uuid.UUID
+    title: str
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+class ChatMessageRead(BaseModel):
+    role: ChatMessageRole
+    content: str
+
+    class Config:
+        from_attributes = True

src/api/schemas/user.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, EmailStr
+
+class UserRead(BaseModel):
+    id: int
+    username: str
+    email: EmailStr
+
+    class Config:
+        from_attributes = True

src/api/selectors/chat/create_session.py

@@ -3,18 +3,28 @@ from src.api.models.chat import ChatSession
 from typing import Optional
 import uuid
 
-async def create_sessions(
+async def create_session(
     user_id: Optional[int],
     title: str,
-    db: AsyncSession
+    db: AsyncSession,
+    session_id: Optional[uuid.UUID] = None
 ) -> ChatSession:
     session = ChatSession(
-        id = uuid.uuid4(),
-        title = title,
-        user_id = user_id,
-        is_active = True,
+        id=session_id or uuid.uuid4(),
+        title=title,
+        user_id=user_id,
+        is_active=True,
     )
     db.add(session)
     await db.commit()
     await db.refresh(session)
-    return session
+    return session
+
+async def create_sessions(
+    user_id: Optional[int],
+    title: str,
+    db: AsyncSession,
+    session_id: Optional[uuid.UUID] = None
+) -> ChatSession:
+    """Deprecated"""
+    return await create_session(user_id, title, db, session_id)

src/api/selectors/chat/get_messages.py

@@ -0,0 +1,17 @@
+import uuid
+from typing import List
+from sqlmodel import select
+from sqlmodel.ext.asyncio.session import AsyncSession
+from src.api.models.chat import ChatMessage
+
+async def get_chat_messages_by_session(
+    session_id: uuid.UUID,
+    db: AsyncSession
+) -> List[ChatMessage]:
+    query = (
+        select(ChatMessage)
+        .where(ChatMessage.session_id == session_id)
+        .order_by(ChatMessage.timestamp)
+    )
+    result = await db.exec(query)
+    return result.all()

src/api/selectors/chat/get_session.py

@@ -1,17 +1,42 @@
 from sqlmodel import select
 from sqlmodel.ext.asyncio.session import AsyncSession
 from src.api.models.chat import ChatSession
-from typing import Optional
+from typing import Optional, List
 import uuid
 
-async def get_chat_session(
+async def get_chat_session_by_id(
     session_id: uuid.UUID,
     user_id: Optional[int],
     db: AsyncSession
 ) -> Optional[ChatSession]:
     query = select(ChatSession).where(ChatSession.id == session_id)
-    if user_id:
-        query = query.where(ChatSession.user_id == user_id)
+    result = await db.exec(query)
+    session = result.first()
+    if not session:
+        return None
+    if session.user_id is not None:
+        if session.user_id != user_id or user_id is None:
+            return None
+    else:
+        if user_id is not None:
+            return None
+    return session
+    
     
+async def get_chat_sessions(
+    user_id: int,
+    db: AsyncSession,
+    limit: int = 20,
+    offset: int = 0
+) -> List[ChatSession]:
+    query = (
+        select(ChatSession)
+        .where(ChatSession.user_id == user_id)
+        .where(ChatSession.is_active == True) 
+        .order_by(ChatSession.updated_at.desc()) 
+        .limit(limit)
+        .offset(offset)
+    )
     result = await db.exec(query)
-    return result.first()
+    return result.all()
+

src/api/selectors/chat/save_messages.py

@@ -1,4 +1,5 @@
 from sqlmodel.ext.asyncio.session import AsyncSession
+from sqlmodel import select, delete
 from src.api.models.chat import ChatSession, ChatMessage, ChatMessageRole
 from llama_index.core.llms import ChatMessage as LlamaChatMessage, MessageRole
 from typing import List
@@ -16,19 +17,27 @@ def llama_to_db_role(llama_role: MessageRole) -> ChatMessageRole:
 async def save_messages_to_db(
     session: ChatSession, 
     messages: List[LlamaChatMessage],
-    db: AsyncSession
+    db: AsyncSession,
+    replace_existing: bool = True
 ) -> List[ChatMessage]:
+    if replace_existing:
+        await db.exec(
+            delete(ChatMessage).where(ChatMessage.session_id == session.id)
+        )
+        await db.commit()
+    
     db_messages = []
     now = datetime.now(timezone.utc)
-    for msg in messages:
+    for i, msg in enumerate(messages):
         db_message = ChatMessage(
-            content=msg.content,
+            content=str(msg.content),
             role=llama_to_db_role(msg.role),
             timestamp=now,
             session_id=session.id,
         )
         db_messages.append(db_message)
         db.add(db_message)
+    
     await db.commit()
     for msg in db_messages:
         await db.refresh(msg)

src/api/services/chat_history_service.py

@@ -4,9 +4,10 @@ from llama_index.core.llms import ChatMessage, MessageRole
 from sqlmodel.ext.asyncio.session import AsyncSession
 from src.api.models.user import User
 from src.api.models.chat import ChatSession
-from src.api.selectors.chat.get_session import get_chat_session
+from src.api.selectors.chat.get_session import get_chat_session_by_id
 from src.api.selectors.chat.create_session import create_sessions
 from src.api.selectors.chat.save_messages import save_messages_to_db
+from src.api.selectors.chat.get_messages import get_chat_messages_by_session
 import uuid
 import logging
 from src.core.settings import settings
@@ -28,11 +29,30 @@ class ChatHistoryService:
     async def get_messages(
         self,
         session_id: uuid.UUID,
-        user: Optional[User]
+        user: Optional[User],
+        db: Optional[AsyncSession] = None
     ) -> List[ChatMessage]:
         try:
             key = self._get_redis_key(session_id, user)
-            return await self.redis_store.aget_messages(key)
+            messages = await self.redis_store.aget_messages(key)
+            if messages:
+                return messages
+            if db:
+                session = await get_chat_session_by_id(session_id, user.id if user else None, db)
+                if not session:
+                    return []
+                db_messages = await get_chat_messages_by_session(session_id, db)
+                if db_messages:
+                    llama_messages = [
+                        ChatMessage(
+                            role=message.role, 
+                            content=message.content) 
+                            for message in db_messages
+                        ]
+                    await self.redis_store.aset_messages(key, llama_messages)
+                    return llama_messages
+
+            return []
         except Exception as e:
             logger.warning(f"Failed to get messages from Redis: {e}. Returning empty list.")
             return []
@@ -45,7 +65,7 @@ class ChatHistoryService:
     ) -> None:
         try:
             key = self._get_redis_key(session_id, user)
-            await self.redis_store.async_add_message(key, message)
+            await self.redis_store.aadd_message(key, message)
         except Exception as e:
             logger.warning(f"Failed to add message to Redis: {e}. Message not stored.")
 
@@ -73,6 +93,8 @@ class ChatHistoryService:
             logger.warning(f"Failed to delete session from Redis: {e}.")
             return None
 
+
+
     async def sync_to_postgres(
         self,
         session_id: uuid.UUID,
@@ -80,12 +102,12 @@ class ChatHistoryService:
         db: AsyncSession,
         title: Optional[str] = None
     ) -> Optional[ChatSession]:
-        messages = await self.get_messages(session_id, user)
+        messages = await self.get_messages(session_id, user, db)
         
         if not messages:
             return None
         
-        db_session = await get_chat_session(session_id, user.id, db)
+        db_session = await get_chat_session_by_id(session_id, user.id, db)
         
         if not db_session:
             if not title:
@@ -99,16 +121,15 @@ class ChatHistoryService:
             db_session = await create_sessions(
                 user_id=user.id,
                 title=title,
-                db=db
+                db=db,
+                session_id=session_id  
             )
-            db_session.id = session_id
-            await db.commit()
-            await db.refresh(db_session)
         
         await save_messages_to_db(
             session=db_session,
             messages=messages,
-            db=db
+            db=db,
+            replace_existing=True  
         )
         
         return db_session

src/clients/postgres.py

@@ -8,6 +8,10 @@ engine = create_async_engine(
     settings.async_database_url,
     echo=False,
     future=True,
+    pool_pre_ping=True,
+    pool_recycle=3600,
+    pool_size=15,
+    max_overflow=25,
 )
 
 async_session = sessionmaker(