feat: Version finale de l'application full stack avec RAG amélioré

PROCHAINES_ETAPES.md

@@ -1,50 +0,0 @@
-# Prochaines Étapes pour l'Assistant Web Éducatif
-
-Ce document détaille les prochaines étapes de développement pour faire évoluer le projet de son état actuel (backend fonctionnel) vers une application complète, en se basant sur le cahier des charges et la vision du produit.
-
----
-### Phase 1 : Consolidation du Backend et de l'API
-
-L'objectif est de rendre le backend plus robuste et complet.
-
-1.  **Gestion des Téléversements de Fichiers (Uploads) :**
-    * [cite_start]Modifier l'endpoint `POST /documents` pour accepter un **vrai téléversement de fichier PDF** au lieu d'un simple nom de fichier [cite: 244-247, 305-309].
-    * Sauvegarder le fichier téléversé dans le dossier `data/documents`.
-    * Déclencher automatiquement le processus d'extraction et de vectorisation juste après le téléversement.
-
-2.  **Affiner le Modèle de Réponse :**
-    * [cite_start]Enrichir la réponse de l'API `/ask` pour inclure les **sources exactes** (nom du document, numéro de page, etc.) qui ont servi de contexte [cite: 269-277].
-    * Cela implique de stocker plus de métadonnées (comme le numéro de page) lors du découpage du texte.
-
-3.  **Gestion des Utilisateurs :**
-    * [cite_start]Créer des modèles de données et des tables pour les **utilisateurs** (Étudiant, Enseignant, Administrateur) [cite: 1236-1240, 1253-1255].
-    * [cite_start]Mettre en place un système d'**authentification** (par exemple, avec JWT) pour sécuriser les endpoints[cite: 71, 132].
-
----
-### Phase 2 : Développement du Frontend
-
-L'objectif est de créer une interface utilisateur pour interagir avec le backend.
-
-1.  **Interface de Questions-Réponses :**
-    * [cite_start]Créer une page simple avec un champ de saisie pour poser une question et une zone pour afficher la réponse de l'IA [cite: 258-260, 1142].
-    * Connecter cette interface à l'endpoint `/api/v1/ask`.
-
-2.  **Interface d'Administration :**
-    * [cite_start]Développer une page sécurisée pour les enseignants et administrateurs[cite: 236].
-    * [cite_start]Créer un formulaire pour le **téléversement des manuels PDF** [cite: 237-242].
-    * Afficher la liste des documents déjà présents dans le système.
-
----
-### Phase 3 : Améliorations et Déploiement
-
-L'objectif est de préparer le projet pour une utilisation réelle.
-
-1.  **Amélioration de la Pertinence :**
-    * [cite_start]Explorer des **modèles de `sentence-transformers` multilingues** ou plus spécialisés en science pour améliorer la qualité de la recherche sémantique[cite: 80].
-    * [cite_start]Permettre à l'utilisateur de noter la pertinence des réponses pour un apprentissage continu (auto-amélioration)[cite: 20, 1271].
-
-2.  **Mise en place du Cache :**
-    * [cite_start]Intégrer **Redis** pour mettre en cache les questions fréquentes et accélérer les temps de réponse, comme spécifié dans l'architecture[cite: 25, 62, 1384].
-
-3.  **Conteneurisation Complète avec Docker Compose :**
-    * [cite_start]Écrire un fichier `docker-compose.yml` pour lancer toute l'application (Backend, PostgreSQL, Redis, Ollama) avec une seule commande, simplifiant ainsi le déploiement [cite: 148-193].

README.md

@@ -1,6 +1,6 @@
 # Assistant Web Éducatif - Full Stack
 
-Ce dépôt contient le code source complet de l'Assistant Web Éducatif, une application full stack conçue pour aider les étudiants en chimie. Le système analyse des manuels PDF, permet de poser des questions en langage naturel et fournit des réponses sourcées grâce à un modèle de langage local.
+Ce dépôt contient le code source complet de l'Assistant Web Éducatif, une application full stack conçue pour aider les étudiants dans un domaine spécifique. Le système analyse des manuels PDF, permet de poser des questions en langage naturel et fournit des réponses sourcées grâce à un modèle de langage local.
 
 ## Fonctionnalités Principales ✨
 -   **API Backend Robuste** : Construite avec FastAPI, elle gère la logique de traitement des documents, l'authentification des utilisateurs et la génération des réponses.

backend/Dockerfile

@@ -3,9 +3,13 @@
 FROM python:3.12-slim
 
 WORKDIR /app
+RUN apt-get update && apt-get install -y netcat-openbsd && rm -rf /var/lib/apt/lists/*
 COPY backend/requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
-COPY backend/ ./backend/
+COPY backend/ .
 COPY scripts/ ./scripts/
+
+COPY backend/entrypoint.sh .
+RUN chmod +x ./entrypoint.sh
 #ENV PYTHONPATH="/app"
-CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "8000"]
+ENTRYPOINT ["./entrypoint.sh"]

backend/api/dependencies.py

@@ -5,9 +5,9 @@ from fastapi.security import OAuth2PasswordBearer
 from sqlalchemy.orm import Session
 from jose import JWTError, jwt
 
-from backend.models.user import User
-from backend.utils.security import SECRET_KEY, ALGORITHM
-from backend.config.database import SessionLocal
+from models.user import User
+from utils.security import SECRET_KEY, ALGORITHM
+from config.database import SessionLocal
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/v1/token")
 

backend/api/routes/documents.py

@@ -3,12 +3,12 @@ from sqlalchemy.orm import Session
 import aiofiles
 import os
 
-from backend.models.document import Document
-from backend.api.dependencies import get_db
-from backend.services.document_processor import extract_pages_from_pdf, split_text_into_chunks
-from backend.services.vector_store import VectorStore
-from backend.models.user import User as UserModel, RoleEnum
-from backend.api.dependencies import get_current_user
+from models.document import Document
+from api.dependencies import get_db
+from services.document_processor import extract_pages_from_pdf, split_text_into_chunks
+from services.vector_store import VectorStore
+from models.user import User as UserModel, RoleEnum
+from api.dependencies import get_current_user
 
 
 router = APIRouter()

backend/api/routes/feedback.py

@@ -3,9 +3,9 @@ from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 from pydantic import BaseModel
 
-from backend.api.dependencies import get_db, get_current_user
-from backend.models.feedback import Feedback as FeedbackModel
-from backend.models.user import User as UserModel
+from api.dependencies import get_db, get_current_user
+from models.feedback import Feedback as FeedbackModel
+from models.user import User as UserModel
 
 router = APIRouter()
 

backend/api/routes/questions.py

@@ -1,14 +1,15 @@
-from fastapi import APIRouter
-# MODIFIÉ: Import des nouveaux modèles
-from backend.models.question import QuestionRequest, QuestionResponse
-from backend.services.question_handler import QuestionHandler
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from api.dependencies import get_db
+from models.question import QuestionRequest, QuestionResponse
+from services.question_handler import QuestionHandler
 
 router = APIRouter()
 handler = QuestionHandler()
 
 # MODIFIÉ: Utilisation du response_model pour garantir le format de sortie
 @router.post("/ask", response_model=QuestionResponse)
-def ask_question(request: QuestionRequest):
+def ask_question(request: QuestionRequest, db: Session = Depends(get_db)):
     """
     Receives a question, finds context, and returns an AI-generated answer.
     """

backend/api/routes/users.py

@@ -5,9 +5,9 @@ from fastapi.security import OAuth2PasswordRequestForm
 from sqlalchemy.orm import Session
 from datetime import timedelta
 
-from backend.models.user import UserCreate, UserResponse, Token, User as UserModel
-from backend.api.dependencies import get_db
-from backend.utils.security import get_password_hash, verify_password, create_access_token, ACCESS_TOKEN_EXPIRE_MINUTES
+from models.user import UserCreate, UserResponse, Token, User as UserModel
+from api.dependencies import get_db
+from utils.security import get_password_hash, verify_password, create_access_token, ACCESS_TOKEN_EXPIRE_MINUTES
 
 router = APIRouter()
 

backend/config/settings.py

@@ -1,3 +1,4 @@
+# backend/config/settings.py
 from pydantic_settings import BaseSettings
 
 class Settings(BaseSettings):
@@ -6,13 +7,14 @@ class Settings(BaseSettings):
     """
     PROJECT_NAME: str = "Assistant Web Éducatif"
     API_V1_STR: str = "/api/v1"
-
-    # Base de données (PostgreSQL)
+    
     DATABASE_URL: str = "postgresql://postgres:postgres@postgres/assistantWed_db"
-
+    
+    OLLAMA_HOST: str = "http://ollama:11434"
+    OLLAMA_MODEL: str = "tinyllama"
+    
     class Config:
         case_sensitive = True
-        # Permet de lire les variables depuis un fichier .env
         env_file = ".env"
 
-settings = Settings()
+settings = Settings()

backend/entrypoint.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+echo "En attente de PostgreSQL..."
+while ! nc -z postgres 5432; do
+  sleep 1
+done
+echo "PostgreSQL démarré."
+
+# Créer les tables de la base de données
+echo "Initialisation de la base de données..."
+python -m scripts.init_db
+
+# Lancer le serveur Uvicorn
+exec uvicorn main:app --host 0.0.0.0 --port 8000

backend/main.py

@@ -1,8 +1,9 @@
+# backend/main.py
+
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from backend.config.settings import settings
-from backend.models import document 
-from backend.api.routes import questions, documents, users,feedback
+from api.routes import questions, documents, users, feedback
+from config.settings import settings 
 
 app = FastAPI(
     title=settings.PROJECT_NAME,
@@ -10,24 +11,25 @@ app = FastAPI(
     version="0.1.0"
 )
 
-app.include_router(users.router, prefix="/api/v1", tags=["Users"])
-
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Permet toutes les origines (à changer pour la production)
+    allow_origins=["*"],
     allow_credentials=True,
-    allow_methods=["*"],  # Permet toutes les méthodes (GET, POST, etc.)
-    allow_headers=["*"],  # Permet tous les en-têtes
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
+# Les inclusions de routeurs sont correctes
+app.include_router(users.router, prefix="/api/v1", tags=["Users"])
 app.include_router(questions.router, prefix="/api/v1", tags=["Questions"])
 app.include_router(documents.router, prefix="/api/v1", tags=["Documents"])
 app.include_router(feedback.router, prefix="/api/v1", tags=["Feedback"])
 
+
 @app.get("/")
 def read_root():
     return {"message": "Bienvenue sur l'API de l'Assistant Web Éducatif"}
 
 @app.get("/health")
 def health_check():
-    return {"status": "ok"}
+    return {"status": "ok"}

backend/models/document.py

@@ -1,6 +1,6 @@
 from sqlalchemy import Column, Integer, String, DateTime
 from sqlalchemy.sql import func
-from backend.config.database import Base
+from config.database import Base
 
 class Document(Base):
     __tablename__ = "documents"

backend/models/feedback.py

@@ -1,7 +1,7 @@
 # backend/models/feedback.py
 from sqlalchemy import Column, Integer, String, Text, DateTime
 from sqlalchemy.sql import func
-from backend.config.database import Base
+from config.database import Base
 
 class Feedback(Base):
     __tablename__ = "feedback"

backend/models/question.py

@@ -1,17 +1,14 @@
-# backend/models/question.py
-
 from pydantic import BaseModel, Field
 from typing import Optional, List
 
 class QuestionRequest(BaseModel):
     question: str = Field(..., min_length=5, max_length=500)
-
 class Source(BaseModel):
-    document_id: Optional[int]
+    document: str
     page: Optional[int]
 
 class QuestionResponse(BaseModel):
     question: str
     answer: str
     sources: List[Source]
-    cached: bool = False 
+    cached: bool = False

backend/models/user.py

@@ -2,7 +2,7 @@
 
 import enum
 from sqlalchemy import Column, Integer, String, Enum
-from backend.config.database import Base
+from config.database import Base
 from pydantic import BaseModel
 
 

backend/services/document_processor.py

@@ -1,35 +1,86 @@
 import fitz  # PyMuPDF
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from typing import List, Dict
+import re
 
+def clean_text(text: str) -> str:
+    """Nettoie le texte extrait du PDF."""
+    text = re.sub(r' +', ' ', text)
+    text = re.sub(r'\n{3,}', '\n\n', text)
+    text = '\n'.join(line.strip() for line in text.split('\n'))
+    return text.strip()
 
 def extract_pages_from_pdf(file_path: str) -> List[Dict]:
     """Extrait le contenu de chaque page et son numéro."""
     doc = fitz.open(file_path)
     pages_content = []
+    
     for page_num, page in enumerate(doc):
-        pages_content.append({
-            "page_number": page_num + 1,
-            "content": page.get_text()
-        })
+        raw_text = page.get_text()
+        cleaned_text = clean_text(raw_text)
+        if len(cleaned_text.strip()) > 50: 
+            pages_content.append({
+                "page_number": page_num + 1,
+                "content": cleaned_text
+            })
+        else:
+            print(f"⚠️  Page {page_num + 1} ignorée (trop courte)")
+    
+    print(f"✅ {len(pages_content)} pages extraites du PDF")
     return pages_content
 
-
 def split_text_into_chunks(pages: List[Dict]) -> List[Dict]:
     """Découpe le texte de chaque page en morceaux en conservant les métadonnées."""
     text_splitter = RecursiveCharacterTextSplitter(
-        chunk_size=1000,
-        chunk_overlap=200,
-        length_function=len
+        chunk_size=1500,        
+        chunk_overlap=300,      
+        length_function=len,
+        separators=[
+            "\n\n\n",          
+            "\n\n",             
+            "\n",               
+            ". ",               
+            " ",                
+            ""
+        ]
     )
     
     all_chunks = []
+    chunk_global_index = 0
+    
     for page in pages:
+        page_num = page["page_number"]
         chunks_on_page = text_splitter.split_text(page["content"])
-        for chunk in chunks_on_page:
+        
+        for local_idx, chunk_text in enumerate(chunks_on_page):
+            if len(chunk_text.strip()) < 100:  
+                print(f"⚠️  Chunk ignoré (trop court) - Page {page_num}")
+                continue
             all_chunks.append({
-                "text": chunk,
-                "metadata": {"page": page["page_number"]}
+                "text": chunk_text.strip(),
+                "metadata": {
+                    "page": page_num,
+                    "chunk_index_on_page": local_idx,
+                    "global_chunk_index": chunk_global_index,
+                    "chunk_length": len(chunk_text)
+                }
             })
-            
-    return all_chunks
+            chunk_global_index += 1
+    
+    print(f"✅ {len(all_chunks)} chunks créés au total")
+    if all_chunks:
+        avg_length = sum(c["metadata"]["chunk_length"] for c in all_chunks) / len(all_chunks)
+        print(f"📊 Longueur moyenne des chunks : {avg_length:.0f} caractères")  
+    return all_chunks
+def preview_chunks(chunks: List[Dict], n: int = 3):
+    """Affiche les n premiers chunks pour vérifier la qualité du découpage."""
+    print(f"\n🔍 Aperçu des {min(n, len(chunks))} premiers chunks :\n")
+    
+    for i, chunk in enumerate(chunks[:n]):
+        text = chunk["text"]
+        meta = chunk["metadata"]
+        
+        print(f"--- Chunk #{i+1} (Page {meta['page']}) ---")
+        print(f"Longueur : {meta['chunk_length']} caractères")
+        print(f"Texte (100 premiers caractères) : {text[:100]}...")
+        print()

backend/services/ollama_client.py

@@ -1,4 +1,3 @@
-# backend/services/ollama_client.py
 import requests
 import json
 import os
@@ -6,32 +5,54 @@ import os
 OLLAMA_HOST = os.getenv("OLLAMA_HOST", "http://localhost:11434")
 
 def generate_response(question: str, context: str) -> str:
-    """
-    Génère une réponse en utilisant Ollama avec un contexte.
-    """
-    prompt = f"""
-    En te basant uniquement sur le contexte suivant, réponds à la question.
-    Contexte :
-    ---
-    {context}
-    ---
-    Question : {question}
-    """
+    prompt = f"""Tu es un assistant éducatif spécialisé en Recherche Opérationnelle.
+
+CONTEXTE DU DOCUMENT :
+{context}
+
+QUESTION DE L'ÉTUDIANT :
+{question}
+
+INSTRUCTIONS IMPORTANTES :
+1. Réponds UNIQUEMENT en utilisant les informations du contexte ci-dessus
+2. Si l'information n'existe PAS dans le contexte, réponds EXACTEMENT : "L'information n'est pas disponible dans le document fourni."
+3. Sois précis, pédagogique et structuré
+4. Utilise des exemples du contexte si disponibles
+5. Ne cite JAMAIS d'informations externes au contexte
+
+RÉPONSE :"""
     
+    full_response_text = ""
     try:
-        response = requests.post(
+        print(f"Envoi de la requête en streaming à Ollama sur l'hôte : {OLLAMA_HOST}")
+        with requests.post(
             f"{OLLAMA_HOST}/api/generate",
             json={
-                "model": "mistral", 
+                "model": "mistral",  
                 "prompt": prompt,
-                "stream": False
+                "stream": True,
+                "options": {
+                    "temperature": 0.1,  
+                    "num_predict": 500   
+                }
             },
-            timeout=60
-        )
-        response.raise_for_status()
-        full_response = response.text.strip().split('\n')[-1]
-        return json.loads(full_response).get("response", "Aucune réponse générée.")
+            stream=True,
+            timeout=300
+        ) as response:
+            response.raise_for_status()
+            for line in response.iter_lines():
+                if line:
+                    try:
+                        chunk = json.loads(line)
+                        full_response_text += chunk.get("response", "")
+                        if chunk.get("done"):
+                            break
+                    except json.JSONDecodeError:
+                        print(f"Ligne JSON invalide reçue d'Ollama: {line}")
+        
+        print("Réponse complète reçue d'Ollama.")
+        return full_response_text.strip()
 
     except requests.exceptions.RequestException as e:
-        print(f"Error calling Ollama: {e}")
+        print(f"Erreur lors de l'appel à Ollama : {e}")
         return "Désolé, une erreur est survenue lors de la génération de la réponse."

backend/services/question_handler.py

@@ -1,35 +1,51 @@
-# backend/services/question_handler.py
-
-from backend.services.vector_store import VectorStore
-from backend.services.ollama_client import generate_response
-from backend.services.cache_manager import CacheManager 
-
+from sqlalchemy.orm import Session
+from services.vector_store import VectorStore
+from services.ollama_client import generate_response
+from services.cache_manager import CacheManager
+from models.document import Document 
 class QuestionHandler:
     def __init__(self):
         self.vector_store = VectorStore()
-        self.cache = CacheManager() 
+        self.cache = CacheManager()
 
-    def get_answer(self, question: str):
+    def get_answer(self, question: str, db: Session):
         cached_answer = self.cache.get(question)
         if cached_answer:
-            print(f"Réponse trouvée dans le cache pour : '{question}'")
             return {**cached_answer, "cached": True}
-        print(f"Réponse non trouvée dans le cache pour : '{question}'. Génération en cours...")
-        search_results = self.vector_store.find_similar_chunks(question)
+
+        search_results = self.vector_store.find_similar_chunks(question, n_results=5)
+        
+        if not search_results or not search_results.get("documents") or not search_results["documents"][0]:
+             return {
+                "question": question,
+                "answer": "Désolé, je n'ai trouvé aucune information pertinente dans les documents fournis pour répondre à cette question.",
+                "sources": [],
+                "cached": False
+            }
+
         context_texts = search_results["documents"][0]
-        sources_metadata = search_results["metadatas"][0]       
+        sources_metadata = search_results["metadatas"][0]
         context = "\n---\n".join(context_texts)
+        
         answer = generate_response(question, context)
+
+        doc_ids = {meta.get("document_id") for meta in sources_metadata if meta.get("document_id") is not None}
+        documents = db.query(Document).filter(Document.id.in_(doc_ids)).all()
+        doc_titles = {doc.id: doc.file_name for doc in documents}
+        
         sources = []
         for meta in sources_metadata:
+            doc_id = meta.get("document_id")
             sources.append({
-                "document_id": meta.get("document_id"),
+                "document": doc_titles.get(doc_id, "Titre inconnu"), 
                 "page": meta.get("page")
             })
+
         final_response = {
             "question": question,
             "answer": answer,
             "sources": sources
         }
+
         self.cache.set(question, final_response)
         return {**final_response, "cached": False}

backend/services/vector_store.py

@@ -5,19 +5,25 @@ from typing import List, Dict
 class VectorStore:
     def __init__(self):
         self.client = chromadb.PersistentClient(path="data/chroma_db")
-        self.embedding_model = SentenceTransformer('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')
-        self.collection = self.client.get_or_create_collection(name="documents")
+        
+        self.embedding_model = SentenceTransformer('intfloat/multilingual-e5-large')
+        
+        self.collection = self.client.get_or_create_collection(
+            name="documents",
+            metadata={"hnsw:space": "cosine"} 
+        )
 
     def add_document_chunks(self, doc_id: int, chunks: List[Dict]):
         if not chunks:
             return
 
         texts = [chunk["text"] for chunk in chunks]
-        embeddings = self.embedding_model.encode(texts)
+        prefixed_texts = [f"passage: {text}" for text in texts]
+        embeddings = self.embedding_model.encode(prefixed_texts, normalize_embeddings=True)
         
         metadatas = []
         for i, chunk in enumerate(chunks):
-            meta = chunk["metadata"]
+            meta = chunk["metadata"].copy()
             meta["document_id"] = doc_id
             meta["chunk_index"] = i
             metadatas.append(meta)
@@ -25,21 +31,30 @@ class VectorStore:
         ids = [f"doc_{doc_id}_chunk_{i}" for i, _ in enumerate(chunks)]
 
         self.collection.add(
-            embeddings=embeddings,
+            embeddings=embeddings.tolist(),
             metadatas=metadatas,
-            documents=texts,
+            documents=texts,  
             ids=ids
         )
-        print(f"Ajout de {len(chunks)} chunks pour le document {doc_id} à ChromaDB.")
+        print(f"✅ Ajout de {len(chunks)} chunks pour le document {doc_id} à ChromaDB.")
 
-    def find_similar_chunks(self, question: str, n_results: int = 3) -> Dict:
+    def find_similar_chunks(self, question: str, n_results: int = 5) -> Dict:
         """Trouve les chunks pertinents et retourne leur contenu et métadonnées."""
-        query_embedding = self.embedding_model.encode(question)
+        
+        prefixed_question = f"query: {question}"
+        query_embedding = self.embedding_model.encode(prefixed_question, normalize_embeddings=True)
         
         results = self.collection.query(
             query_embeddings=[query_embedding.tolist()],
             n_results=n_results,
-            include=["documents", "metadatas"] 
+            include=["documents", "metadatas", "distances"]  
         )
         
+        if results.get("distances"):
+            distances = results["distances"][0]
+            print(f"\n📊 Scores de similarité pour '{question}':")
+            for i, dist in enumerate(distances[:3]):
+                similarity = 1 - dist  
+                print(f"  Chunk {i+1}: {similarity:.3f}")
+        
         return results

docker-compose.yml

@@ -22,6 +22,8 @@ services:
       - ollama_data:/root/.ollama
     ports:
       - "11434:11434"
+    environment:
+      - OLLAMA_KEEP_ALIVE=-1
   
  
   redis:

frontend/src/App.jsx

@@ -15,6 +15,18 @@ function App() {
       return;
     }
     try {
+      let questionText = '';
+      const messageIndex = messages.indexOf(message);
+      for (let i = messageIndex - 1; i >= 0; i--) {
+        if (messages[i].sender === 'user') {
+          questionText = messages[i].text;
+          break;
+        }
+      }
+      if (!questionText) {
+        alert("Impossible de trouver la question originale.");
+        return;
+      }
       await fetch('http://localhost:8000/api/v1/feedback', {
         method: 'POST',
         headers: {
@@ -22,7 +34,7 @@ function App() {
           'Authorization': `Bearer ${token}`
         },
         body: JSON.stringify({
-          question: messages[messages.indexOf(message) - 1].text, // Trouve la question précédente
+          question: questionText,
           answer: message.text,
           rating: rating
         })
@@ -44,13 +56,10 @@ function App() {
     setPrompt('');
     setIsLoading(true);
 
-    // --- NOUVEAU : Appel à l'API Backend ---
     try {
       const response = await fetch('http://localhost:8000/api/v1/ask', {
         method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
+        headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ question: currentPrompt }),
       });
 
@@ -60,10 +69,10 @@ function App() {
 
       const data = await response.json();
 
-      const apiResponse = { 
-        sender: 'bot', 
+      const apiResponse = {
+        sender: 'bot',
         text: data.answer,
-        sources: data.sources // On sauvegarde les sources
+        sources: data.sources
       };
       setMessages(prev => [...prev, apiResponse]);
 
@@ -77,34 +86,34 @@ function App() {
     } finally {
       setIsLoading(false);
     }
-    // --- FIN DU NOUVEAU BLOC ---
   };
 
   return (
     <div className="app-container">
       <header className="app-header">
-        <h1>Assistant Web Educatif</h1>
+        <h1>Assistant Web Éducatif</h1>
       </header>
 
       <div className="chat-window">
         {messages.map((msg, index) => (
           <div key={index} className={`message ${msg.sender}`}>
             <p>{msg.text}</p>
-            {/* Affiche les sources si elles existent */}
-            {msg.sender === 'bot' && msg.sources && (
+            
+            {msg.sender === 'bot' && msg.sources && msg.sources.length > 0 && (
               <div className="sources">
                 <strong>Sources:</strong>
                 <ul>
                   {msg.sources.map((source, i) => (
                     <li key={i}>
-                      Document ID: {source.document_id}, Page: {source.page}
+                      {/* LIGNE CORRIGÉE CI-DESSOUS */}
+                      {source.document}, Page: {source.page}
                     </li>
                   ))}
                 </ul>
               </div>
             )}
-            {/* boutons de feedback pour les messages du bot */}
-            {msg.sender === 'bot' && !msg.sources && (
+
+            {msg.sender === 'bot' && msg.text !== "Désolé, une erreur est survenue. Veuillez réessayer." && (
               <div className="feedback-buttons">
                 <button onClick={() => handleFeedback(msg, 1)}>👍</button>
                 <button onClick={() => handleFeedback(msg, -1)}>👎</button>
@@ -120,7 +129,7 @@ function App() {
           type="text"
           value={prompt}
           onChange={(e) => setPrompt(e.target.value)}
-          placeholder="Posez votre question ..."
+          placeholder="Posez votre question..."
           disabled={isLoading}
         />
         <button type="submit" disabled={isLoading}>Envoyer</button>

scripts/init_db.py

@@ -1,6 +1,6 @@
-from backend.config.database import Base, engine
-from backend.models import document
-from backend.models import user
+from config.database import Base, engine
+from models import document
+from models import user
 
 def init_db():
     print("Création des tables de la base de données...")

scripts/set_user_role.py

@@ -1,8 +1,8 @@
 # scripts/set_user_role.py
 import sys
 from sqlalchemy.orm import Session
-from backend.config.database import SessionLocal
-from backend.models.user import User, RoleEnum
+from config.database import SessionLocal
+from models.user import User, RoleEnum
 
 def set_user_role(email: str, role_input: str):
     db: Session = SessionLocal()