Initial deploy

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,33 @@
+# ── Build Frontend ────────────────────────────────────────────────────────────
+FROM node:20-alpine AS frontend-builder
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm ci
+COPY frontend/ ./
+ARG VITE_API_URL=/api
+ENV VITE_API_URL=$VITE_API_URL
+RUN npm run build
+
+# ── Backend + Frontend servi par FastAPI ──────────────────────────────────────
+FROM python:3.10-slim
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY backend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY backend/ .
+
+# Copier le build frontend dans le dossier static du backend
+COPY --from=frontend-builder /app/frontend/dist ./static
+
+RUN mkdir -p /app/chroma_db /app/documents
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=15s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,8 +1,8 @@
 ---
-title: PaperBrainAI
-emoji: 🐢
-colorFrom: blue
-colorTo: yellow
+title: PaperBrain
+emoji: 💻
+colorFrom: green
+colorTo: indigo
 sdk: docker
 pinned: false
 ---

backend/.dockerignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.venv/
+venv/
+env/
+chroma_db/
+smartstudydb
+.git/
+.idea/
+.vscode/

backend/.spyproject/config/backups/codestyle.ini.bak

@@ -0,0 +1,8 @@
+[codestyle]
+indentation = True
+edge_line = True
+edge_line_columns = 79
+
+[main]
+version = 0.2.0
+

backend/.spyproject/config/backups/encoding.ini.bak

@@ -0,0 +1,6 @@
+[encoding]
+text_encoding = utf-8
+
+[main]
+version = 0.2.0
+

backend/.spyproject/config/backups/vcs.ini.bak

@@ -0,0 +1,7 @@
+[vcs]
+use_version_control = False
+version_control_system = 
+
+[main]
+version = 0.2.0
+

backend/.spyproject/config/backups/workspace.ini.bak

@@ -0,0 +1,12 @@
+[workspace]
+restore_data_on_startup = True
+save_data_on_exit = True
+save_history = True
+save_non_project_files = False
+project_type = 'empty-project-type'
+recent_files = ['app\\auth\\jwt_handler.py', '.dockerignore', 'app\\main.py', 'app\\tools\\tool_flashcards.py', 'app\\tools\\tool_quiz.py', 'app\\tools\\tool_rag_qa.py', 'app\\tools\\tool_resume.py', 'app\\tools\\tool_simple_explain.py', 'app\\agent.py', 'app\\ingest.py', 'app\\rag_evaluator.py']
+
+[main]
+version = 0.2.0
+recent_files = []
+

backend/.spyproject/config/codestyle.ini

@@ -0,0 +1,8 @@
+[codestyle]
+indentation = True
+edge_line = True
+edge_line_columns = 79
+
+[main]
+version = 0.2.0
+

backend/.spyproject/config/defaults/defaults-codestyle-0.2.0.ini

@@ -0,0 +1,5 @@
+[codestyle]
+indentation = True
+edge_line = True
+edge_line_columns = 79
+

backend/.spyproject/config/defaults/defaults-encoding-0.2.0.ini

@@ -0,0 +1,3 @@
+[encoding]
+text_encoding = utf-8
+

backend/.spyproject/config/defaults/defaults-vcs-0.2.0.ini

@@ -0,0 +1,4 @@
+[vcs]
+use_version_control = False
+version_control_system = 
+

backend/.spyproject/config/defaults/defaults-workspace-0.2.0.ini

@@ -0,0 +1,6 @@
+[workspace]
+restore_data_on_startup = True
+save_data_on_exit = True
+save_history = True
+save_non_project_files = False
+

backend/.spyproject/config/encoding.ini

@@ -0,0 +1,6 @@
+[encoding]
+text_encoding = utf-8
+
+[main]
+version = 0.2.0
+

backend/.spyproject/config/vcs.ini

@@ -0,0 +1,7 @@
+[vcs]
+use_version_control = False
+version_control_system = 
+
+[main]
+version = 0.2.0
+

backend/.spyproject/config/workspace.ini

@@ -0,0 +1,12 @@
+[workspace]
+restore_data_on_startup = True
+save_data_on_exit = True
+save_history = True
+save_non_project_files = False
+project_type = 'empty-project-type'
+recent_files = ['app\\auth\\jwt_handler.py', '.dockerignore', 'app\\main.py', 'app\\tools\\tool_flashcards.py', 'app\\tools\\tool_quiz.py', 'app\\tools\\tool_rag_qa.py', 'app\\tools\\tool_resume.py', 'app\\tools\\tool_simple_explain.py', 'app\\agent.py', 'app\\ingest.py', 'app\\rag_evaluator.py', 'app\\rag.py', 'app\\router_service.py', 'app\\schemas_new.py', 'app\\schemas.py', 'app\\auth\\middleware.py', 'app\\db\\crud.py', 'app\\db\\database.py', 'app\\db\\models.py']
+
+[main]
+version = 0.2.0
+recent_files = []
+

backend/Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN mkdir -p /app/chroma_db /app/documents
+
+# HuggingFace Spaces impose le port 7860
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=15s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

backend/app/.spyproject/config/codestyle.ini

@@ -0,0 +1,8 @@
+[codestyle]
+indentation = True
+edge_line = True
+edge_line_columns = 79
+
+[main]
+version = 0.2.0
+

backend/app/.spyproject/config/defaults/defaults-codestyle-0.2.0.ini

@@ -0,0 +1,5 @@
+[codestyle]
+indentation = True
+edge_line = True
+edge_line_columns = 79
+

backend/app/.spyproject/config/defaults/defaults-encoding-0.2.0.ini

@@ -0,0 +1,3 @@
+[encoding]
+text_encoding = utf-8
+

backend/app/.spyproject/config/defaults/defaults-vcs-0.2.0.ini

@@ -0,0 +1,4 @@
+[vcs]
+use_version_control = False
+version_control_system = 
+

backend/app/.spyproject/config/defaults/defaults-workspace-0.2.0.ini

@@ -0,0 +1,6 @@
+[workspace]
+restore_data_on_startup = True
+save_data_on_exit = True
+save_history = True
+save_non_project_files = False
+

backend/app/.spyproject/config/encoding.ini

@@ -0,0 +1,6 @@
+[encoding]
+text_encoding = utf-8
+
+[main]
+version = 0.2.0
+

backend/app/.spyproject/config/vcs.ini

@@ -0,0 +1,7 @@
+[vcs]
+use_version_control = False
+version_control_system = 
+
+[main]
+version = 0.2.0
+

backend/app/.spyproject/config/workspace.ini

@@ -0,0 +1,12 @@
+[workspace]
+restore_data_on_startup = True
+save_data_on_exit = True
+save_history = True
+save_non_project_files = False
+project_type = 'empty-project-type'
+recent_files = []
+
+[main]
+version = 0.2.0
+recent_files = []
+

backend/app/agent.py

@@ -0,0 +1,313 @@
+import asyncio
+import json
+import re
+import os
+from huggingface_hub import InferenceClient
+
+# ── Config ────────────────────────────────────────────────────────────────────
+HF_TOKEN   = os.getenv("HF_TOKEN", "")
+MODEL_NAME = os.getenv("HF_MODEL", "Qwen/Qwen2.5-72B-Instruct")
+
+conversation_store: dict[str, list] = {}
+
+_client: InferenceClient | None = None
+
+
+def _get_client() -> InferenceClient:
+    global _client
+    if _client is None:
+        _client = InferenceClient(token=HF_TOKEN or None)
+    return _client
+
+
+# ── Core call — utilise chat_completion (compatible tous providers HF) ─────────
+def _call_hf(
+    system: str,
+    user: str,
+    max_tokens: int = 1024,
+    temperature: float = 0.4,
+) -> str:
+    try:
+        client = _get_client()
+        response = client.chat_completion(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user",   "content": user},
+            ],
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        raise Exception(f"HuggingFace InferenceClient error: {str(e)}")
+
+
+# ── JSON helpers ──────────────────────────────────────────────────────────────
+def _fix_json(s: str) -> str:
+    s = re.sub(r',\s*([}\]])', r'\1', s)
+    s = re.sub(r'[\x00-\x1f\x7f]', ' ', s)
+    return s
+
+
+def _extract_json_array(raw: str) -> list:
+    cleaned = re.sub(r'```(?:json)?\s*', '', raw)
+    cleaned = re.sub(r'```', '', cleaned).strip()
+
+    try:
+        result = json.loads(cleaned)
+        if isinstance(result, list):
+            return result
+    except Exception:
+        pass
+
+    start = cleaned.find('[')
+    if start != -1:
+        depth = 0
+        for i, ch in enumerate(cleaned[start:], start):
+            if ch == '[':
+                depth += 1
+            elif ch == ']':
+                depth -= 1
+                if depth == 0:
+                    candidate = cleaned[start:i + 1]
+                    for attempt in (candidate, _fix_json(candidate)):
+                        try:
+                            result = json.loads(attempt)
+                            if isinstance(result, list):
+                                return result
+                        except Exception:
+                            pass
+                    break
+
+    match = re.search(r'\[[\s\S]*\]', cleaned)
+    if match:
+        for attempt in (match.group(), _fix_json(match.group())):
+            try:
+                return json.loads(attempt)
+            except Exception:
+                pass
+
+    return []
+
+
+# ── Conversation history ──────────────────────────────────────────────────────
+def _get_history(user_id: str) -> list:
+    return conversation_store.get(user_id, [])
+
+
+def _save_history(user_id: str, user_msg: str, ai_msg: str) -> None:
+    if user_id not in conversation_store:
+        conversation_store[user_id] = []
+    conversation_store[user_id].append({"user": user_msg, "assistant": ai_msg})
+    conversation_store[user_id] = conversation_store[user_id][-5:]
+
+
+# ── Async entry point ─────────────────────────────────────────────────────────
+async def run_agent(action: str, data: dict) -> dict:
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, _run_sync, action, data)
+
+
+def _run_sync(action: str, data: dict) -> dict:
+    dispatch = {
+        "chat":       _chat,
+        "quiz":       _quiz,
+        "flashcards": _flashcards,
+        "explain":    _explain,
+        "resume":     _resume,
+        "rag-qa":     _rag_qa,
+    }
+    handler = dispatch.get(action)
+    if handler:
+        return handler(data)
+    return {"answer": f"Unknown action: {action}", "action": action}
+
+
+# ── Action handlers ───────────────────────────────────────────────────────────
+
+def _chat(data: dict) -> dict:
+    query   = data.get("query", "")
+    user_id = data.get("user_id", "anonymous")
+    history = _get_history(user_id)
+
+    history_text = ""
+    if history:
+        history_text = "Conversation récente :\n" + "\n".join(
+            f"Utilisateur: {h['user']}\nAssistant: {h['assistant']}"
+            for h in history
+        ) + "\n\n"
+
+    system = (
+        "Tu es PaperBrain AI, un assistant pédagogique pour les étudiants. "
+        "Aide les étudiants à comprendre leurs cours, préparer leurs examens et apprendre efficacement. "
+        "Réponds toujours dans la même langue que la question. "
+        "Sois clair, structuré et pédagogique."
+    )
+    user = f"{history_text}Utilisateur : {query}"
+
+    answer = _call_hf(system, user, max_tokens=1024, temperature=0.5)
+    _save_history(user_id, query, answer)
+    return {"answer": answer, "user_id": user_id}
+
+
+def _quiz(data: dict) -> dict:
+    topic         = data.get("topic", "")
+    num_questions = data.get("num_questions", 5)
+    difficulty    = data.get("difficulty", "medium")
+
+    difficulty_map = {
+        "easy":   "simples et directes, pour débutants",
+        "medium": "de difficulté intermédiaire",
+        "hard":   "difficiles et approfondies, pour experts",
+    }
+    level_desc = difficulty_map.get(difficulty, "de difficulté intermédiaire")
+
+    system = (
+        "Tu es un générateur de quiz pédagogique. "
+        "Tu réponds UNIQUEMENT avec un tableau JSON valide, sans texte avant ni après, sans balises markdown."
+    )
+    user = (
+        f"Génère {num_questions} questions QCM ({level_desc}) sur : \"{topic}\".\n\n"
+        "Chaque objet JSON doit contenir : question, options (tableau de 4 chaînes "
+        "\"A) ...\", \"B) ...\", \"C) ...\", \"D) ...\"), correct_answer (A/B/C/D), explanation.\n\n"
+        "Réponds UNIQUEMENT avec le tableau JSON."
+    )
+
+    raw = _call_hf(system, user, max_tokens=1500, temperature=0.3)
+    questions = _extract_json_array(raw)
+
+    if questions:
+        clean = [
+            {
+                "question":       str(q.get("question", "")),
+                "options":        list(q.get("options", [])),
+                "correct_answer": str(q.get("correct_answer", "A")),
+                "explanation":    str(q.get("explanation", "")),
+            }
+            for q in questions
+            if isinstance(q, dict) and q.get("question") and q.get("options")
+        ]
+        if clean:
+            return {"questions": clean, "topic": topic, "difficulty": difficulty}
+
+    return {"questions": [], "topic": topic, "error": "JSON invalide.", "raw_preview": raw[:300]}
+
+
+def _flashcards(data: dict) -> dict:
+    topic     = data.get("topic", "")
+    num_cards = data.get("num_cards", 8)
+
+    system = (
+        "Tu es un générateur de flashcards pédagogiques. "
+        "Tu réponds UNIQUEMENT avec un tableau JSON valide, sans texte avant ni après, sans balises markdown."
+    )
+    user = (
+        f"Génère {num_cards} flashcards sur : \"{topic}\".\n\n"
+        "Chaque objet JSON doit contenir : front (question/terme) et back (réponse/définition).\n\n"
+        "Réponds UNIQUEMENT avec le tableau JSON."
+    )
+
+    raw   = _call_hf(system, user, max_tokens=1024, temperature=0.3)
+    cards = _extract_json_array(raw)
+
+    if cards:
+        clean = [
+            {"front": str(c.get("front", "")), "back": str(c.get("back", ""))}
+            for c in cards
+            if isinstance(c, dict) and c.get("front") and c.get("back")
+        ]
+        if clean:
+            return {"flashcards": clean, "topic": topic}
+
+    return {"flashcards": [], "topic": topic, "error": "Impossible de parser les flashcards."}
+
+
+def _explain(data: dict) -> dict:
+    concept = data.get("concept", "")
+    level   = data.get("level", "intermediate")
+
+    level_map = {
+        "beginner":     "de manière très simple, avec des analogies du quotidien, pour un lycéen",
+        "intermediate": "clairement avec les concepts essentiels, pour un étudiant universitaire",
+        "advanced":     "de manière approfondie et technique, pour un expert du domaine",
+    }
+    level_desc = level_map.get(level, level_map["intermediate"])
+
+    system = (
+        "Tu es un professeur pédagogue expert. "
+        "Réponds dans la même langue que le concept demandé."
+    )
+    user = (
+        f"Explique le concept suivant {level_desc}.\n\n"
+        "Structure ta réponse avec :\n"
+        "1. Définition courte et claire\n"
+        "2. Points clés à retenir\n"
+        "3. Exemple concret\n"
+        "4. Applications pratiques\n\n"
+        f"Concept : {concept}"
+    )
+
+    explanation = _call_hf(system, user, max_tokens=1024, temperature=0.5)
+    return {"explanation": explanation, "concept": concept, "level": level}
+
+
+def _resume(data: dict) -> dict:
+    text = data.get("text", "")
+    if not text:
+        return {"summary": "Aucun texte fourni."}
+
+    system = (
+        "Tu es un assistant pédagogique expert en synthèse de documents. "
+        "Réponds dans la même langue que le texte fourni."
+    )
+    user = (
+        "Résume le texte suivant de façon claire et structurée.\n"
+        "Utilise des titres et des points clés.\n\n"
+        f"Texte :\n{text[:3000]}"
+    )
+
+    summary = _call_hf(system, user, max_tokens=1024, temperature=0.4)
+    return {"summary": summary}
+
+
+def _rag_qa(data: dict) -> dict:
+    query = data.get("query", "")
+
+    try:
+        from app.rag import query_documents
+
+        results   = query_documents(query, n_results=4)
+        documents = results.get("documents", [[]])[0]
+        metadatas = results.get("metadatas",  [[]])[0]
+        distances = results.get("distances",  [[]])[0]
+
+        THRESHOLD = 0.8
+        relevant  = [
+            (doc, meta)
+            for doc, meta, dist in zip(documents, metadatas, distances)
+            if dist < THRESHOLD
+        ]
+
+        if not relevant:
+            return {
+                "answer":  "Aucune information pertinente trouvée dans vos documents.",
+                "sources": [],
+            }
+
+        context = "\n\n---\n\n".join([doc for doc, _ in relevant])
+        sources  = list(set([meta.get("source", "inconnu") for _, meta in relevant]))
+
+        system = (
+            "Tu es un assistant pédagogique RAG. "
+            "Réponds à la question en te basant UNIQUEMENT sur le contexte fourni. "
+            "Si la réponse n'est pas dans le contexte, dis-le clairement. "
+            "Réponds dans la même langue que la question."
+        )
+        user = f"Contexte :\n{context[:3000]}\n\nQuestion : {query}"
+
+        answer = _call_hf(system, user, max_tokens=1024, temperature=0.4)
+        return {"answer": answer, "sources": sources}
+
+    except Exception as e:
+        return {"answer": f"Erreur RAG : {str(e)}", "sources": []}

backend/app/auth/jwt_handler.py

@@ -0,0 +1,19 @@
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+
+SECRET_KEY = "smartstudy_secret_key_2024_change_in_production"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_HOURS = 24
+
+
+def create_token(data: dict) -> str:
+    payload = data.copy()
+    payload["exp"] = datetime.utcnow() + timedelta(hours=ACCESS_TOKEN_EXPIRE_HOURS)
+    return jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)
+
+
+def decode_token(token: str) -> dict:
+    try:
+        return jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+    except JWTError:
+        return None

backend/app/auth/middleware.py

@@ -0,0 +1,33 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from sqlalchemy.orm import Session
+from app.db.database import get_db
+from app.auth.jwt_handler import decode_token
+from app.db.crud import get_user_by_id
+
+security = HTTPBearer()
+
+
+def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+    db: Session = Depends(get_db)
+):
+    token = credentials.credentials
+    payload = decode_token(token)
+
+    if not payload:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token invalide ou expiré"
+        )
+
+    user_id = int(payload.get("sub", 0))
+    user = get_user_by_id(db, user_id)
+
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Utilisateur non trouvé"
+        )
+
+    return user

backend/app/db/crud.py

@@ -0,0 +1,160 @@
+import hashlib
+import secrets
+from datetime import datetime, timedelta
+from sqlalchemy.orm import Session
+from app.db.models import User, QuizResult, StudySession
+
+
+# ── Password
+def hash_password(password: str) -> str:
+    salt = secrets.token_hex(16)
+    hashed = hashlib.sha256((password + salt).encode()).hexdigest()
+    return f"{salt}:{hashed}"
+
+
+def verify_password(plain: str, hashed: str) -> bool:
+    try:
+        salt, hash_val = hashed.split(":")
+        return hashlib.sha256((plain + salt).encode()).hexdigest() == hash_val
+    except:
+        return False
+
+
+# ── User CRUD
+def get_user_by_email(db: Session, email: str):
+    return db.query(User).filter(User.email == email).first()
+
+
+def get_user_by_username(db: Session, username: str):
+    return db.query(User).filter(User.username == username).first()
+
+
+def get_user_by_id(db: Session, user_id: int):
+    return db.query(User).filter(User.id == user_id).first()
+
+
+def create_user(db: Session, username: str, email: str, password: str):
+    user = User(
+        username=username,
+        email=email,
+        password=hash_password(password),
+        created_at=datetime.utcnow()
+    )
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+    return user
+
+
+def update_streak(db: Session, user: User):
+    now = datetime.utcnow()
+    if user.last_login:
+        diff = (now.date() - user.last_login.date()).days
+        if diff == 1:
+            user.streak_days += 1
+        elif diff > 1:
+            user.streak_days = 1
+    else:
+        user.streak_days = 1
+    user.last_login = now
+    db.commit()
+
+
+# ── Quiz Results
+def save_quiz_result(db: Session, user_id: int, req):
+    result = QuizResult(
+        user_id=user_id,
+        topic=req.topic,
+        score=req.score,
+        total_questions=req.total_questions,
+        correct_answers=req.correct_answers,
+        difficulty=req.difficulty,
+        duration_sec=req.duration_sec
+    )
+    db.add(result)
+
+    # Mise à jour du niveau utilisateur
+    user = get_user_by_id(db, user_id)
+    if user:
+        results = db.query(QuizResult).filter(QuizResult.user_id == user_id).all()
+        if len(results) > 0:
+            avg = sum(r.score for r in results) / len(results)
+            if avg >= 80:
+                user.niveau = "expert"
+            elif avg >= 60:
+                user.niveau = "intermédiaire"
+            else:
+                user.niveau = "débutant"
+
+    db.commit()
+    db.refresh(result)
+    return result
+
+
+# ── Profile
+def get_student_profile(db: Session, user_id: int) -> dict:
+    user = get_user_by_id(db, user_id)
+    if not user:
+        return {}
+
+    quiz_results = db.query(QuizResult).filter(
+        QuizResult.user_id == user_id
+    ).order_by(QuizResult.created_at.desc()).all()
+
+    sessions = db.query(StudySession).filter(
+        StudySession.user_id == user_id
+    ).all()
+
+    scores = [r.score for r in quiz_results]
+    avg_score = round(sum(scores) / len(scores), 1) if scores else 0
+    best_score = max(scores) if scores else 0
+
+    # Top matières
+    subjects = {}
+    for s in sessions:
+        subjects[s.subject] = subjects.get(s.subject, 0) + 1
+    top_subjects = sorted(
+        [{"subject": k, "count": v} for k, v in subjects.items()],
+        key=lambda x: x["count"], reverse=True
+    )[:5]
+
+    recent_quiz = [
+        {
+            "topic": r.topic,
+            "score": r.score,
+            "date": r.created_at.strftime("%d/%m/%Y"),
+            "difficulty": r.difficulty
+        }
+        for r in quiz_results[:10]
+    ]
+
+    return {
+        "user": {
+            "username": user.username,
+            "email": user.email,
+            "niveau": user.niveau,
+            "streak_days": user.streak_days,
+            "member_since": user.created_at.strftime("%d/%m/%Y") if user.created_at else "N/A"
+        },
+        "stats": {
+            "total_sessions": len(sessions),
+            "total_quiz": len(quiz_results),
+            "average_score": avg_score,
+            "best_score": best_score,
+            "top_subjects": top_subjects
+        },
+        "recent_quiz": recent_quiz
+    }
+
+
+def get_progress(db: Session, user_id: int) -> dict:
+    results = db.query(QuizResult).filter(
+        QuizResult.user_id == user_id
+    ).order_by(QuizResult.created_at.asc()).all()
+
+    return {
+        "progression": [
+            {"date": r.created_at.strftime("%d/%m"), "score": r.score, "topic": r.topic}
+            for r in results
+        ]
+    }

backend/app/db/database.py

@@ -0,0 +1,26 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+DATABASE_URL = "sqlite:///./smartstudy.db"
+
+engine = create_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False}
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def create_tables():
+    from app.db.models import User, QuizResult, StudySession, FlashcardProgress
+    Base.metadata.create_all(bind=engine)

backend/app/db/models.py

@@ -0,0 +1,61 @@
+from sqlalchemy import Column, Integer, String, Float, DateTime, ForeignKey, Boolean
+from sqlalchemy.orm import relationship
+from datetime import datetime
+from app.db.database import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id           = Column(Integer, primary_key=True, index=True)
+    username     = Column(String, unique=True, index=True)
+    email        = Column(String, unique=True, index=True)
+    password     = Column(String)
+    niveau       = Column(String, default="débutant")
+    streak_days  = Column(Integer, default=0)
+    last_login   = Column(DateTime, default=datetime.utcnow)
+    created_at   = Column(DateTime, default=datetime.utcnow)
+    is_active    = Column(Boolean, default=True)
+
+    quiz_results  = relationship("QuizResult", back_populates="user")
+    study_sessions = relationship("StudySession", back_populates="user")
+
+
+class QuizResult(Base):
+    __tablename__ = "quiz_results"
+
+    id               = Column(Integer, primary_key=True, index=True)
+    user_id          = Column(Integer, ForeignKey("users.id"))
+    topic            = Column(String)
+    score            = Column(Float)
+    total_questions  = Column(Integer)
+    correct_answers  = Column(Integer)
+    difficulty       = Column(String, default="medium")
+    duration_sec     = Column(Integer, default=0)
+    created_at       = Column(DateTime, default=datetime.utcnow)
+
+    user = relationship("User", back_populates="quiz_results")
+
+
+class StudySession(Base):
+    __tablename__ = "study_sessions"
+
+    id         = Column(Integer, primary_key=True, index=True)
+    user_id    = Column(Integer, ForeignKey("users.id"))
+    action     = Column(String)  # chat, quiz, flashcards, explain, rag-qa
+    subject    = Column(String, default="general")
+    duration   = Column(Integer, default=0)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    user = relationship("User", back_populates="study_sessions")
+
+
+class FlashcardProgress(Base):
+    __tablename__ = "flashcard_progress"
+
+    id         = Column(Integer, primary_key=True, index=True)
+    user_id    = Column(Integer, ForeignKey("users.id"))
+    topic      = Column(String)
+    known      = Column(Integer, default=0)
+    unknown    = Column(Integer, default=0)
+    created_at = Column(DateTime, default=datetime.utcnow)

backend/app/ingest.py

@@ -0,0 +1,123 @@
+import os
+import uuid
+from app.rag import add_documents, get_collection
+
+CHUNK_SIZE = 600
+CHUNK_OVERLAP = 80
+
+
+def chunk_text(text: str, chunk_size: int = CHUNK_SIZE, overlap: int = CHUNK_OVERLAP) -> list:
+    """Découpe le texte en chunks avec overlap."""
+    paragraphs = text.split("\n\n")
+    chunks = []
+    current = ""
+
+    for para in paragraphs:
+        para = para.strip()
+        if not para:
+            continue
+        if len(current) + len(para) < chunk_size:
+            current += ("\n\n" + para) if current else para
+        else:
+            if current:
+                chunks.append(current.strip())
+            current = para
+
+    if current:
+        chunks.append(current.strip())
+
+    # Si les paragraphes sont trop grands, découper par caractères
+    final_chunks = []
+    for chunk in chunks:
+        if len(chunk) > chunk_size * 2:
+            for i in range(0, len(chunk), chunk_size - overlap):
+                part = chunk[i:i + chunk_size]
+                if part.strip():
+                    final_chunks.append(part.strip())
+        else:
+            final_chunks.append(chunk)
+
+    return final_chunks
+
+
+def read_file(file_path: str) -> str:
+    """Lit un fichier PDF, DOCX ou TXT et retourne le texte."""
+    ext = os.path.splitext(file_path)[1].lower()
+
+    if ext == ".txt":
+        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+            return f.read()
+
+    elif ext == ".pdf":
+        try:
+            import pdfplumber
+            with pdfplumber.open(file_path) as pdf:
+                pages = []
+                for page in pdf.pages:
+                    text = page.extract_text()
+                    if text:
+                        pages.append(text)
+                return "\n\n".join(pages)
+        except ImportError:
+            raise ImportError("pdfplumber requis: pip install pdfplumber")
+
+    elif ext in [".docx", ".doc"]:
+        try:
+            import docx
+            doc = docx.Document(file_path)
+            return "\n\n".join(p.text for p in doc.paragraphs if p.text.strip())
+        except ImportError:
+            raise ImportError("python-docx requis: pip install python-docx")
+
+    else:
+        raise ValueError(f"Format non supporté: {ext}. Acceptés: .pdf, .txt, .docx")
+
+
+def check_duplicate(file_name: str) -> bool:
+    """Vérifie si le document existe déjà dans ChromaDB."""
+    try:
+        collection = get_collection()
+        results = collection.get(where={"source": file_name})
+        return len(results.get("ids", [])) > 0
+    except:
+        return False
+
+
+def ingest_document(file_path: str, subject: str = "general") -> int:
+    """Ingère un document dans ChromaDB. Retourne le nombre de chunks."""
+    file_name = os.path.basename(file_path)
+
+    # Supprimer les anciens chunks si le fichier existe déjà
+    try:
+        collection = get_collection()
+        old = collection.get(where={"source": file_name})
+        if old.get("ids"):
+            collection.delete(ids=old["ids"])
+            print(f"🗑️  Anciens chunks supprimés pour '{file_name}'")
+    except Exception as e:
+        print(f"Warning suppression: {e}")
+
+    # Lire et découper
+    text = read_file(file_path)
+    if not text.strip():
+        raise ValueError("Le document est vide ou illisible")
+
+    chunks = chunk_text(text)
+    if not chunks:
+        raise ValueError("Impossible de découper le document en chunks")
+
+    # Préparer les métadonnées
+    ids = [str(uuid.uuid4()) for _ in chunks]
+    metadatas = [
+        {
+            "source": file_name,
+            "subject": subject,
+            "chunk_index": i,
+            "total_chunks": len(chunks)
+        }
+        for i in range(len(chunks))
+    ]
+
+    add_documents(chunks, metadatas, ids)
+    print(f"✅ {len(chunks)} chunks ingérés depuis '{file_name}' (matière: {subject})")
+    return len(chunks)

backend/app/main.py

@@ -0,0 +1,38 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from app.router_service import router
+from app.db.database import create_tables
+import os
+
+app = FastAPI(
+    title="PaperBrain API BY HICHAM",
+    description="API d'assistance à l'apprentissage avec auth et profils",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.on_event("startup")
+def startup():
+    create_tables()
+    print("Tables créées avec succès")
+
+app.include_router(router, prefix="/api")
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+# Servir le frontend React — DOIT être en dernier
+if os.path.exists("static"):
+    app.mount("/", StaticFiles(directory="static", html=True), name="static")
+else:
+    @app.get("/")
+    def root():
+        return {"message": "SmartStudyAI v2.0 running"}

backend/app/rag.py

@@ -0,0 +1,35 @@
+import chromadb
+
+CHROMA_PATH = "./chroma_db"
+COLLECTION_NAME = "smartstudy_docs"
+
+
+def get_chroma_client():
+    return chromadb.PersistentClient(path=CHROMA_PATH)
+
+
+def get_collection():
+    client = get_chroma_client()
+    return client.get_or_create_collection(
+        name=COLLECTION_NAME,
+        metadata={"hnsw:space": "cosine"}
+    )
+
+
+def add_documents(chunks: list, metadatas: list, ids: list):
+    collection = get_collection()
+    collection.add(documents=chunks, metadatas=metadatas, ids=ids)
+
+
+def query_documents(query: str, n_results: int = 4) -> dict:
+    collection = get_collection()
+    count = collection.count()
+    if count == 0:
+        return {"documents": [[]], "metadatas": [[]], "distances": [[]]}
+    actual_n = min(n_results, count)
+    return collection.query(query_texts=[query], n_results=actual_n)
+
+
+def delete_collection():
+    client = get_chroma_client()
+    client.delete_collection(COLLECTION_NAME)

backend/app/rag_evaluator.py

@@ -0,0 +1,210 @@
+import json
+import re
+import os
+from huggingface_hub import InferenceClient
+
+HF_TOKEN   = os.getenv("HF_TOKEN", "")
+MODEL_NAME = os.getenv("HF_MODEL", "Qwen/Qwen2.5-72B-Instruct")
+
+_client: InferenceClient | None = None
+
+
+def _get_client() -> InferenceClient:
+    global _client
+    if _client is None:
+        _client = InferenceClient(model=MODEL_NAME, token=HF_TOKEN or None)
+    return _client
+
+
+def _call_hf(prompt: str, max_tokens: int = 256, temperature: float = 0.1) -> str:
+    client = _get_client()
+    response = client.text_generation(
+        prompt,
+        max_new_tokens=max_tokens,
+        temperature=temperature,
+        do_sample=False,        # deterministic for evaluation
+        return_full_text=False,
+    )
+    return response.strip()
+
+
+def _extract_score(raw: str) -> float:
+    try:
+        cleaned = re.sub(r'```(?:json)?\s*|```', '', raw).strip()
+        data = json.loads(cleaned)
+        if isinstance(data, dict):
+            for key in ["score", "value", "result", "rating"]:
+                if key in data:
+                    val = float(data[key])
+                    return max(0.0, min(1.0, val if val <= 1.0 else val / 10.0))
+    except Exception:
+        pass
+
+    matches = re.findall(r'\b(0\.\d+|1\.0|[0-9](?:\.[0-9]+)?)\b', raw)
+    for m in matches:
+        val = float(m)
+        if 0.0 <= val <= 1.0:
+            return val
+        if 1.0 < val <= 10.0:
+            return val / 10.0
+
+    raw_lower = raw.lower()
+    if any(w in raw_lower for w in ["excellent", "perfect", "fully", "completely"]):
+        return 0.9
+    if any(w in raw_lower for w in ["good", "mostly", "largely"]):
+        return 0.7
+    if any(w in raw_lower for w in ["partial", "somewhat", "moderate"]):
+        return 0.5
+    if any(w in raw_lower for w in ["poor", "barely", "little"]):
+        return 0.3
+    if any(w in raw_lower for w in ["no", "none", "not", "fail"]):
+        return 0.1
+
+    return 0.5
+
+
+def _parse_result(raw: str) -> tuple[float, str]:
+    score  = _extract_score(raw)
+    reason = "No reason provided."
+    try:
+        cleaned = re.sub(r'```(?:json)?\s*|```', '', raw).strip()
+        data    = json.loads(cleaned)
+        reason  = data.get("reason", reason)
+    except Exception:
+        m = re.search(r'"reason"\s*:\s*"([^"]+)"', raw)
+        if m:
+            reason = m.group(1)
+    return round(score, 2), reason
+
+
+# ── Evaluation functions ──────────────────────────────────────────────────────
+
+def evaluate_faithfulness(question: str, context: str, answer: str) -> dict:
+    prompt = f"""<s>[INST] Tu es un évaluateur RAG expert. Évalue la FIDÉLITÉ de la réponse.
+La fidélité mesure si la réponse est entièrement fondée sur le contexte fourni.
+
+Question : {question}
+Contexte : {context[:2000]}
+Réponse : {answer[:1000]}
+
+Note de 0.0 à 1.0 (1.0 = entièrement fondée sur le contexte, 0.0 = totalement hallucinée).
+Réponds UNIQUEMENT avec : {{"score": <float 0.0-1.0>, "reason": "<une phrase>"}} [/INST]
+"""
+    raw   = _call_hf(prompt)
+    score, reason = _parse_result(raw)
+    return {"score": score, "reason": reason, "raw": raw[:200]}
+
+
+def evaluate_answer_relevancy(question: str, answer: str) -> dict:
+    prompt = f"""<s>[INST] Tu es un évaluateur RAG expert. Évalue la PERTINENCE DE LA RÉPONSE.
+La pertinence mesure si la réponse répond directement à la question posée.
+
+Question : {question}
+Réponse : {answer[:1000]}
+
+Note de 0.0 à 1.0 (1.0 = répond parfaitement, 0.0 = hors sujet).
+Réponds UNIQUEMENT avec : {{"score": <float 0.0-1.0>, "reason": "<une phrase>"}} [/INST]
+"""
+    raw   = _call_hf(prompt)
+    score, reason = _parse_result(raw)
+    return {"score": score, "reason": reason, "raw": raw[:200]}
+
+
+def evaluate_context_recall(question: str, context: str) -> dict:
+    prompt = f"""<s>[INST] Tu es un évaluateur RAG expert. Évalue le RAPPEL DU CONTEXTE.
+Mesure si le contexte récupéré contient les informations nécessaires pour répondre à la question.
+
+Question : {question}
+Contexte récupéré : {context[:2000]}
+
+Note de 0.0 à 1.0 (1.0 = contexte idéal, 0.0 = contexte inutile).
+Réponds UNIQUEMENT avec : {{"score": <float 0.0-1.0>, "reason": "<une phrase>"}} [/INST]
+"""
+    raw   = _call_hf(prompt)
+    score, reason = _parse_result(raw)
+    return {"score": score, "reason": reason, "raw": raw[:200]}
+
+
+def evaluate_hallucination(question: str, context: str, answer: str) -> dict:
+    prompt = f"""<s>[INST] Tu es un évaluateur RAG expert. Détecte les HALLUCINATIONS dans la réponse.
+Une hallucination = information présente dans la réponse mais ABSENTE du contexte et non-connaissance générale.
+
+Question : {question}
+Contexte : {context[:2000]}
+Réponse : {answer[:1000]}
+
+Note de 0.0 à 1.0 (1.0 = aucune hallucination, 0.0 = totalement hallucinée).
+Réponds UNIQUEMENT avec : {{"score": <float 0.0-1.0>, "reason": "<une phrase>"}} [/INST]
+"""
+    raw   = _call_hf(prompt)
+    score, reason = _parse_result(raw)
+    return {"score": score, "reason": reason, "raw": raw[:200]}
+
+
+def evaluate_rag_response(question: str, context: str, answer: str) -> dict:
+    print(f"[RAG EVAL] Démarrage pour : {question[:80]}")
+
+    results: dict[str, dict] = {}
+
+    for key, fn, args in [
+        ("faithfulness",      evaluate_faithfulness,     (question, context, answer)),
+        ("answer_relevancy",  evaluate_answer_relevancy, (question, answer)),
+        ("context_recall",    evaluate_context_recall,   (question, context)),
+        ("hallucination",     evaluate_hallucination,    (question, context, answer)),
+    ]:
+        try:
+            results[key] = fn(*args)
+            print(f"[RAG EVAL] {key}: {results[key]['score']}")
+        except Exception as e:
+            results[key] = {"score": 0.0, "reason": str(e), "error": True}
+
+    weights = {
+        "faithfulness":     0.35,
+        "answer_relevancy": 0.30,
+        "context_recall":   0.20,
+        "hallucination":    0.15,
+    }
+    overall = round(sum(
+        results[k]["score"] * w
+        for k, w in weights.items()
+        if not results[k].get("error")
+    ), 2)
+
+    grade = "A" if overall >= 0.85 else "B" if overall >= 0.70 else "C" if overall >= 0.55 else "D" if overall >= 0.40 else "F"
+    print(f"[RAG EVAL] Overall: {overall} ({grade})")
+
+    return {
+        "question":      question,
+        "overall_score": overall,
+        "grade":         grade,
+        "metrics":       results,
+        "summary":       _generate_summary(overall, results),
+    }
+
+
+def _generate_summary(overall: float, results: dict) -> str:
+    label_map = {
+        "faithfulness":     "Fidélité",
+        "answer_relevancy": "Pertinence",
+        "context_recall":   "Rappel contexte",
+        "hallucination":    "Hallucination",
+    }
+    weak   = [label_map[k] for k, v in results.items() if v["score"] < 0.5  and not v.get("error")]
+    strong = [label_map[k] for k, v in results.items() if v["score"] >= 0.8 and not v.get("error")]
+
+    if overall >= 0.85:
+        verdict = "Excellente réponse RAG."
+    elif overall >= 0.70:
+        verdict = "Bonne réponse avec quelques défauts mineurs."
+    elif overall >= 0.50:
+        verdict = "Réponse acceptable — qualité du contexte à améliorer."
+    else:
+        verdict = "Réponse insuffisante — uploadez des documents plus pertinents."
+
+    parts = []
+    if strong:
+        parts.append(f"Points forts : {', '.join(strong)}.")
+    if weak:
+        parts.append(f"À améliorer : {', '.join(weak)}.")
+
+    return verdict + (" " + " ".join(parts) if parts else "")

backend/app/router_service.py

@@ -0,0 +1,206 @@
+import os
+import shutil
+from fastapi import APIRouter, HTTPException, Depends, UploadFile, File, Form
+from sqlalchemy.orm import Session
+
+from app.db.database import get_db
+from app.db import crud
+from app.auth.jwt_handler import create_token
+from app.auth.middleware import get_current_user
+from app.schemas import (
+    RegisterRequest, LoginRequest, ChatRequest, QuizRequest,
+    FlashcardRequest, ExplainRequest, ResumeRequest, RAGRequest, QuizResultRequest
+)
+
+# ── Router (TOUJOURS en premier)
+router = APIRouter()
+UPLOAD_DIR = "./documents"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+
+# ══════════════════════════════════════════════════════════
+# AUTH
+# ══════════════════════════════════════════════════════════
+
+@router.post("/auth/register")
+def register(req: RegisterRequest, db: Session = Depends(get_db)):
+    if crud.get_user_by_email(db, req.email):
+        raise HTTPException(400, "Email déjà utilisé")
+    if crud.get_user_by_username(db, req.username):
+        raise HTTPException(400, "Nom d'utilisateur déjà pris")
+    user = crud.create_user(db, req.username, req.email, req.password)
+    token = create_token({"sub": str(user.id), "username": user.username})
+    return {"access_token": token, "username": user.username, "user_id": user.id}
+
+
+@router.post("/auth/login")
+def login(req: LoginRequest, db: Session = Depends(get_db)):
+    user = crud.get_user_by_email(db, req.email)
+    if not user or not crud.verify_password(req.password, user.password):
+        raise HTTPException(401, "Email ou mot de passe incorrect")
+    crud.update_streak(db, user)
+    token = create_token({"sub": str(user.id), "username": user.username})
+    return {"access_token": token, "username": user.username, "user_id": user.id}
+
+
+# ══════════════════════════════════════════════════════════
+# PROFILE
+# ══════════════════════════════════════════════════════════
+
+@router.get("/profile")
+def get_profile(current_user=Depends(get_current_user), db: Session = Depends(get_db)):
+    return crud.get_student_profile(db, current_user.id)
+
+
+@router.get("/progress")
+def get_progress(current_user=Depends(get_current_user), db: Session = Depends(get_db)):
+    return crud.get_progress(db, current_user.id)
+
+
+# ══════════════════════════════════════════════════════════
+# QUIZ RESULT
+# ══════════════════════════════════════════════════════════
+
+@router.post("/quiz/result")
+def save_quiz_result(req: QuizResultRequest, current_user=Depends(get_current_user), db: Session = Depends(get_db)):
+    result = crud.save_quiz_result(db, current_user.id, req)
+    return {"message": "Résultat sauvegardé", "id": result.id}
+
+
+# ══════════════════════════════════════════════════════════
+# UPLOAD & DOCUMENTS
+# ══════════════════════════════════════════════════════════
+
+@router.post("/upload")
+async def upload_document(
+    file: UploadFile = File(...),
+    subject: str = Form(default="general")
+):
+    allowed = [".pdf", ".txt", ".docx"]
+    ext = os.path.splitext(file.filename)[1].lower()
+    if ext not in allowed:
+        raise HTTPException(400, f"Format non supporté. Acceptés: {allowed}")
+
+    file_path = os.path.join(UPLOAD_DIR, file.filename)
+    with open(file_path, "wb") as f:
+        shutil.copyfileobj(file.file, f)
+
+    try:
+        from app.ingest import ingest_document
+        chunks = ingest_document(file_path, subject)
+        return {
+            "message": f"Fichier '{file.filename}' ingéré avec succès",
+            "chunks": chunks,
+            "subject": subject,
+            "filename": file.filename
+        }
+    except Exception as e:
+        if os.path.exists(file_path):
+            os.remove(file_path)
+        raise HTTPException(500, f"Erreur ingestion: {str(e)}")
+
+
+@router.get("/documents")
+def list_documents():
+    try:
+        from app.rag import get_collection
+        collection = get_collection()
+        results = collection.get()
+        sources = {}
+        for meta in results.get("metadatas", []):
+            if not meta:
+                continue
+            src  = meta.get("source", "inconnu")
+            subj = meta.get("subject", "general")
+            if src not in sources:
+                sources[src] = {"filename": src, "subject": subj, "chunks": 0}
+            sources[src]["chunks"] += 1
+        return {"documents": list(sources.values()), "total": len(sources)}
+    except Exception as e:
+        return {"documents": [], "total": 0, "error": str(e)}
+
+
+@router.delete("/documents/{filename}")
+def delete_document(filename: str):
+    try:
+        from app.rag import get_collection
+        collection = get_collection()
+        results = collection.get(where={"source": filename})
+        ids = results.get("ids", [])
+        if ids:
+            collection.delete(ids=ids)
+        file_path = os.path.join(UPLOAD_DIR, filename)
+        if os.path.exists(file_path):
+            os.remove(file_path)
+        return {"message": f"'{filename}' supprimé ({len(ids)} chunks)"}
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+
+# ══════════════════════════════════════════════════════════
+# AI ENDPOINTS
+# ══════════════════════════════════════════════════════════
+
+@router.post("/chat")
+async def chat(req: ChatRequest):
+    try:
+        from app.agent import run_agent
+        result = await run_agent("chat", req.dict())
+        return result
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+
+@router.post("/quiz")
+async def generate_quiz(req: QuizRequest):
+    try:
+        from app.agent import run_agent
+        result = await run_agent("quiz", req.dict())
+        return result
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+
+@router.post("/flashcards")
+async def generate_flashcards(req: FlashcardRequest):
+    try:
+        from app.agent import run_agent
+        result = await run_agent("flashcards", req.dict())
+        return result
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+
+@router.post("/explain")
+async def explain(req: ExplainRequest):
+    try:
+        from app.agent import run_agent
+        result = await run_agent("explain", req.dict())
+        return result
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+
+@router.post("/resume")
+async def resume(req: ResumeRequest):
+    try:
+        from app.agent import run_agent
+        result = await run_agent("resume", req.dict())
+        return result
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+
+@router.post("/rag-qa")
+async def rag_qa_endpoint(req: RAGRequest):
+    try:
+        from app.agent import run_agent
+        result = await run_agent("rag-qa", req.dict())
+        return result
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+
+@router.get("/health")
+def health():
+    return {"status": "ok", "service": "SmartStudyAI"}

backend/app/schemas.py

@@ -0,0 +1,50 @@
+from pydantic import BaseModel
+from typing import Optional
+
+# ── Auth
+class RegisterRequest(BaseModel):
+    username: str
+    email: str
+    password: str
+
+class LoginRequest(BaseModel):
+    email: str
+    password: str
+
+# ── AI Requests
+class ChatRequest(BaseModel):
+    query: str
+    user_id: Optional[str] = "anonymous"
+
+class QuizRequest(BaseModel):
+    topic: str
+    num_questions: Optional[int] = 5
+    difficulty: Optional[str] = "medium"
+
+class FlashcardRequest(BaseModel):
+    topic: str
+    num_cards: Optional[int] = 8
+
+class ExplainRequest(BaseModel):
+    concept: str
+    level: Optional[str] = "intermediate"
+
+class ResumeRequest(BaseModel):
+    text: str
+
+class RAGRequest(BaseModel):
+    query: str
+    user_id: Optional[str] = "anonymous"
+
+# ── Quiz Result
+class QuizResultRequest(BaseModel):
+    topic: str
+    score: int
+    total_questions: int
+    correct_answers: int
+    difficulty: Optional[str] = "medium"
+    duration_sec: Optional[int] = 0
+class RAGEvalRequest(BaseModel):
+    question: str
+    context: str
+    answer: str

backend/app/schemas_new.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel 
+from typing import Optional 
+ 
+class RegisterRequest(BaseModel): 
+    username: str 
+    email: str 
+    password: str 
+ 
+class LoginRequest(BaseModel): 
+    email: str 
+    password: str 
+ 
+class ChatRequest(BaseModel): 
+    query: str 
+    user_id: str = "anonymous" 
+ 
+class QuizRequest(BaseModel): 
+    topic: str 
+    num_questions: int = 5 
+    difficulty: str = "medium" 
+ 
+class FlashcardRequest(BaseModel): 
+    topic: str 
+    num_cards: int = 8 
+ 
+class ExplainRequest(BaseModel): 
+    concept: str 
+    level: str = "intermediate" 
+ 
+class ResumeRequest(BaseModel): 
+    text: str 
+ 
+class RAGRequest(BaseModel): 
+    query: str 
+    user_id: str = "anonymous" 
+ 
+class QuizResultRequest(BaseModel): 
+    topic: str 
+    score: int 
+    total_questions: int 
+    correct_answers: int 
+    difficulty: str = "medium" 
+    duration_sec: int = 0 

backend/app/tools/tool_flashcards.py

@@ -0,0 +1,77 @@
+import json
+import re
+import os
+from huggingface_hub import InferenceClient
+
+HF_TOKEN   = os.getenv("HF_TOKEN", "")
+MODEL_NAME = os.getenv("HF_MODEL", "Qwen/Qwen2.5-72B-Instruct")
+
+_client = None
+
+def _get_client() -> InferenceClient:
+    global _client
+    if _client is None:
+        _client = InferenceClient(token=HF_TOKEN or None)
+    return _client
+
+
+def _call_hf(system: str, user: str, max_tokens: int = 1024, temperature: float = 0.3) -> str:
+    client = _get_client()
+    response = client.chat_completion(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": system},
+            {"role": "user",   "content": user},
+        ],
+        max_tokens=max_tokens,
+        temperature=temperature,
+    )
+    return response.choices[0].message.content.strip()
+
+
+def _extract_json_array(raw: str) -> list:
+    cleaned = re.sub(r'```(?:json)?\s*|```', '', raw).strip()
+    try:
+        result = json.loads(cleaned)
+        if isinstance(result, list):
+            return result
+    except Exception:
+        pass
+    start = cleaned.find('[')
+    if start != -1:
+        depth = 0
+        for i, ch in enumerate(cleaned[start:], start):
+            if ch == '[': depth += 1
+            elif ch == ']':
+                depth -= 1
+                if depth == 0:
+                    candidate = re.sub(r',\s*([}\]])', r'\1', cleaned[start:i+1])
+                    try:
+                        return json.loads(candidate)
+                    except Exception:
+                        pass
+                    break
+    return []
+
+
+def generate_flashcards(topic: str, num_cards: int = 10) -> list[dict]:
+    system = (
+        "Tu es un générateur de flashcards pédagogiques. "
+        "Tu réponds UNIQUEMENT avec un tableau JSON valide, sans texte avant ni après."
+    )
+    user = (
+        f"Génère {num_cards} flashcards sur : \"{topic}\".\n"
+        "Chaque objet : front (question/terme) et back (réponse/définition).\n"
+        "Réponds UNIQUEMENT avec le tableau JSON."
+    )
+
+    raw   = _call_hf(system, user)
+    cards = _extract_json_array(raw)
+
+    if cards:
+        return [
+            {"front": str(c.get("front", "")), "back": str(c.get("back", ""))}
+            for c in cards
+            if isinstance(c, dict) and c.get("front") and c.get("back")
+        ]
+    return [{"front": topic, "back": raw[:300]}]

backend/app/tools/tool_quiz.py

@@ -0,0 +1,92 @@
+import json
+import re
+import os
+from huggingface_hub import InferenceClient
+
+HF_TOKEN   = os.getenv("HF_TOKEN", "")
+MODEL_NAME = os.getenv("HF_MODEL", "Qwen/Qwen2.5-72B-Instruct")
+
+_client = None
+
+def _get_client() -> InferenceClient:
+    global _client
+    if _client is None:
+        _client = InferenceClient(token=HF_TOKEN or None)
+    return _client
+
+
+def _call_hf(system: str, user: str, max_tokens: int = 1500, temperature: float = 0.3) -> str:
+    client = _get_client()
+    response = client.chat_completion(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": system},
+            {"role": "user",   "content": user},
+        ],
+        max_tokens=max_tokens,
+        temperature=temperature,
+    )
+    return response.choices[0].message.content.strip()
+
+
+def _extract_json_array(raw: str) -> list:
+    cleaned = re.sub(r'```(?:json)?\s*|```', '', raw).strip()
+    try:
+        result = json.loads(cleaned)
+        if isinstance(result, list):
+            return result
+    except Exception:
+        pass
+    start = cleaned.find('[')
+    if start != -1:
+        depth = 0
+        for i, ch in enumerate(cleaned[start:], start):
+            if ch == '[': depth += 1
+            elif ch == ']':
+                depth -= 1
+                if depth == 0:
+                    candidate = re.sub(r',\s*([}\]])', r'\1', cleaned[start:i+1])
+                    try:
+                        return json.loads(candidate)
+                    except Exception:
+                        pass
+                    break
+    return []
+
+
+def generate_quiz(topic: str, num_questions: int = 5, difficulty: str = "medium") -> list[dict]:
+    difficulty_map = {
+        "easy":   "simples et directes, pour débutants",
+        "medium": "de difficulté intermédiaire",
+        "hard":   "difficiles et approfondies, pour experts",
+    }
+    level_desc = difficulty_map.get(difficulty, "de difficulté intermédiaire")
+
+    system = (
+        "Tu es un générateur de quiz pédagogique. "
+        "Tu réponds UNIQUEMENT avec un tableau JSON valide, sans texte avant ni après."
+    )
+    user = (
+        f"Génère {num_questions} questions QCM ({level_desc}) sur : \"{topic}\".\n"
+        "Chaque objet : question, options (4 chaînes A/B/C/D), correct_answer (A/B/C/D), explanation.\n"
+        "Réponds UNIQUEMENT avec le tableau JSON."
+    )
+
+    raw       = _call_hf(system, user)
+    questions = _extract_json_array(raw)
+
+    if questions:
+        clean = [
+            {
+                "question":       str(q.get("question", "")),
+                "options":        list(q.get("options", [])),
+                "correct_answer": str(q.get("correct_answer", "A")),
+                "explanation":    str(q.get("explanation", "")),
+            }
+            for q in questions
+            if isinstance(q, dict) and q.get("question") and q.get("options")
+        ]
+        if clean:
+            return clean
+
+    return [{"question": f"Question sur {topic}", "options": ["A) -", "B) -", "C) -", "D) -"], "correct_answer": "A", "explanation": "Erreur de génération."}]

backend/app/tools/tool_rag_qa.py

@@ -0,0 +1,61 @@
+import os
+from huggingface_hub import InferenceClient
+
+HF_TOKEN   = os.getenv("HF_TOKEN", "")
+MODEL_NAME = os.getenv("HF_MODEL", "Qwen/Qwen2.5-72B-Instruct")
+RELEVANCE_THRESHOLD = 0.4
+
+_client = None
+
+def _get_client() -> InferenceClient:
+    global _client
+    if _client is None:
+        _client = InferenceClient(token=HF_TOKEN or None)
+    return _client
+
+
+def _call_hf(system: str, user: str, max_tokens: int = 1024, temperature: float = 0.4) -> str:
+    client = _get_client()
+    response = client.chat_completion(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": system},
+            {"role": "user",   "content": user},
+        ],
+        max_tokens=max_tokens,
+        temperature=temperature,
+    )
+    return response.choices[0].message.content.strip()
+
+
+def rag_qa(query: str, history_text: str = "") -> tuple[str, list[str]]:
+    from app.rag import query_documents
+
+    results   = query_documents(query, n_results=3)
+    documents = results.get("documents", [[]])[0]
+    metadatas = results.get("metadatas",  [[]])[0]
+    distances = results.get("distances",  [[]])[0]
+
+    relevant_docs = [
+        (doc, meta)
+        for doc, meta, dist in zip(documents, metadatas, distances)
+        if dist < RELEVANCE_THRESHOLD
+    ]
+
+    if not relevant_docs:
+        return ("Je n'ai pas trouvé d'information pertinente dans vos cours.", [])
+
+    context = "\n\n---\n\n".join([doc for doc, _ in relevant_docs])
+    sources  = list(set([meta.get("source", "inconnu") for _, meta in relevant_docs]))
+
+    system = (
+        "Tu es un assistant pédagogique RAG. "
+        "Réponds à la question en te basant UNIQUEMENT sur le contexte fourni. "
+        "Si la réponse n'est pas dans le contexte, dis-le clairement. "
+        "Réponds dans la même langue que la question."
+    )
+    history_section = f"Historique:\n{history_text}\n\n" if history_text else ""
+    user = f"{history_section}Contexte :\n{context[:3000]}\n\nQuestion : {query}"
+
+    answer = _call_hf(system, user)
+    return answer, sources

backend/app/tools/tool_resume.py

@@ -0,0 +1,51 @@
+import os
+from huggingface_hub import InferenceClient
+
+HF_TOKEN   = os.getenv("HF_TOKEN", "")
+MODEL_NAME = os.getenv("HF_MODEL", "Qwen/Qwen2.5-72B-Instruct")
+
+_client = None
+
+def _get_client() -> InferenceClient:
+    global _client
+    if _client is None:
+        _client = InferenceClient(token=HF_TOKEN or None)
+    return _client
+
+
+def _call_hf(system: str, user: str, max_tokens: int = 1024, temperature: float = 0.4) -> str:
+    client = _get_client()
+    response = client.chat_completion(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": system},
+            {"role": "user",   "content": user},
+        ],
+        max_tokens=max_tokens,
+        temperature=temperature,
+    )
+    return response.choices[0].message.content.strip()
+
+
+def generate_resume(text: str = None, file_path: str = None) -> str:
+    if file_path and not text:
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                text = f.read()
+        except Exception as e:
+            return f"Erreur lors de la lecture du fichier : {e}"
+
+    if not text:
+        return "Aucun texte ou fichier fourni."
+
+    system = (
+        "Tu es un assistant pédagogique expert en synthèse de documents. "
+        "Réponds dans la même langue que le texte fourni."
+    )
+    user = (
+        "Résume le texte suivant de façon claire et structurée. "
+        "Utilise des titres et des points clés.\n\n"
+        f"Texte :\n{text[:4000]}"
+    )
+
+    return _call_hf(system, user, max_tokens=1024)

backend/app/tools/tool_simple_explain.py

@@ -0,0 +1,53 @@
+import os
+from huggingface_hub import InferenceClient
+
+HF_TOKEN   = os.getenv("HF_TOKEN", "")
+MODEL_NAME = os.getenv("HF_MODEL", "Qwen/Qwen2.5-72B-Instruct")
+
+LEVEL_DESCRIPTIONS = {
+    "beginner":     "de manière très simple, comme si tu expliquais à un lycéen, avec des analogies du quotidien",
+    "intermediate": "de manière claire avec les concepts essentiels, pour un étudiant universitaire",
+    "advanced":     "de manière approfondie et technique, pour un expert du domaine",
+}
+
+_client = None
+
+def _get_client() -> InferenceClient:
+    global _client
+    if _client is None:
+        _client = InferenceClient(token=HF_TOKEN or None)
+    return _client
+
+
+def _call_hf(system: str, user: str, max_tokens: int = 1024, temperature: float = 0.5) -> str:
+    client = _get_client()
+    response = client.chat_completion(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": system},
+            {"role": "user",   "content": user},
+        ],
+        max_tokens=max_tokens,
+        temperature=temperature,
+    )
+    return response.choices[0].message.content.strip()
+
+
+def simple_explain(concept: str, level: str = "intermediate") -> str:
+    level_desc = LEVEL_DESCRIPTIONS.get(level, LEVEL_DESCRIPTIONS["intermediate"])
+
+    system = (
+        "Tu es un professeur pédagogue expert. "
+        "Réponds dans la même langue que le concept demandé."
+    )
+    user = (
+        f"Explique le concept suivant {level_desc}.\n\n"
+        "Structure ta réponse avec :\n"
+        "1. Une définition courte et claire\n"
+        "2. Les points clés à retenir\n"
+        "3. Un exemple concret\n"
+        "4. Les applications pratiques\n\n"
+        f"Concept : {concept}"
+    )
+
+    return _call_hf(system, user, max_tokens=1024)

backend/database.py

@@ -0,0 +1,25 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+DATABASE_URL = "sqlite:///./smartstudy.db"
+
+engine = create_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False}
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+def create_tables():
+    from app.db.models import User, QuizResult, StudySession, FlashcardProgress
+    Base.metadata.create_all(bind=engine)
+    print("✅ Tables créées avec succès")

backend/migrate.py

@@ -0,0 +1,20 @@
+import sqlite3
+import os
+
+db_path = os.path.join(os.path.dirname(__file__), "smartstudy.db")
+
+conn = sqlite3.connect(db_path)
+cursor = conn.cursor()
+
+# Check if column already exists
+cursor.execute("PRAGMA table_info(study_sessions)")
+columns = [col[1] for col in cursor.fetchall()]
+
+if "duration" not in columns:
+    cursor.execute("ALTER TABLE study_sessions ADD COLUMN duration INTEGER DEFAULT 0")
+    conn.commit()
+    print("✅ Column 'duration' added successfully.")
+else:
+    print("ℹ️ Column 'duration' already exists, nothing to do.")
+
+conn.close()

backend/requirements.txt

@@ -0,0 +1,30 @@
+# API & serveur
+fastapi==0.111.0
+uvicorn[standard]==0.29.0
+python-multipart==0.0.9
+
+# Auth & sécurité
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4
+
+# Base de données
+sqlalchemy==2.0.30
+
+# HuggingFace
+huggingface-hub>=0.31.0
+
+# NumPy — forcer 1.x pour compatibilité ChromaDB
+numpy<2.0
+
+# RAG / ChromaDB
+chromadb==0.5.0
+onnxruntime==1.18.0
+
+# Lecture de documents
+pdfplumber==0.11.1
+python-docx==1.1.2
+
+# Utilitaires
+pydantic==2.7.1
+python-dotenv==1.0.1
+requests==2.32.3

docker-compose.yml

@@ -0,0 +1,39 @@
+services:
+
+  backend:
+    build:
+      context: ./backend        # Docker lit les fichiers DEPUIS ./backend
+      dockerfile: Dockerfile
+    container_name: smartstudy-backend
+    ports:
+      - "8000:8000"
+    environment:
+      HF_TOKEN: ${HF_TOKEN}
+      HF_MODEL: ${HF_MODEL:-mistralai/Mistral-7B-Instruct-v0.3}
+    volumes:
+      - chroma_data:/app/chroma_db
+      - documents_data:/app/documents
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  frontend:
+    build:
+      context: ./frontend       # Docker lit les fichiers DEPUIS ./frontend
+      dockerfile: Dockerfile
+      args:
+        VITE_API_URL: http://localhost:8000/api
+    container_name: smartstudy-frontend
+    ports:
+      - "5173:80"
+    depends_on:
+      backend:
+        condition: service_healthy
+    restart: unless-stopped
+
+volumes:
+  chroma_data:
+  documents_data:

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/Dockerfile

@@ -0,0 +1,30 @@
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+ARG VITE_API_URL=http://localhost:8000/api
+ENV VITE_API_URL=$VITE_API_URL
+
+COPY package*.json ./
+RUN npm ci
+
+COPY . .
+RUN npm run build
+
+# ── Runtime Nginx ─────────────────────────────────────────────────────────────
+FROM nginx:alpine
+
+COPY --from=builder /app/dist /usr/share/nginx/html
+
+RUN echo 'server { \
+    listen 80; \
+    root /usr/share/nginx/html; \
+    index index.html; \
+    location / { \
+        try_files $uri $uri/ /index.html; \
+    } \
+}' > /etc/nginx/conf.d/default.conf
+
+EXPOSE 80
+
+CMD ["nginx", "-g", "daemon off;"]