Merge remote-tracking branch 'origin' into frontend

Author: Hermi-git

README.md

@@ -116,4 +116,4 @@ MindVault AI is designed with standard SaaS security practices in mind:
 
 ## Documentation
 
-- [Architecture](docs/architecture.md)
+- [Architecture](backend/architecture.md)

backend/app/adapters/inbound/api/v1/routes_chat.py

@@ -6,7 +6,8 @@
 from fastapi import APIRouter, Depends
 from fastapi.responses import StreamingResponse
 
-from app.application.dto.requests import ChatRequest
+from app.application.dto.requests import ChatRequest, CreateSessionRequest
+from app.application.dto.responses import SessionResponse
 from app.infrastructure.config import settings
 from app.infrastructure.di.container import Container
 from app.infrastructure.security.auth import get_current_claims
@@ -17,6 +18,26 @@
 router = APIRouter(prefix="/chats", tags=["chats"])
 
 
+@router.post("", status_code=201)
+async def create_session(
+    payload: CreateSessionRequest,
+    claims: dict = Depends(get_current_claims),
+    chat_service=Depends(Container.get_chat_service),
+) -> SessionResponse:
+    user_id = UUID(claims["sub"])
+    org_id = UUID(claims["org_id"])
+    session = await chat_service.create_session(
+        org_id=org_id,
+        user_id=user_id,
+        title=payload.title,
+    )
+    return SessionResponse(
+        id=str(session.id),
+        title=session.title,
+        created_at=session.created_at.isoformat() if session.created_at else None,
+    )
+
+
 @router.post(
     "/{session_id}/ask",
     dependencies=[

backend/app/application/dto/requests.py

@@ -71,6 +71,11 @@ class MFAVerifyRequest(BaseModel):
     code: StrictStr = Field(..., min_length=6, max_length=8)
 
 
+class CreateSessionRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+    title: StrictStr = Field(..., min_length=1, max_length=255)
+
+
 class ChatRequest(BaseModel):
     model_config = ConfigDict(extra="forbid", strict=True)
     message: StrictStr = Field(..., min_length=1, max_length=10000)
@@ -80,3 +85,8 @@ class SearchRequest(BaseModel):
     model_config = ConfigDict(extra="forbid", strict=True)
     query: StrictStr = Field(..., min_length=1, max_length=10000)
     top_k: StrictInt = Field(default=5, ge=1, le=50)
+
+
+class CreateSesssionRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+    initial_message: StrictStr = Field(..., min_length=1, max_length=10000)

backend/app/application/dto/responses.py

@@ -49,6 +49,13 @@ class InviteMemberResponse(BaseModel):
     invite_url: str
 
 
+class SessionResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+    id: str
+    title: str
+    created_at: str | None = None
+
+
 class UsageResponse(BaseModel):
     model_config = ConfigDict(extra="forbid", strict=True)
     org_id: str
@@ -93,3 +100,11 @@ class SearchResponse(BaseModel):
     items: list[SearchChunkResponse]
     citations: list[dict]
     total: int
+
+
+class CreateSessionresponse(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+    session_id: str
+    title: str | None = None
+    created_at: str
+    last_message_at: str

backend/app/application/services/chat_service.py

@@ -2,12 +2,16 @@
 
 import json
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import AsyncGenerator
 from uuid import UUID
 
+from app.adapters.outbound.db.repositories.chat_session_repository_implementation import (  # noqa: E501
+    NotFound as SessionNotFound,
+)
 from app.application.services.hybrid_search_service import HybridSearchService
 from app.domain.entities.chat_message import ChatMessage
+from app.domain.entities.chat_session import ChatSession
 from app.domain.ports.outbound.llm_port import LLMPort
 from app.domain.ports.outbound.reranker import Reranker
 from app.domain.services.citation_policy import (
@@ -44,6 +48,35 @@ def __init__(
         self._model = model
         self._usage_service = usage_service
 
+    async def create_session(
+        self,
+        *,
+        org_id: UUID,
+        user_id: UUID,
+        title: str,
+    ) -> ChatSession:
+        session = ChatSession.create(org_id=org_id, user_id=user_id, title=title)
+        async with self._uow_factory() as uow:
+            await uow.sessions.create_chat_session(session)
+            await uow.commit()
+        return session
+
+    async def _ensure_session(
+        self, uow, *, session_id: UUID, org_id: UUID, user_id: UUID
+    ) -> None:
+        try:
+            await uow.sessions.get_chat_session(session_id)
+        except SessionNotFound:
+            session = ChatSession(
+                id=session_id,
+                org_id=org_id,
+                user_id=user_id,
+                title="New Chat",
+                created_at=datetime.now(timezone.utc),
+                updated_at=datetime.now(timezone.utc),
+            )
+            await uow.sessions.create_chat_session(session)
+
     async def ask_question(
         self,
         *,
@@ -77,6 +110,9 @@ async def ask_question(
         citations_as_dicts = [c.__dict__ for c in citations]
 
         async with self._uow_factory() as uow:
+            await self._ensure_session(
+                uow, session_id=session_id, org_id=org_id, user_id=user_id
+            )
             history = await uow.messages.get_recent_by_session(session_id, limit=6)
 
             user_msg = ChatMessage.create_user_message(
@@ -141,6 +177,10 @@ async def _persist_answer(
         token_count: int,
     ) -> None:
         async with self._uow_factory() as uow:
+            await self._ensure_session(
+                uow, session_id=session_id, org_id=org_id, user_id=user_id
+            )
+
             ai_msg = ChatMessage.create_assistant_message(
                 session_id=session_id,
                 org_id=org_id,

backend/app/domain/entities/chat_session.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any
-from uuid import UUID
+from uuid import UUID, uuid4
 
 
 @dataclass(slots=True)
@@ -16,3 +16,22 @@ class ChatSession:
     last_message_at: datetime | None = None
     created_at: datetime | None = None
     updated_at: datetime | None = None
+
+    @staticmethod
+    def create(
+        *,
+        org_id: UUID,
+        user_id: UUID,
+        title: str,
+        metadata: dict[str, Any] | None = None,
+    ) -> ChatSession:
+        now = datetime.now(timezone.utc)
+        return ChatSession(
+            id=uuid4(),
+            org_id=org_id,
+            user_id=user_id,
+            title=title,
+            metadata=metadata or {},
+            created_at=now,
+            updated_at=now,
+        )