Intégration de ChromaDB pour le stockage et la recherche : service Docker persistant, sessions utilisateur, UI enrichie, dashboard admin amélioré et theming unifié

Author: thanhtulearncode

.env.example

@@ -17,6 +17,8 @@ ACCESS_TOKEN_EXPIRE_MINUTES=30
 # Note : Dans Docker, utilisez le chemin absolu interne /app/data/
 # DATABASE_URL="sqlite:////app/data/chatbot_production.db"
 DATABASE_URL="sqlite:///./data/chatbot_production.db"
+CHROMA_DB_HOST=localhost
+CHROMA_DB_PORT=8001
 
 # --- Clés API LLM ---
 # Au moins une clé est requise. Groq est prioritaire.

app/core/config.py

@@ -18,6 +18,11 @@ class Settings(BaseSettings):
     EMBEDDING_MODEL: str = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
     FAQ_JSON_PATH: str = "data/faq.json"
     CONFIDENCE_THRESHOLD: float = 0.45
+    DIRECT_ANSWER_THRESHOLD: float = 0.75
+    # Config Chroma
+    CHROMA_DB_HOST: str = "chromadb"
+    CHROMA_DB_PORT: int = 8000
+    CHROMA_COLLECTION_NAME: str = "faq_collection"
     model_config = SettingsConfigDict(
         env_file=".env", 
         case_sensitive=True,

app/main.py

@@ -1,7 +1,8 @@
 from contextlib import asynccontextmanager
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse  
+from fastapi.templating import Jinja2Templates
 from sqlmodel import SQLModel
 import os
 
@@ -10,6 +11,8 @@
 from app.services.rag_engine import RAGService
 from app.routers import auth, admin, chat
 
+templates = Jinja2Templates(directory="templates")
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     SQLModel.metadata.create_all(engine)
@@ -29,8 +32,10 @@ async def lifespan(app: FastAPI):
 app.include_router(chat.router)
 
 @app.get("/")
-async def root():
-    # Vérifie si le fichier existe pour éviter une erreur 500
+async def root(request: Request):
     if os.path.exists("templates/index.html"):
-        return FileResponse("templates/index.html")
+        return templates.TemplateResponse(
+        "index.html",
+        {"request": request}
+    )
     return {"message": "Erreur: templates/index.html introuvable. Vérifiez vos dossiers."}

app/routers/admin.py

@@ -1,5 +1,5 @@
-from fastapi import APIRouter, Depends, Request, Form
-from fastapi.responses import RedirectResponse
+from fastapi import APIRouter, Depends, Request, Form, HTTPException
+from fastapi.responses import RedirectResponse, JSONResponse
 from fastapi.templating import Jinja2Templates
 from sqlmodel import Session, select, func
 from app.db.session import get_session
@@ -24,7 +24,7 @@ async def dashboard(
         .where(ChatInteraction.confidence < 0.45)
         .where(ChatInteraction.provider != "static_rule")
         .order_by(ChatInteraction.timestamp.desc())
-        .limit(10)
+        .limit(50) 
     ).all()
 
     stats = {
@@ -94,4 +94,73 @@ async def delete_faq(
 @router.get("/stats")
 async def get_stats_json(db: Session = Depends(get_session), current_user = Depends(get_current_admin_user)):
     total = db.exec(select(func.count(ChatInteraction.id))).one()
-    return {"total_messages": total}
+    return {"total_messages": total}
+
+@router.post("/questions/convert-to-faq/{interaction_id}")
+async def convert_question_to_faq(
+    interaction_id: int,
+    question: str = Form(None),
+    answer: str = Form(None),
+    category: str = Form("general"),
+    db: Session = Depends(get_session),
+    current_user = Depends(get_current_admin_user)
+):
+    interaction = db.get(ChatInteraction, interaction_id)
+    if not interaction:
+        raise HTTPException(status_code=404, detail="Interaction not found")
+    
+    faq_question = question if question else interaction.message
+    faq_answer = answer if answer else interaction.response
+    
+    existing = db.exec(
+        select(FAQItem).where(FAQItem.question == faq_question)
+    ).first()
+    
+    if existing:
+        return JSONResponse(
+            status_code=400,
+            content={"message": "This question already exists in FAQ", "faq_id": existing.id}
+        )
+    
+    new_faq = FAQItem(
+        question=faq_question,
+        answer=faq_answer,
+        category=category
+    )
+    db.add(new_faq)
+    db.commit()
+    db.refresh(new_faq)
+    
+    try:
+        RAGService().reload_from_db(db)
+    except Exception as e:
+        print(f"Error reloading ChromaDB: {e}")
+    
+    return JSONResponse(
+        status_code=200,
+        content={
+            "message": "Question added to FAQ successfully",
+            "faq_id": new_faq.id,
+            "question": new_faq.question
+        }
+    )
+
+@router.get("/questions/{interaction_id}")
+async def get_question_details(
+    interaction_id: int,
+    db: Session = Depends(get_session),
+    current_user = Depends(get_current_admin_user)
+):
+    interaction = db.get(ChatInteraction, interaction_id)
+    if not interaction:
+        raise HTTPException(status_code=404, detail="Interaction not found")
+    
+    return {
+        "id": interaction.id,
+        "message": interaction.message,
+        "response": interaction.response,
+        "confidence": interaction.confidence,
+        "provider": interaction.provider,
+        "timestamp": interaction.timestamp.isoformat(),
+        "user_session_id": interaction.user_session_id
+    }

app/routers/chat.py

@@ -1,7 +1,7 @@
 from fastapi import APIRouter, Depends, BackgroundTasks, HTTPException
 from pydantic import BaseModel
 from typing import List, Dict, Any
-from sqlmodel import Session, select, delete
+from sqlmodel import Session, select, delete, desc
 from app.db.session import get_session
 from app.db.models import ChatInteraction
 from app.services.rag_engine import RAGService
@@ -45,61 +45,78 @@ async def chat_endpoint(
     background_tasks: BackgroundTasks,
     db: Session = Depends(get_session)
 ):
-    # Recherche RAG (incluant maintenant les règles statiques Bonjour/Merci)
+    history_items = db.exec(
+        select(ChatInteraction)
+        .where(ChatInteraction.user_session_id == request.user_id)
+        .order_by(desc(ChatInteraction.timestamp))
+        .limit(5)
+    ).all()
+    history_items = history_items[::-1]
+    history_text = "\n".join(
+        [f"User: {h.message}\nAssistant: {h.response}" for h in history_items]
+    ) if history_items else "Aucun historique récent."
+
     rag_result = rag_service.search(request.message, threshold=settings.CONFIDENCE_THRESHOLD)
-    
     response_text = ""
     provider = "retrieval_only"
     confidence = rag_result["confidence"]
     matched_q = rag_result["matched_question"]
-    # Si le moteur RAG a trouvé une règle statique (Bonjour), on l'utilise directement
+    context_faq = rag_result["answer"] if rag_result["answer"] else ""
+
     if rag_result.get("provider") == "static_rule":
-        response_text = rag_result["answer"]
-        provider = "static_rule"
-        # La confiance est déjà à 1.0 grâce à la modif dans rag_engine.py
+        return ChatResponse(
+            response=rag_result["answer"],
+            confidence=1.0,
+            provider="static_rule",
+            retrieval_only=True,
+            is_new_question=False
+        )
+    # Cas A : Confiance TRÈS élevée -> FAQ Directe
+    if context_faq and confidence >= settings.DIRECT_ANSWER_THRESHOLD:
+        response_text = context_faq
+        provider = "retrieval_high_confidence"
+    # Cas B : Passage au LLM
     else:
-        # Décision : RAG ou LLM ?
-        should_use_llm = request.use_llm and (confidence < 0.65)
-        if not should_use_llm and rag_result["answer"]:
-            # Cas : Réponse trouvée dans la FAQ avec une bonne confiance
-            response_text = rag_result["answer"]
-        else:
-            # Cas : Pas de réponse FAQ ou confiance faible -> Appel LLM
-            context = rag_result["answer"] if rag_result["answer"] else ""
-            
-            prompt = f"""Tu es un assistant support client expert.
-Contexte issu de la base de connaissances : "{context}"
-Question utilisateur : "{request.message}"
+        system_prompt = f"""Tu es un assistant support client utile et précis.
+
+CONTEXTE FAQ (Peut être vide ou peu pertinent, score={confidence:.2f}) :
+"{context_faq}"
 
-Instructions :
-- Si le contexte répond à la question, reformule-le poliment.
-- Si le contexte est vide ou non pertinent, réponds avec tes connaissances générales en restant bref.
-- Réponds en français.
+HISTORIQUE :
+{history_text}
+
+INSTRUCTIONS :
+1. Utilise le CONTEXTE FAQ en priorité s'il semble répondre à la question.
+2. Si le contexte est vide ou hors-sujet, utilise tes connaissances.
+3. Réponds toujours poliment et en français.
 """
-            llm_result = await llm_orchestrator.generate_response(prompt)
+        if request.use_llm:
+            llm_result = await llm_orchestrator.generate_response(
+                f"{system_prompt}\n\nUser: {request.message}"
+            )
 
             if llm_result["status"] == "success":
                 response_text = llm_result["response"]
-                provider = llm_result["provider"]
-                confidence = 1.0 
-                
+                provider = f"llm_{llm_result['provider']}"
             else:
-                # Fallback ultime
-                response_text = rag_result["answer"] or "Désolé, je n'ai pas la réponse et mes services IA sont indisponibles."
+                response_text = context_faq or "Désolé, mes services d'IA sont indisponibles."
                 provider = "fallback_error"
+        else:
+            response_text = context_faq or "Je n'ai pas trouvé de réponse exacte."
 
     # Sauvegarde
     background_tasks.add_task(
         save_interaction_task, db, request.user_id, request.message, response_text, confidence, provider
     )
+    is_retrieval = provider in ["retrieval_high_confidence", "static_rule", "retrieval_only"]
 
     return ChatResponse(
         response=response_text,
         confidence=confidence,
         provider=provider,
         matched_question=matched_q,
-        retrieval_only=(provider == "retrieval_only" or provider == "static_rule"),
-        is_new_question=(rag_result["confidence"] < 0.45 and provider != "static_rule") # On marque comme "new" seulement si ce n'est pas un "Bonjour"
+        retrieval_only=is_retrieval,
+        is_new_question=(confidence < settings.CONFIDENCE_THRESHOLD) 
     )
 
 @router.get("/llm/status")