Deploy from GitLab CI - 6509512f

.devcontainer/devcontainer.json

@@ -0,0 +1,33 @@
+{
+  "name": "Python 3",
+  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+  "image": "mcr.microsoft.com/devcontainers/python:1-3.11-bookworm",
+  "customizations": {
+    "codespaces": {
+      "openFiles": [
+        "README.md",
+        "app.py"
+      ]
+    },
+    "vscode": {
+      "settings": {},
+      "extensions": [
+        "ms-python.python",
+        "ms-python.vscode-pylance"
+      ]
+    }
+  },
+  "updateContentCommand": "[ -f packages.txt ] && sudo apt update && sudo apt upgrade -y && sudo xargs apt install -y <packages.txt; [ -f requirements.txt ] && pip3 install --user -r requirements.txt; pip3 install --user streamlit; echo '✅ Packages installed and Requirements met'",
+  "postAttachCommand": {
+    "server": "streamlit run app.py --server.enableCORS false --server.enableXsrfProtection false"
+  },
+  "portsAttributes": {
+    "8501": {
+      "label": "Application",
+      "onAutoForward": "openPreview"
+    }
+  },
+  "forwardPorts":[
+    8501
+  ]
+}

.dockerignore

@@ -0,0 +1,30 @@
+# .dockerignore
+# Fichiers à exclure de l'image Docker
+
+# Git
+.git
+.gitignore
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+venv/
+.venv/
+
+# Environnement (on garde .env pour les tests locaux)
+.env.local
+
+# IDE
+.vscode/
+.idea/
+
+# CI/CD
+.github/
+
+# Docs
+README.md
+LICENSE
+
+# Tests
+tests/

.gitignore

@@ -0,0 +1,12 @@
+# Variables d'environnement (Clés API)
+.env
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+venv/
+env/
+
+# OS
+.DS_Store

Dockerfile

@@ -1,20 +1,44 @@
-FROM python:3.13.5-slim
+# Étape 1 : Image de base Python
+FROM python:3.11-slim AS base
 
+# Variables d'environnement pour Python
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# Créer un utilisateur non-root (UID 1000 imposé par HF)
+RUN useradd -m -u 1000 user
+
+# Définit le répertoire de travail
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+# Étape 2 : Installation des dépendances
+FROM base AS dependencies
+
+# Copie uniquement les fichiers de dépendances
+COPY requirements.txt .
+
+# Installation des dépendances
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Étape 3 : Image finale
+FROM base AS final
+
+# Copie les dépendances installées depuis l'étape précédente
+COPY --from=dependencies /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# AJOUT CRUCIAL : copier les binaires (streamlit, etc.)
+COPY --from=dependencies /usr/local/bin /usr/local/bin
 
-RUN pip3 install -r requirements.txt
+# Copie tout le code de l'application avec les bons propriétaires
+COPY --chown=user:user . .
 
-EXPOSE 8501
+# Bascule vers l'utilisateur non-root
+USER user
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Expose le port attendu par Hugging Face Spaces
+EXPOSE 7860
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Commande de démarrage
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -1,20 +1,365 @@
+# CV Evaluator — Système Multi-Agents d'Évaluation de CV
+
+[![CI/CD Pipeline](https://github.com/yacineberkani/cv_evaluator/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/yacineberkani/cv_evaluator/actions/workflows/ci-cd.yml)
+[![Python 3.10+](https://img.shields.io/badge/Python-3.10%2B-blue?logo=python)](https://www.python.org/)
+[![Streamlit](https://img.shields.io/badge/Streamlit-1.x-FF4B4B?logo=streamlit)](https://streamlit.io/)
+[![LangChain](https://img.shields.io/badge/LangChain-latest-1C3C3C?logo=langchain)](https://www.langchain.com/)
+[![Docker](https://img.shields.io/badge/Docker-multi--stage-2496ED?logo=docker)](https://www.docker.com/)
+[![Hugging Face](https://img.shields.io/badge/Hugging%20Face-Spaces-FFD21E?logo=huggingface)](https://huggingface.co/spaces/yacineberkani/cv_evaluator)
+[![License](https://img.shields.io/badge/License-JEMSLABS-green)](./README.md)
+
+---
+
+## 📌 Description
+
+Application d'évaluation automatisée de CV utilisant une architecture **multi-agents** propulsée par **LangChain** et plusieurs backends LLM au choix : **Google Gemini**, **OpenAI ChatGPT** et **Ollama** (cloud). Le système analyse, évalue et note chaque section d'un CV de manière **déterministe et reproductible**, puis restitue un rapport structuré avec score, tableau d'évaluation, verdict et recommandations.
+
+**Stack technique :** Python 3.11 · Streamlit · LangChain · Google Gemini / ChatGPT / Ollama · Pydantic · PyMuPDF · Docker · GitHub Actions · Hugging Face Spaces
+
+
+
+
+<table>
+<tr>
+<td width="100%">
+
+### 📹 Voir la vidéo de démonstration
+---
+https://github.com/user-attachments/assets/45300066-c809-473d-ba67-3bd57212b555
+
+</td>
+</tr>
+</table>
+
+### 🌐 Accéder à l'application en ligne
+
+> **L'application est déployée et accessible directement sur Hugging Face Spaces :**
+>
+> ## 👉 [**Lancer CV Evaluator**](https://berkani-cv-evaluator.hf.space/)
+>
+> Aucune installation requise — uploadez votre CV en PDF et obtenez votre évaluation en quelques secondes.
+
+---
+
+## 🏗 Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    STREAMLIT FRONTEND                       │
+│         Upload PDF → Affichage Résultats → Export JSON      │
+└──────────────────────┬──────────────────────────────────────┘
+                       │
+┌──────────────────────▼──────────────────────────────────────┐
+│                   ORCHESTRATOR                              │
+│        (Gestion du pipeline, cache, parallélisme)           │
+└──────────────────────┬──────────────────────────────────────┘
+                       │
+    ┌──────────────────┼────────────────────┐
+    │                  │                    │
+┌───▼──────────┐       │                    │
+│  Phase 1     │       │                    │
+│  Experience  │       │                    │
+│  Analysis    │       │                    │
+│  Agent       │       │                    │
+└──────┬───────┘       │                    │
+       │               │                    │
+┌──────▼───────┐ ┌─────▼─────────┐          │
+│  Phase 2a    │ │  Phase 2b     │          │
+│  Skills &    │ │  Summary      │   (parallel)
+│  Education   │ │  Validation   │          │
+│  Agent       │ │  Agent        │          │
+└──────┬───────┘ └──────┬────────┘          │
+       └────────┬───────┘                   │
+                ▼                           │
+       ┌─────────────────┐                  │
+       │  Phase 3        │                  │
+       │  Scoring Agent  │                  │
+       └──────┬──────────┘                  │
+              ▼                             │
+    ┌──────────────┐ ┌────────────────┐     │
+    │  Phase 4a    │ │  Phase 4b      │  (parallel)
+    │  Quality     │ │  Table         │     │
+    │  Control     │ │  Generator     │     │
+    │  Agent       │ │  Agent         │     ��
+    └──────────────┘ └────────────────┘     │
+                                            │
+    ┌───────────────────────────────────────┘
+    ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    RAPPORT FINAL (JSON)                     │
+│    Score /100 · Tableau · Verdict · Recommandation          │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Les 6 Agents
+
+| # | Agent | Rôle | Entrées | Sorties |
+|---|-------|------|---------|---------|
+| 1 | `ExperienceAnalysisAgent` | Analyse chaque expérience professionnelle | Texte expériences + CV complet | Score, missions, résultats, erreurs détectées |
+| 2 | `SkillsEducationAgent` | Évalue compétences & formations | Texte compétences/formations + résultat Agent 1 | Scores, compétences démontrées vs non démontrées |
+| 3 | `SummaryValidationAgent` | Valide le résumé vs preuves concrètes | Texte résumé + résultat Agent 1 | Taux de preuve, écarts identifiés, score |
+| 4 | `ScoringAgent` | Calcule le score pondéré global | Scores des agents 1 à 3 | Note /10, /20, /100 + détail par critère |
+| 5 | `QualityControlAgent` | Verdict final et recommandations | Résultats agents 1 à 4 | Verdict, recommandation, forces/faiblesses |
+| 6 | `TableGeneratorAgent` | Génère le tableau d'évaluation visuel | Résultats agents 1 à 3 | Tableau avec emojis + justifications |
+
+---
+
+## 📂 Structure du Projet
+
+```
+cv_evaluator/
+├── app.py                          # Application Streamlit (frontend)
+├── orchestrator.py                 # Orchestration multi-agents
+├── requirements.txt                # Dépendances Python (production)
+├── requirements-dev.txt            # Dépendances de développement (tests, linting)
+├── pyproject.toml                  # Configuration du projet (ruff, pytest, mypy)
+├── Dockerfile                      # Image Docker multi-stage, utilisateur non-root
+├── docker-compose.prod.yml         # Compose pour déploiement production
+├── .dockerignore                   # Exclusions du build Docker
+├── .env.example                    # Template variables d'environnement
+├── .gitignore                      # Exclusions Git
+├── README.md                       # Ce fichier
+│
+├── .github/
+│   └── workflows/
+│       └── ci-cd.yml               # Pipeline CI/CD (qualité, tests, Docker, HF deploy)
+│
+├── .devcontainer/                  # Configuration Dev Container (VS Code)
+│
+├── assets/                         # Ressources statiques
+│   └── ci-cd-success.png           # Capture d'écran du pipeline CI/CD réussi
+│
+├── agents/                         # Agents spécialisés
+│   ├── __init__.py
+│   ├── base_agent.py               # Classe de base (LangChain + LLM abstrait)
+│   ├── experience_agent.py         # Agent 1 : Analyse expériences
+│   ├── skills_education_agent.py   # Agent 2 : Compétences & formations
+│   ├── summary_validation_agent.py # Agent 3 : Validation résumé
+│   ├── scoring_agent.py            # Agent 4 : Calcul scores
+│   ├── quality_control_agent.py    # Agent 5 : Contrôle qualité
+│   └── table_generator_agent.py    # Agent 6 : Tableau d'évaluation
+│
+├── models/                         # Schémas Pydantic
+│   ├── __init__.py
+│   └── schemas.py                  # Tous les modèles de données validés
+│
+├── prompts/                        # Templates de prompts
+│   ├── __init__.py
+│   └── templates.py                # Prompts optimisés par provider LLM
+│
+├── tests/                          # Suite de tests
+│   ├── __init__.py
+│   └── ...                         # Tests unitaires et d'intégration
+│
+└── utils/                          # Utilitaires
+    ├── __init__.py
+    ├── pdf_parser.py               # Extraction PDF (PyMuPDF)
+    ├── chunking.py                 # Découpage sémantique du CV
+    └── cache.py                    # Cache des résultats intermédiaires
+```
+
+---
+
+## 🚀 Installation & Exécution Locale
+
+### Prérequis
+
+- Python 3.10+
+- Une clé API LLM au choix :
+  - **Google Gemini** — [obtenir ici](https://makersuite.google.com/app/apikey)
+  - **OpenAI ChatGPT** — [obtenir ici](https://platform.openai.com/api-keys)
+  - **Ollama** (local ou cloud)
+
+### Installation
+
+```bash
+# Cloner le projet
+git clone https://github.com/yacineberkani/cv_evaluator.git
+cd cv_evaluator
+
+# Créer un environnement virtuel
+python -m venv venv
+source venv/bin/activate       # Linux/Mac
+# ou : venv\Scripts\activate   # Windows
+
+# Installer les dépendances de production
+pip install -r requirements.txt
+
+# (Optionnel) Installer les dépendances de développement
+pip install -r requirements-dev.txt
+
+# Configurer les variables d'environnement
+cp .env.example .env
+# Éditer .env et renseigner votre clé API
+```
+
+### Exécution
+
+```bash
+streamlit run app.py
+```
+
+L'application s'ouvrira sur `http://localhost:8501`.
+
+---
+
+## 🐳 Exécution avec Docker (via Docker Hub)
+
+L'image est publiée et maintenue sur **Docker Hub** : [`yacineberkani32/cv-evaluator`](https://hub.docker.com/r/yacineberkani32/cv-evaluator)
+
+<img width="1914" height="919" alt="Image" src="https://github.com/user-attachments/assets/c7ab269c-1af2-4b7f-842b-c7b8bc0f4c19" />
+
 ---
-title: Cveval
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
-license: mit
+| Propriété | Valeur |
+|-----------|--------|
+| **Repository** | `yacineberkani32/cv-evaluator` |
+| **Tag stable** | `latest` |
+| **OS / Architecture** | `linux/amd64` |
+| **Taille compressée** | 251.62 MB |
+| **Runtime Python** | 3.11.15 |
+
+### Récupérer l'image depuis Docker Hub
+```bash
+docker pull yacineberkani32/cv-evaluator:latest
+```
 ---
+<img width="1368" height="772" alt="Image" src="https://github.com/user-attachments/assets/ac85dac9-473e-4169-a8dd-99a6b7b5ec0b" />
+
+
+### Lancer le conteneur
 
-# Welcome to Streamlit!
+```bash
+docker run -p 7860:7860 \
+  -e GOOGLE_API_KEY=votre_clé_ici \
+  yacineberkani32/cv-evaluator:latest
+```
+
+L'application sera accessible sur `http://localhost:7860`.
+
+### Avec Docker Compose (production)
+
+```bash
+docker compose -f docker-compose.prod.yml up
+```
+
+### Builder l'image localement (développement)
+
+Si vous souhaitez modifier l'image et la reconstruire :
+
+```bash
+docker build -t cv-evaluator .
+docker run -p 7860:7860 -e GOOGLE_API_KEY=votre_clé_ici cv-evaluator
+```
+
+> **Note :** L'image expose le port `7860` — requis par Hugging Face Spaces. Le binaire `streamlit` est explicitement copié depuis l'étape `dependencies` vers l'étape finale (`COPY --from=dependencies /usr/local/bin /usr/local/bin`), indispensable dans un build multi-stage non-root (UID 1000).
+
+---
+
+## ☁️ Déploiement sur Hugging Face Spaces
+
+Le déploiement est entièrement automatisé via un pipeline **GitHub Actions CI/CD** déclenché à chaque `push` sur la branche `main`.
+
+### Pipeline CI/CD — 4 jobs
+
+```
+push → main
+       │
+       ├─ [1] quality     → Linting (ruff), formatage, vérification types (mypy)
+       │
+       ├─ [2] tests        → Exécution des tests unitaires (pytest) avec mock LLM
+       │
+       ├─ [3] build        → Build Docker multi-stage + validation de l'image
+       │        (dépend de : quality + tests)
+       │
+       └─ [4] deploy       → Push vers Hugging Face Spaces via l'API HF
+                (dépend de : build)
+```
+
+### Secrets GitHub à configurer
+
+Rendez-vous dans **Settings → Secrets and variables → Actions** de votre repository :
+
+| Secret | Description |
+|--------|-------------|
+| `HF_TOKEN` | Token d'accès Hugging Face (write) |
+| `HF_SPACE_NAME` | Nom du Space HF cible (ex. `berkani/cv_evaluator`) |
+| `GOOGLE_API_KEY` | Clé API Google Gemini (injectée dans le Space) |
+| `OPENAI_API_KEY` | Clé API OpenAI (optionnel, si provider ChatGPT utilisé) |
+
+### Fonctionnement automatique
+
+Une fois les secrets configurés, chaque `git push` sur `main` déclenche automatiquement le pipeline. En cas de succès sur tous les jobs, le Space Hugging Face est mis à jour sans intervention manuelle.
+
+---
+
+## 📊 Statut du Déploiement
+
+Le pipeline CI/CD passe intégralement — qualité, tests, build Docker et déploiement Hugging Face sont tous au vert.
+
+<img width="1658" height="447" alt="Image" src="https://github.com/user-attachments/assets/a96ee773-e521-4391-9259-fdd63a53c0f3" />
+
+---
+
+## ⚙️ Variables d'Environnement
+
+| Variable | Description | Défaut |
+|----------|-------------|--------|
+| `GOOGLE_API_KEY` | Clé API Google Gemini | *(obligatoire si provider Gemini)* |
+| `OPENAI_API_KEY` | Clé API OpenAI ChatGPT | *(obligatoire si provider ChatGPT)* |
+| `OLLAMA_BASE_URL` | URL du serveur Ollama | `http://localhost:11434` |
+| `LLM_PROVIDER` | Provider LLM actif (`gemini`, `openai`, `ollama`) | `gemini` |
+| `GEMINI_MODEL` | Modèle Gemini à utiliser | `gemini-2.5-flash-lite` |
+| `GEMINI_TEMPERATURE` | Température LLM (0 = déterministe) | `0` |
+
+---
+
+## 📏 Formule de Scoring
+
+```
+Note /10 = (Expériences × 0.5) + (Compétences × 0.2) + (Formations × 0.1) + (Résumé × 0.2)
+```
+
+- **Note /20** = Note /10 × 2
+- **Note /100** = Note /10 × 10
+
+Le `ScoringAgent` effectue le calcul via le LLM, puis le valide **programmatiquement** via Pydantic pour garantir la cohérence du résultat.
+
+---
+
+## 🔧 Bonnes Pratiques Implémentées
+
+### Intelligence Artificielle
+
+- ✅ **Déterminisme** : température = 0, prompts stricts, sorties JSON validées par Pydantic
+- ✅ **Gestion d'erreurs** : retry avec backoff exponentiel (3 tentatives max), fallback de parsing JSON robuste
+- ✅ **Chunking sémantique** : découpage du CV par sections (expériences, compétences, résumé) pour respecter la fenêtre de contexte du LLM
+- ✅ **Parallélisme** : les paires d'agents 2a/2b et 4a/4b s'exécutent en parallèle via `ThreadPoolExecutor`
+- ✅ **Caching** : résultats intermédiaires mis en cache pour éviter les appels LLM redondants
+- ✅ **Modularité** : chaque agent est une classe indépendante, extensible et testable isolément
+- ✅ **Validation stricte** : chaque sortie JSON est validée par un modèle Pydantic dédié avant traitement
+- ✅ **Données manquantes** : signalement systématique d'une section absente plutôt qu'invention de données
+
+### DevOps
+
+- ✅ **Docker multi-stage non-root** : image slim en 3 étapes (`base → dependencies → final`), l'utilisateur `user` (UID 1000) est imposé par Hugging Face Spaces
+- ✅ **Pipeline CI/CD GitHub Actions** : 4 jobs ordonnés (qualité → tests → build → déploiement) avec dépendances explicites
+- ✅ **Déploiement continu** : chaque push sur `main` déclenche automatiquement la mise à jour du Space HF
+- ✅ **Cohérence des ports** : port `7860` utilisé de bout en bout (Dockerfile, docker-compose, CMD Streamlit) pour la compatibilité native avec Hugging Face Spaces
+
+---
+
+## 🧩 Défis Techniques Relevés
+
+Ce projet a nécessité la résolution de plusieurs problèmes non triviaux lors du déploiement sur Hugging Face Spaces :
+
+- **Port incorrect** : Streamlit démarrait par défaut sur le port `8501`, incompatible avec HF Spaces qui exige le port `7860`. Correction appliquée dans le `CMD` du Dockerfile et dans `docker-compose.prod.yml`.
+- **Binaires manquants en multi-stage build** : dans un build Docker multi-stage, seuls les `site-packages` étaient copiés vers l'image finale, mais pas les exécutables (`streamlit`, etc.) présents dans `/usr/local/bin`. Ajout explicite de `COPY --from=dependencies /usr/local/bin /usr/local/bin`.
+- **Emoji invalide dans le YAML CI/CD** : certains caractères Unicode (emojis) dans les `name:` des steps GitHub Actions provoquaient des erreurs de parsing YAML. Suppression ou remplacement par des équivalents textuels.
+- **Dépôt Git imbriqué** : un sous-dossier contenant un `.git/` propre était ignoré par Git lors du push, entraînant un déploiement incomplet sur HF. Résolu par suppression du `.git/` interne ou utilisation d'un submodule explicite.
+- **Permissions utilisateur HF** : Hugging Face impose l'UID `1000` pour l'utilisateur non-root. Configuration du `useradd -m -u 1000 user` et `COPY --chown=user:user` dans le Dockerfile.
+
+---
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## 📄 Licence
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+**JEMSLABS** — Tous droits réservés.

agents/__init__.py

@@ -0,0 +1,15 @@
+from agents.experience_agent import ExperienceAnalysisAgent
+from agents.quality_control_agent import QualityControlAgent
+from agents.scoring_agent import ScoringAgent
+from agents.skills_education_agent import SkillsEducationAgent
+from agents.summary_validation_agent import SummaryValidationAgent
+from agents.table_generator_agent import TableGeneratorAgent
+
+__all__ = [
+    "ExperienceAnalysisAgent",
+    "SkillsEducationAgent",
+    "SummaryValidationAgent",
+    "ScoringAgent",
+    "QualityControlAgent",
+    "TableGeneratorAgent",
+]

agents/base_agent.py

@@ -0,0 +1,226 @@
+"""
+Base agent class for all CV evaluation agents.
+Supports multiple LLM providers: OpenAI (ChatGPT), Google (Gemini) via LangChain.
+"""
+
+import json
+import logging
+import os
+import re
+from typing import Any, Literal, TypeVar
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import HumanMessage, SystemMessage
+from pydantic import BaseModel, ValidationError
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T", bound=BaseModel)
+
+# Supported provider types
+ProviderType = Literal["gemini", "openai", "ollama"]
+
+
+def create_llm(
+    provider: ProviderType,
+    model_name: str | None,
+    temperature: float,
+    api_key: str | None,
+) -> BaseChatModel:
+    """Factory function to instantiate the correct LangChain LLM based on provider."""
+
+    if provider == "gemini":
+        from langchain_google_genai import ChatGoogleGenerativeAI
+
+        resolved_key = api_key or os.getenv("GOOGLE_API_KEY", "")
+        resolved_model = model_name or os.getenv("GEMINI_MODEL", "gemini-1.5-flash")
+
+        if not resolved_key:
+            raise ValueError(
+                "GOOGLE_API_KEY not found. Set it in .env or pass it directly."
+            )
+
+        return ChatGoogleGenerativeAI(
+            model=resolved_model,
+            google_api_key=resolved_key,
+            temperature=temperature,
+            convert_system_message_to_human=True,  # Gemini doesn't support SystemMessage natively
+        )
+
+    elif provider == "openai":
+        from langchain_openai import ChatOpenAI
+
+        resolved_key = api_key or os.getenv("OPENAI_API_KEY", "")
+        resolved_model = model_name or os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+        if not resolved_key:
+            raise ValueError(
+                "OPENAI_API_KEY not found. Set it in .env or pass it directly."
+            )
+
+        return ChatOpenAI(
+            model=resolved_model,
+            openai_api_key=resolved_key,
+            temperature=temperature,
+            request_timeout=60,  # 60s timeout
+            max_retries=2,
+        )
+
+    elif provider == "ollama":
+        from langchain_openai import ChatOpenAI
+
+        # Ollama Cloud API configuration
+        resolved_key = api_key or os.getenv("OLLAMA_API_KEY")
+        resolved_model = model_name or os.getenv("OLLAMA_MODEL", "glm-5.1:cloud")
+
+        if not resolved_key:
+            raise ValueError(
+                "OLLAMA_API_KEY not found. Set it in .env or pass it directly."
+            )
+
+        return ChatOpenAI(
+            model=resolved_model,
+            base_url="https://ollama.com/v1",
+            openai_api_key=resolved_key,
+            temperature=temperature,
+            request_timeout=120,  # 120s timeout for Ollama Cloud
+            max_retries=2,
+        )
+
+    else:
+        raise ValueError(
+            f"Unsupported provider: '{provider}'. Choose 'gemini', 'openai', or 'ollama'."
+        )
+
+
+class BaseAgent:
+    """
+    Base class for all CV evaluation agents.
+    Supports OpenAI (ChatGPT) and Google (Gemini) via LangChain.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        role: str,
+        provider: ProviderType = "gemini",
+        model_name: str | None = None,
+        temperature: float = 0,
+        api_key: str | None = None,
+    ):
+        self.name = name
+        self.role = role
+        self.provider = provider
+        self.model_name = model_name
+        self.temperature = temperature
+
+        self.llm: BaseChatModel = create_llm(
+            provider=provider,
+            model_name=model_name,
+            temperature=temperature,
+            api_key=api_key,
+        )
+
+        logger.info(
+            f"[{self.name}] Initialized with provider='{provider}', model='{self.model_name or 'default'}'"
+        )
+
+    def _build_messages(self, prompt: str) -> list:
+        """
+        Build the message list for the LLM.
+        Gemini uses convert_system_message_to_human, so SystemMessage is safe for OpenAI
+        and handled automatically for Gemini.
+        """
+        messages = []
+        if self.role:
+            messages.append(SystemMessage(content=self.role))
+        messages.append(HumanMessage(content=prompt))
+        return messages
+
+    def _extract_json_from_response(self, text: str) -> str:
+        """Extract JSON from LLM response, handling markdown code blocks."""
+        patterns = [
+            r"```json\s*([\s\S]*?)```",
+            r"```\s*([\s\S]*?)```",
+            r"(\{[\s\S]*\})",
+        ]
+        for pattern in patterns:
+            match = re.search(pattern, text)
+            if match:
+                candidate = match.group(1).strip()
+                try:
+                    json.loads(candidate)
+                    return candidate
+                except json.JSONDecodeError:
+                    continue
+
+        return text.strip()
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        retry=retry_if_exception_type((json.JSONDecodeError, ValidationError)),
+        reraise=True,
+    )
+    def _call_llm_with_retry(self, prompt: str, output_model: type[T]) -> T:
+        """Call LLM with retry logic for JSON parsing failures."""
+        logger.info(f"[{self.name}] Calling {self.provider} LLM...")
+
+        messages = self._build_messages(prompt)
+        response = self.llm.invoke(messages)
+        raw_text = response.content
+
+        logger.debug(f"[{self.name}] Raw response:\n{raw_text}")
+
+        json_str = self._extract_json_from_response(raw_text)
+
+        # --- JSON parse ---
+        try:
+            data = json.loads(json_str)
+        except json.JSONDecodeError as e:
+            logger.warning(f"[{self.name}] JSON parse error: {e}. Asking LLM to fix...")
+            fix_prompt = (
+                f"Le texte suivant devait être un JSON valide mais contient des erreurs. "
+                f"Corrige-le et renvoie UNIQUEMENT le JSON valide :\n\n{json_str}"
+            )
+            fix_response = self.llm.invoke([HumanMessage(content=fix_prompt)])
+            json_str = self._extract_json_from_response(fix_response.content)
+            data = json.loads(json_str)  # raises → retry
+
+        # --- Pydantic validation ---
+        try:
+            result = output_model.model_validate(data)
+        except ValidationError as e:
+            # Log exactly which fields are wrong
+            logger.warning(
+                f"[{self.name}] Pydantic ValidationError:\n{e}\n"
+                f"Data received:\n{json.dumps(data, indent=2, ensure_ascii=False)}"
+            )
+            # Send schema + errors back to LLM for self-correction
+            schema = json.dumps(
+                output_model.model_json_schema(), indent=2, ensure_ascii=False
+            )
+            fix_prompt = (
+                f"Le JSON suivant ne respecte pas le schéma attendu.\n\n"
+                f"SCHÉMA:\n{schema}\n\n"
+                f"JSON REÇU:\n{json.dumps(data, indent=2, ensure_ascii=False)}\n\n"
+                f"ERREURS DE VALIDATION:\n{str(e)}\n\n"
+                f"Renvoie UNIQUEMENT un JSON corrigé qui respecte exactement le schéma."
+            )
+            fix_response = self.llm.invoke([HumanMessage(content=fix_prompt)])
+            json_str = self._extract_json_from_response(fix_response.content)
+            data = json.loads(json_str)
+            result = output_model.model_validate(data)  # raises ValidationError → retry
+
+        logger.info(f"[{self.name}] Successfully parsed and validated output.")
+        return result
+
+    def run(self, **kwargs) -> Any:
+        """Override in subclasses."""
+        raise NotImplementedError("Subclasses must implement run()")

agents/experience_agent.py

@@ -0,0 +1,50 @@
+"""
+ExperienceAnalysisAgent - Extracts and evaluates each professional experience.
+"""
+
+import logging
+
+from agents.base_agent import BaseAgent
+from models.schemas import ExperienceAnalysisOutput
+from prompts.templates import EXPERIENCE_ANALYSIS_PROMPT
+
+logger = logging.getLogger(__name__)
+
+
+class ExperienceAnalysisAgent(BaseAgent):
+    def __init__(self, **kwargs):
+        super().__init__(
+            name="ExperienceAnalysisAgent",
+            role=(
+                "Extraire et évaluer chaque expérience professionnelle du CV. "
+                "Critères : contexte métier, missions différenciantes, résultats mesurables, "
+                "cohérence technique, détection d'erreurs naïves."
+            ),
+            **kwargs,
+        )
+
+    def run(self, cv_experiences: str, cv_full_text: str) -> ExperienceAnalysisOutput:
+        """
+        Analyze the experience section of a CV.
+
+        Args:
+            cv_experiences: Text content of the experiences section.
+            cv_full_text: Full CV text for context.
+
+        Returns:
+            ExperienceAnalysisOutput: Validated analysis results.
+        """
+        logger.info(f"[{self.name}] Starting experience analysis...")
+
+        prompt = EXPERIENCE_ANALYSIS_PROMPT.format(
+            cv_experiences=cv_experiences,
+            cv_full_text=cv_full_text[:8000],  # Limit context to avoid overflow
+        )
+
+        result = self._call_llm_with_retry(prompt, ExperienceAnalysisOutput)
+        logger.info(
+            f"[{self.name}] Analysis complete. "
+            f"Found {len(result.experiences)} experiences. "
+            f"Global score: {result.score_global_experiences}/10"
+        )
+        return result

agents/quality_control_agent.py

@@ -0,0 +1,70 @@
+"""
+QualityControlAgent - Final quality assessment and verdict.
+"""
+
+import json
+import logging
+
+from agents.base_agent import BaseAgent
+from models.schemas import (
+    ExperienceAnalysisOutput,
+    QualityControlOutput,
+    ScoringOutput,
+    SkillsEducationOutput,
+    SummaryValidationOutput,
+)
+from prompts.templates import QUALITY_CONTROL_PROMPT
+
+logger = logging.getLogger(__name__)
+
+
+class QualityControlAgent(BaseAgent):
+    def __init__(self, **kwargs):
+        super().__init__(
+            name="QualityControlAgent",
+            role=(
+                "Contrôle qualité final du CV. Vérifie la présence des éléments clés, "
+                "évalue l'alignement global et rend un verdict : profil vendeur vs banal."
+            ),
+            **kwargs,
+        )
+
+    def run(
+        self,
+        experience_analysis: ExperienceAnalysisOutput,
+        skills_education: SkillsEducationOutput,
+        summary_validation: SummaryValidationOutput,
+        scoring: ScoringOutput,
+    ) -> QualityControlOutput:
+        """
+        Perform final quality control assessment.
+
+        Args:
+            experience_analysis: Results from ExperienceAnalysisAgent.
+            skills_education: Results from SkillsEducationAgent.
+            summary_validation: Results from SummaryValidationAgent.
+            scoring: Results from ScoringAgent.
+
+        Returns:
+            QualityControlOutput: Final verdict and quality assessment.
+        """
+        logger.info(f"[{self.name}] Starting quality control...")
+
+        def truncated_json(obj, max_len=4000):
+            s = json.dumps(obj.model_dump(), ensure_ascii=False, indent=2)
+            return s[:max_len] if len(s) > max_len else s
+
+        prompt = QUALITY_CONTROL_PROMPT.format(
+            experience_analysis=truncated_json(experience_analysis),
+            skills_education=truncated_json(skills_education),
+            summary_validation=truncated_json(summary_validation),
+            scoring=truncated_json(scoring),
+        )
+
+        result = self._call_llm_with_retry(prompt, QualityControlOutput)
+        logger.info(
+            f"[{self.name}] Quality control complete. "
+            f"Verdict: {result.verdict}, "
+            f"Recommendation: {result.recommandation}"
+        )
+        return result

agents/scoring_agent.py

@@ -0,0 +1,87 @@
+"""
+ScoringAgent - Calculates weighted scores according to the strict formula.
+"""
+
+import logging
+
+from agents.base_agent import BaseAgent
+from models.schemas import ScoringOutput
+from prompts.templates import SCORING_PROMPT
+
+logger = logging.getLogger(__name__)
+
+
+class ScoringAgent(BaseAgent):
+    def __init__(self, **kwargs):
+        super().__init__(
+            name="ScoringAgent",
+            role=(
+                "Calculer le score final pondéré du CV selon la formule stricte : "
+                "Note/10 = (Exp × 0.5) + (Comp × 0.2) + (Form × 0.1) + (Résumé × 0.2). "
+                "Afficher les calculs intermédiaires et valider mathématiquement."
+            ),
+            **kwargs,
+        )
+
+    def run(
+        self,
+        score_experiences: float,
+        score_competences: float,
+        score_formations: float,
+        score_resume: float,
+    ) -> ScoringOutput:
+        """
+        Calculate the final weighted score.
+
+        Args:
+            score_experiences: Experience score /10
+            score_competences: Skills score /10
+            score_formations: Education score /10
+            score_resume: Summary score /10
+
+        Returns:
+            ScoringOutput: Validated scoring results.
+        """
+        logger.info(f"[{self.name}] Calculating scores...")
+
+        prompt = SCORING_PROMPT.format(
+            score_experiences=score_experiences,
+            score_competences=score_competences,
+            score_formations=score_formations,
+            score_resume=score_resume,
+        )
+
+        result = self._call_llm_with_retry(prompt, ScoringOutput)
+
+        # Double-check the math programmatically
+        expected = (
+            score_experiences * 0.5
+            + score_competences * 0.2
+            + score_formations * 0.1
+            + score_resume * 0.2
+        )
+        expected = round(expected, 2)
+
+        if abs(result.note_finale_sur_10 - expected) > 0.1:
+            logger.warning(
+                f"[{self.name}] Math discrepancy detected! "
+                f"LLM: {result.note_finale_sur_10}, Expected: {expected}. Correcting..."
+            )
+            result.note_finale_sur_10 = expected
+            result.note_finale_sur_20 = round(expected * 2, 2)
+            result.note_finale_sur_100 = round(expected * 10, 2)
+            result.validation_mathematique = True
+            result.erreur_calcul = (
+                f"Corrigé programmatiquement. LLM avait calculé différemment. "
+                f"Valeur correcte : {expected}/10"
+            )
+            result.calcul_intermediaire = (
+                f"({score_experiences} × 0.5) + ({score_competences} × 0.2) + "
+                f"({score_formations} × 0.1) + ({score_resume} × 0.2) = {expected}"
+            )
+
+        logger.info(
+            f"[{self.name}] Final score: {result.note_finale_sur_10}/10 "
+            f"({result.note_finale_sur_100}/100)"
+        )
+        return result

agents/skills_education_agent.py

@@ -0,0 +1,65 @@
+"""
+SkillsEducationAgent - Evaluates skills and education sections.
+"""
+
+import json
+import logging
+
+from agents.base_agent import BaseAgent
+from models.schemas import ExperienceAnalysisOutput, SkillsEducationOutput
+from prompts.templates import SKILLS_EDUCATION_PROMPT
+
+logger = logging.getLogger(__name__)
+
+
+class SkillsEducationAgent(BaseAgent):
+    def __init__(self, **kwargs):
+        super().__init__(
+            name="SkillsEducationAgent",
+            role=(
+                "Évaluer les compétences et formations du CV. "
+                "Critères : clarté, structuration, correspondance compétences ↔ expériences, "
+                "détection des compétences non démontrées, cohérence formation ↔ parcours."
+            ),
+            **kwargs,
+        )
+
+    def run(
+        self,
+        cv_competences: str,
+        cv_formations: str,
+        experience_analysis: ExperienceAnalysisOutput,
+    ) -> SkillsEducationOutput:
+        """
+        Analyze skills and education sections.
+
+        Args:
+            cv_competences: Text of the skills section.
+            cv_formations: Text of the education section.
+            experience_analysis: Results from ExperienceAnalysisAgent for cross-checking.
+
+        Returns:
+            SkillsEducationOutput: Validated analysis results.
+        """
+        logger.info(f"[{self.name}] Starting skills & education analysis...")
+
+        # Serialize experience analysis for context
+        exp_json = json.dumps(
+            experience_analysis.model_dump(),
+            ensure_ascii=False,
+            indent=2,
+        )
+
+        prompt = SKILLS_EDUCATION_PROMPT.format(
+            cv_competences=cv_competences,
+            cv_formations=cv_formations,
+            experience_analysis=exp_json[:6000],
+        )
+
+        result = self._call_llm_with_retry(prompt, SkillsEducationOutput)
+        logger.info(
+            f"[{self.name}] Analysis complete. "
+            f"Skills score: {result.score_competences}/10, "
+            f"Education score: {result.score_formations}/10"
+        )
+        return result

agents/summary_validation_agent.py

@@ -0,0 +1,61 @@
+"""
+SummaryValidationAgent - Validates resume/profile claims against experience evidence.
+"""
+
+import json
+import logging
+
+from agents.base_agent import BaseAgent
+from models.schemas import ExperienceAnalysisOutput, SummaryValidationOutput
+from prompts.templates import SUMMARY_VALIDATION_PROMPT
+
+logger = logging.getLogger(__name__)
+
+
+class SummaryValidationAgent(BaseAgent):
+    def __init__(self, **kwargs):
+        super().__init__(
+            name="SummaryValidationAgent",
+            role=(
+                "Valider le résumé/profil du CV en confrontant chaque affirmation "
+                "aux preuves trouvées dans les expériences. Distinguer les affirmations "
+                "prouvées des déclaratives non étayées."
+            ),
+            **kwargs,
+        )
+
+    def run(
+        self,
+        cv_resume: str,
+        experience_analysis: ExperienceAnalysisOutput,
+    ) -> SummaryValidationOutput:
+        """
+        Validate the summary/profile section against experience analysis.
+
+        Args:
+            cv_resume: Text of the summary/profile section.
+            experience_analysis: Results from ExperienceAnalysisAgent.
+
+        Returns:
+            SummaryValidationOutput: Validated analysis results.
+        """
+        logger.info(f"[{self.name}] Starting summary validation...")
+
+        exp_json = json.dumps(
+            experience_analysis.model_dump(),
+            ensure_ascii=False,
+            indent=2,
+        )
+
+        prompt = SUMMARY_VALIDATION_PROMPT.format(
+            cv_resume=cv_resume,
+            experience_analysis=exp_json[:6000],
+        )
+
+        result = self._call_llm_with_retry(prompt, SummaryValidationOutput)
+        logger.info(
+            f"[{self.name}] Validation complete. "
+            f"Resume score: {result.score_resume}/10, "
+            f"Claims proven: {result.taux_affirmations_prouvees}%"
+        )
+        return result

agents/table_generator_agent.py

@@ -0,0 +1,62 @@
+"""
+TableGeneratorAgent - Generates structured evaluation table.
+"""
+
+import json
+import logging
+
+from agents.base_agent import BaseAgent
+from models.schemas import (
+    ExperienceAnalysisOutput,
+    SkillsEducationOutput,
+    SummaryValidationOutput,
+    TableGeneratorOutput,
+)
+from prompts.templates import TABLE_GENERATOR_PROMPT
+
+logger = logging.getLogger(__name__)
+
+
+class TableGeneratorAgent(BaseAgent):
+    def __init__(self, **kwargs):
+        super().__init__(
+            name="TableGeneratorAgent",
+            role=(
+                "Générer un tableau d'évaluation structuré avec emojis et justifications "
+                "pour chaque section du CV."
+            ),
+            **kwargs,
+        )
+
+    def run(
+        self,
+        experience_analysis: ExperienceAnalysisOutput,
+        skills_education: SkillsEducationOutput,
+        summary_validation: SummaryValidationOutput,
+    ) -> TableGeneratorOutput:
+        """
+        Generate structured evaluation table.
+
+        Args:
+            experience_analysis: Results from ExperienceAnalysisAgent.
+            skills_education: Results from SkillsEducationAgent.
+            summary_validation: Results from SummaryValidationAgent.
+
+        Returns:
+            TableGeneratorOutput: Structured evaluation table.
+        """
+        logger.info(f"[{self.name}] Generating evaluation table...")
+
+        def truncated_json(obj, max_len=4000):
+            s = json.dumps(obj.model_dump(), ensure_ascii=False, indent=2)
+            return s[:max_len] if len(s) > max_len else s
+
+        prompt = TABLE_GENERATOR_PROMPT.format(
+            experience_analysis=truncated_json(experience_analysis),
+            skills_education=truncated_json(skills_education),
+            summary_validation=truncated_json(summary_validation),
+        )
+
+        result = self._call_llm_with_retry(prompt, TableGeneratorOutput)
+        logger.info(f"[{self.name}] Table generated with {len(result.lignes)} rows.")
+        return result

app.py

@@ -0,0 +1,1379 @@
+"""
+CV Evaluator - Multi-Agent Streamlit Application
+Main entry point for the CV evaluation system.
+"""
+
+import json
+import logging
+import os
+import sys
+import warnings
+from datetime import datetime
+
+import streamlit as st
+from dotenv import load_dotenv
+
+# ── Setup ──
+load_dotenv(override=False)  # Ne pas écraser les variables d'environnement existantes
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Suppress urllib3/requests compatibility warnings
+warnings.filterwarnings("ignore", category=ImportWarning, module="requests")
+
+# Add project root to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from models.schemas import FinalReport
+from orchestrator import CVEvaluationOrchestrator
+from utils.pdf_parser import extract_text_from_uploaded_file
+
+# ── Page config ──
+st.set_page_config(
+    page_title="CV Evaluator - JEMS Group",
+    page_icon="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAMAAABF0y+mAAAAulBMVEUAAAD9sxr+YXP/bmP6eFj/Tob/vBFHcEz/iUf+YXL/UoL/tRn/VX7+shv/ToX/pSn/uBb/vRD/sB7/XnT/ljr+mjX+vRH/////TYf/vRD/U4H/WHz/jj//XXX/oiz/qyL/gkn/mzT/fVP/aGj/Ym//tBn/cGP/ljn/d1v/TXb/4+H/hYj/cUz/V2j/qgj/4sH/0tT/qrT/xr//vqn/z5r/maX/j23/rJn/Xkr/8/D/jiP/w2X+fBr/wEkOWfK9AAAAF3RSTlMBL17fFObgAP42wLzzVoXlfPH5f9SEgb0o5TAAAAGFSURBVCiRZdLpkoIwDADgckbAa92j4IkIrhyiiPfq+7/WJi0o6/KD6eSbtJkkjIkPAKx322i3DbtrAbDmB6BqYTgZjYZD13UNtcEAurZcLMJJra6hPxSsYLX8q64FtfmB0PC/gj5u+cFqRanhE11xM3wQBtnx5WIDETrzb1S/5DwVGsexVBUY9KZCOee7c5qu18X2IBVTlRnh+Ii4PXFepHgYVTWx/kxoSZkJ58kBD4VM7TInmk2n8+sGY+WF80uBhyQWRdnMjEivGOIn+lEmj0XJBnvzIrqYQvQuT8UPERWR9IdCVDE/i3SZykwPNd9T6IZvJudEVES9MJjzwMtth0VlO6p7TZ2yWR/Ry6nYzXVcnrKMytoK7DKF0CPcYy98HIFEVIuBWaNsY5AlhNjkNva2Q3jHxLzSY5KkND2VxiJSvXsum0y5GU1Po0UCXaDsBT0byMlXa6TUOq0upqWpl6jSqKnWczl1s3lxy9fkAtWb2zGf2lJfdp6B8uWYg0HP+VSgtl/wnEmGER38dAAAAABJRU5ErkJggg==",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# ── Custom CSS ──
+st.markdown(
+    """
+<style>
+    /* ── Global fonts & base ── */
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+
+    html, body, [class*="css"] {
+        font-family: 'Inter', sans-serif;
+    }
+
+    /* ── Header banner ── */
+    .main-header {
+        text-align: center;
+        padding: 2rem 1.5rem;
+        background: linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%);
+        color: white;
+        border-radius: 16px;
+        margin-bottom: 2rem;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.25);
+        border: 1px solid rgba(255,255,255,0.08);
+    }
+    .main-header h1 {
+        font-size: 2.2rem;
+        font-weight: 700;
+        margin: 0 0 0.4rem 0;
+        letter-spacing: -0.5px;
+    }
+    .main-header .subtitle {
+        font-size: 1rem;
+        opacity: 0.75;
+        margin: 0;
+    }
+    .main-header .badge-row {
+        display: flex;
+        justify-content: center;
+        gap: 0.6rem;
+        margin-top: 0.8rem;
+        flex-wrap: wrap;
+    }
+    .main-header .badge {
+        background: rgba(255,255,255,0.12);
+        border: 1px solid rgba(255,255,255,0.2);
+        border-radius: 20px;
+        padding: 0.2rem 0.75rem;
+        font-size: 0.78rem;
+        font-weight: 500;
+        backdrop-filter: blur(4px);
+    }
+
+    /* ── Upload zone ── */
+    .upload-zone {
+        border: 2px dashed #4f6ef7;
+        border-radius: 12px;
+        padding: 2rem;
+        text-align: center;
+        background: linear-gradient(135deg, rgba(79,110,247,0.05), rgba(118,75,162,0.05));
+        margin-bottom: 1rem;
+    }
+    .upload-zone h3 { color: #4f6ef7; margin-bottom: 0.3rem; }
+    .upload-zone p  { color: #888; font-size: 0.9rem; margin: 0; }
+
+    /* ── File info banner ── */
+    .file-info-banner {
+        display: flex;
+        align-items: center;
+        gap: 1rem;
+        padding: 1rem 1.25rem;
+        background: linear-gradient(135deg, #d4edda, #c3e6cb);
+        border: 1px solid #b1dfbb;
+        border-radius: 10px;
+        margin: 0.75rem 0 1.25rem 0;
+    }
+    .file-info-banner .icon { font-size: 1.8rem; }
+    .file-info-banner .name { font-weight: 600; font-size: 1rem; color: #155724; }
+    .file-info-banner .size { font-size: 0.82rem; color: #2d6a4f; }
+
+    /* ── Score cards ── */
+    .score-card {
+        text-align: center;
+        padding: 1.5rem 1rem;
+        border-radius: 14px;
+        margin: 0.4rem 0;
+        box-shadow: 0 4px 16px rgba(0,0,0,0.12);
+        transition: transform 0.2s;
+    }
+    .score-card:hover { transform: translateY(-2px); }
+    .score-excellent { background: linear-gradient(135deg, #11998e, #38ef7d); color: white; }
+    .score-good      { background: linear-gradient(135deg, #36d1dc, #5b86e5); color: white; }
+    .score-average   { background: linear-gradient(135deg, #f2994a, #f2c94c); color: white; }
+    .score-low       { background: linear-gradient(135deg, #eb3349, #f45c43); color: white; }
+
+    /* ── Verdict box ── */
+    .verdict-box {
+        padding: 1.25rem 1.5rem;
+        border-radius: 10px;
+        border-left: 5px solid;
+        margin: 1rem 0;
+    }
+    .verdict-oui   { background: #d4edda; border-color: #28a745; }
+    .verdict-non   { background: #f8d7da; border-color: #dc3545; }
+    .verdict-maybe { background: #fff3cd; border-color: #ffc107; }
+
+    /* ── Agent section (sidebar) ── */
+    .agent-section {
+        background: rgba(79,110,247,0.06);
+        padding: 0.85rem 1rem;
+        border-radius: 8px;
+        margin: 0.4rem 0;
+        border-left: 3px solid #4f6ef7;
+    }
+
+    /* ── Progress bar color ── */
+    .stProgress > div > div > div > div {
+        background: linear-gradient(90deg, #4f6ef7, #764ba2);
+    }
+
+    /* ── Action buttons row ── */
+    .action-row {
+        display: flex;
+        gap: 0.75rem;
+        margin: 1rem 0;
+        flex-wrap: wrap;
+    }
+
+    /* ── Section divider ── */
+    .section-title {
+        font-size: 1.2rem;
+        font-weight: 600;
+        color: #1a1a2e;
+        padding-bottom: 0.4rem;
+        border-bottom: 2px solid #4f6ef7;
+        margin: 1.5rem 0 1rem 0;
+    }
+
+    /* ── Info chip ── */
+    .chip {
+        display: inline-block;
+        background: #eef0ff;
+        color: #4f6ef7;
+        border-radius: 20px;
+        padding: 0.15rem 0.65rem;
+        font-size: 0.78rem;
+        font-weight: 500;
+        margin: 0.15rem;
+    }
+
+    /* ── Tabs style override ── */
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 4px;
+        background: #f3f4f8;
+        padding: 4px;
+        border-radius: 10px;
+    }
+    .stTabs [data-baseweb="tab"] {
+        border-radius: 8px;
+        padding: 6px 14px;
+        font-size: 0.88rem;
+    }
+    .stTabs [aria-selected="true"] {
+        background: white !important;
+        box-shadow: 0 1px 4px rgba(0,0,0,0.12);
+    }
+
+    /* ── Barème card ── */
+    .bareme-card {
+        padding: 1.4rem 1.6rem;
+        border-radius: 16px;
+        color: white;
+        box-shadow: 0 6px 24px rgba(0,0,0,0.22);
+        margin-bottom: 1.2rem;
+        display: flex;
+        align-items: center;
+        gap: 1.2rem;
+        border: 1px solid rgba(255,255,255,0.15);
+    }
+    .bareme-card .bc-icon  { font-size: 3rem; line-height: 1; flex-shrink: 0; }
+    .bareme-card .bc-body  { flex: 1; }
+    .bareme-card .bc-label { font-size: 1.55rem; font-weight: 800; letter-spacing: -.5px; margin: 0; line-height: 1.15; }
+    .bareme-card .bc-desc  { font-size: .95rem; opacity: .85; margin: .3rem 0 0; }
+    .bareme-card .bc-score { font-size: 2.6rem; font-weight: 900; line-height: 1; flex-shrink: 0; text-align:right; }
+    .bareme-card .bc-score span { font-size: 1.1rem; font-weight: 500; opacity: .8; }
+
+    /* ── Barème scale strip ── */
+    .bareme-scale {
+        display: flex;
+        border-radius: 8px;
+        overflow: hidden;
+        height: 36px;
+        margin: .6rem 0 1.2rem;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.12);
+    }
+    .bareme-scale-seg {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: .72rem;
+        font-weight: 600;
+        color: white;
+        transition: opacity .2s;
+        cursor: default;
+    }
+    .bareme-scale-seg.active {
+        outline: 3px solid white;
+        outline-offset: -2px;
+        z-index: 1;
+        border-radius: 4px;
+    }
+    .bareme-scale-seg.inactive { opacity: .38; }
+
+    /* ── Reset banner ── */
+    .reset-banner {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 0.9rem 1.25rem;
+        background: linear-gradient(135deg, #fff8e1, #fff3cd);
+        border: 1px solid #ffe082;
+        border-radius: 10px;
+        margin-bottom: 1.2rem;
+    }
+    .reset-banner .label { font-size: 0.9rem; font-weight: 500; color: #795548; }
+</style>
+""",
+    unsafe_allow_html=True,
+)
+
+
+# ══════════════════════════════════════════════
+# HELPERS
+# ══════════════════════════════════════════════
+
+
+def get_score_class(score_100: float) -> str:
+    if score_100 >= 75:
+        return "score-excellent"
+    if score_100 >= 55:
+        return "score-good"
+    if score_100 >= 35:
+        return "score-average"
+    return "score-low"
+
+
+# ── Barème d'appréciation officiel ──
+BAREME = [
+    {
+        "range": (0, 10),
+        "label": "Inexploitable",
+        "short": "DC inutilisable, décrédibilisant.",
+        "emoji": "🚫",
+        "gradient": "linear-gradient(135deg,#3a0000,#8b0000)",
+        "text": "#ffcdd2",
+        "bar_color": "#c62828",
+    },
+    {
+        "range": (11, 12),
+        "label": "Très insuffisant",
+        "short": "DC incomplet, brouillon, donne une mauvaise image.",
+        "emoji": "❌",
+        "gradient": "linear-gradient(135deg,#7f0000,#d32f2f)",
+        "text": "#ffcdd2",
+        "bar_color": "#e53935",
+    },
+    {
+        "range": (13, 14),
+        "label": "Insuffisant",
+        "short": "DC exploitable mais faible, non vendeur.",
+        "emoji": "⚠️",
+        "gradient": "linear-gradient(135deg,#bf360c,#f4511e)",
+        "text": "#ffe0b2",
+        "bar_color": "#f4511e",
+    },
+    {
+        "range": (15, 16),
+        "label": "Correct",
+        "short": "DC utilisable mais perfectible, profil crédible mais banal.",
+        "emoji": "📋",
+        "gradient": "linear-gradient(135deg,#e65100,#fb8c00)",
+        "text": "#fff3e0",
+        "bar_color": "#fb8c00",
+    },
+    {
+        "range": (17, 17),
+        "label": "Bon",
+        "short": "DC solide, clair, cohérent, peut être transmis.",
+        "emoji": "👍",
+        "gradient": "linear-gradient(135deg,#1565c0,#1e88e5)",
+        "text": "#e3f2fd",
+        "bar_color": "#1e88e5",
+    },
+    {
+        "range": (18, 19),
+        "label": "Très bon",
+        "short": "DC percutant, vendeur, bien rédigé.",
+        "emoji": "🌟",
+        "gradient": "linear-gradient(135deg,#1b5e20,#2e7d32)",
+        "text": "#e8f5e9",
+        "bar_color": "#43a047",
+    },
+    {
+        "range": (20, 20),
+        "label": "Excellent",
+        "short": "DC exemplaire, parfaitement aligné, riche en résultats et démonstrations.",
+        "emoji": "🏆",
+        "gradient": "linear-gradient(135deg,#4a148c,#7b1fa2)",
+        "text": "#f3e5f5",
+        "bar_color": "#8e24aa",
+    },
+]
+
+ALL_LEVELS = [
+    (0, 10, "Inexploitable", "🚫", "#c62828"),
+    (11, 12, "Très insuffisant", "❌", "#e53935"),
+    (13, 14, "Insuffisant", "⚠️", "#f4511e"),
+    (15, 16, "Correct", "📋", "#fb8c00"),
+    (17, 17, "Bon", "👍", "#1e88e5"),
+    (18, 19, "Très bon", "🌟", "#43a047"),
+    (20, 20, "Excellent", "🏆", "#8e24aa"),
+]
+
+
+def get_bareme(note_sur_20: float) -> dict:
+    """Return the matching barème entry for a /20 score."""
+    n = round(note_sur_20)
+    for entry in BAREME:
+        lo, hi = entry["range"]
+        if lo <= n <= hi:
+            return entry
+    # Fallback: clamp to extremes
+    return BAREME[0] if n < 10 else BAREME[-1]
+
+
+def reset_evaluation():
+    """
+    Clear all evaluation-related session state keys.
+    Called when user wants to start a new evaluation.
+    """
+    keys_to_clear = [
+        "report",
+        "cv_text",
+        "evaluated_filename",
+        "evaluation_started",
+        "evaluation_complete",
+    ]
+    for key in keys_to_clear:
+        st.session_state.pop(key, None)
+
+
+# ══════════════════════════════════════════════
+# LAYOUT COMPONENTS
+# ══════════════════════════════════════════════
+
+
+def render_header():
+    st.markdown(
+        """
+    <style>
+        /* Animation de clignotement */
+        @keyframes blinker {
+            50% {
+                opacity: 0; /* Devient invisible au milieu du cycle */
+            }
+        }
+
+        /* Classe pour le logo qui clignote */
+        .blinking-logo {
+            animation: blinker 4.0s linear infinite; 
+            height: 50px;
+        }
+
+        .header-container {
+            display: flex;
+            flex-direction: row;
+            align-items: center;
+            justify-content: center;
+            gap: 10px;
+            margin-bottom: 10px;
+        }
+        .main-header {
+            text-align: center;
+        }
+    </style>
+    
+    <div class="main-header">
+        <div class="header-container">
+            <img src="https://www.jems-group.com/wp-content/uploads/2021/12/Logo.svg" 
+                 alt="JEMS Group Logo" 
+                 class="blinking-logo">
+            <img src="https://readme-typing-svg.demolab.com?font=Bungee+Spice&size=40&duration=3000&pause=800&color=FFFFFF&vCenter=true&width=350&lines=CV+Evaluator" 
+                 alt="CV Evaluator">
+        </div>
+        <p class="subtitle">Système Multi-Agents d'Évaluation de CV propulsé par IA GEN</p>
+        <div class="badge-row">
+            <span class="badge">⚡ 6 agents spécialisés</span>
+            <span class="badge">🧠 Analyse déterministe</span>
+            <span class="badge">📋 Rapport structuré</span>
+            <span class="badge">🔗 LangChainc</span>
+        </div>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+
+def render_sidebar():
+    with st.sidebar:
+        st.markdown(
+            """
+        <div style="text-align:center;padding:1rem 0 .5rem;">
+            <img src="https://img.icons8.com/fluency/96/artificial-intelligence.png" width="56">
+            <div style="font-size:1.1rem;font-weight:700;color:#1a1a2e;margin-top:.4rem;">Configuration</div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+        st.divider()
+
+        # ── Mode Gratuit Ollama Cloud ──
+        use_ollama = st.toggle(
+            "🆓 Utiliser le mode gratuit (Ollama Cloud)",
+            value=False,
+            help="Aucune clé API requise · Modèles open-source · Totalement gratuit",
+        )
+
+        if use_ollama:
+            # Ollama Cloud models available
+
+            model = st.selectbox(
+                "🤖 Modèle Ollama Cloud",
+                ["gpt-oss:20b-cloud", "gpt-oss:120b-cloud", "gemma4:31b-cloud"],
+                index=0,
+                help="Modèles open-source accessibles via l'API Ollama Cloud",
+            )
+            api_key = (
+                ""  # No API key needed for Ollama Cloud (uses default embedded key)
+            )
+            st.info("🔑 Clé API Ollama incluse automatiquement")
+        else:
+            # ── Mode Premium (Gemini / OpenAI) ──
+            api_key = st.text_input(
+                "🔑 Clé API Google Gemini Ou OpenAI",
+                type="password",
+                value=os.getenv("GOOGLE_API_KEY", ""),
+                help="Obtenez votre clé sur https://makersuite.google.com/app/apikey",
+            )
+
+            model = st.selectbox(
+                "🤖 Modèle Gemini & OpenAI",
+                [
+                    "gemini-2.5-flash-lite",
+                    "gemini-2.5-flash",
+                    "gemini-2.5-pro",
+                    "gpt-5",
+                    "gpt-5-mini",
+                    "gpt-5-nano",
+                    "gpt-4o",
+                    "gpt-4o-mini",
+                    "gpt-4.1",
+                    "gpt-4.1-mini",
+                    "gpt-4.1-nano",
+                    "gpt-4-turbo",
+                    "gpt-4",
+                ],
+                index=0,
+                help="Flash = rapide & économique · Pro = plus précis",
+            )
+
+        st.divider()
+        st.caption("v1.0.0 · CV-Evaluator © JEMS GROUP")
+
+        return api_key, model, use_ollama
+
+
+# ══════════════════════════════════════════════
+# RESULT RENDERERS
+# ══════════════════════════════════════════════
+
+
+def _bareme_color(note_20: float) -> str:
+    """Return the exact hex color for a /20 score per the barème."""
+    n = round(note_20)
+    if n <= 10:
+        return "#c62828"  # Rouge — Inexploitable
+    if n <= 12:
+        return "#e53935"  # Rouge-orange — Très insuffisant
+    if n <= 14:
+        return "#f4511e"  # Orange — Insuffisant
+    if n <= 16:
+        return "#7cb342"  # Vert clair — Correct
+    if n == 17:
+        return "#388e3c"  # Vert moyen — Bon
+    if n <= 19:
+        return "#2e7d32"  # Vert foncé — Très bon
+    return "#1b5e20"  # Vert très foncé — Excellent
+
+
+def _progress_ring_svg(
+    value: float, max_val: float, label: str, sublabel: str, color: str, size: int = 160
+) -> str:
+    """
+    Generate an SVG animated progress ring.
+    value   : raw score value
+    max_val : maximum possible value
+    label   : big centred text (the score string)
+    sublabel: small text below (e.g. '/ 20')
+    color   : stroke colour hex
+    """
+    pct = min(value / max_val, 1.0)
+    radius = (size - 24) / 2
+    circ = 2 * 3.14159 * radius
+    dash_val = pct * circ
+    track_color = "#e8eaf0"
+    cx = cy = size / 2
+    anim_id = f"anim_{label.replace('/', '').replace(' ', '')}"
+
+    return f"""
+<svg width="{size}" height="{size}" viewBox="0 0 {size} {size}" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <style>
+      @keyframes {anim_id} {{
+        from {{ stroke-dashoffset: {circ:.2f}; }}
+        to   {{ stroke-dashoffset: {circ - dash_val:.2f}; }}
+      }}
+    </style>
+    <filter id="glow_{anim_id}">
+      <feGaussianBlur stdDeviation="3" result="blur"/>
+      <feMerge><feMergeNode in="blur"/><feMergeNode in="SourceGraphic"/></feMerge>
+    </filter>
+  </defs>
+  <!-- Track -->
+  <circle cx="{cx}" cy="{cy}" r="{radius}" fill="none"
+          stroke="{track_color}" stroke-width="12"/>
+  <!-- Progress arc -->
+  <circle cx="{cx}" cy="{cy}" r="{radius}" fill="none"
+          stroke="{color}" stroke-width="12"
+          stroke-linecap="round"
+          stroke-dasharray="{circ:.2f}"
+          stroke-dashoffset="{circ:.2f}"
+          transform="rotate(-90 {cx} {cy})"
+          filter="url(#glow_{anim_id})"
+          style="animation:{anim_id} 1.2s ease-out forwards;">
+    <animate attributeName="stroke-dashoffset"
+             from="{circ:.2f}" to="{circ - dash_val:.2f}"
+             dur="1.2s" fill="freeze" calcMode="spline"
+             keyTimes="0;1" keySplines="0.4 0 0.2 1"/>
+  </circle>
+  <!-- Centre label -->
+  <text x="{cx}" y="{cy - 8}" text-anchor="middle" dominant-baseline="middle"
+        font-family="Inter,sans-serif" font-size="28" font-weight="800" fill="{color}">{label}</text>
+  <text x="{cx}" y="{cy + 20}" text-anchor="middle"
+        font-family="Inter,sans-serif" font-size="13" font-weight="500" fill="#9ea3b0">{sublabel}</text>
+</svg>"""
+
+
+def render_scores(report: FinalReport):
+    scoring = report.scoring
+    score_20 = scoring.note_finale_sur_20
+    score_10 = scoring.note_finale_sur_10
+    score_100 = scoring.note_finale_sur_100
+    bareme = get_bareme(score_20)
+    ring_color = _bareme_color(score_20)
+
+    # ── Section title ──
+    st.markdown('<div class="section-title">📊 Scores</div>', unsafe_allow_html=True)
+
+    # ── 3 progress rings ──
+    c10, c20, c100 = st.columns(3)
+
+    ring_css = """
+    <style>
+    .ring-wrapper {
+        display:flex; flex-direction:column; align-items:center;
+        padding:1.4rem 1rem 1rem;
+        background:#fff;
+        border-radius:18px;
+        box-shadow:0 2px 16px rgba(0,0,0,.07);
+        border:1px solid #f0f1f5;
+        transition:transform .2s;
+    }
+    .ring-wrapper:hover { transform:translateY(-3px); box-shadow:0 6px 24px rgba(0,0,0,.11); }
+    .ring-title {
+        font-family:'Inter',sans-serif;
+        font-size:.78rem; font-weight:600; letter-spacing:.06em;
+        text-transform:uppercase; color:#9ea3b0; margin-bottom:.6rem;
+    }
+    .ring-badge {
+        margin-top:.8rem;
+        display:inline-block;
+        padding:.28rem .85rem;
+        border-radius:20px;
+        font-size:.82rem; font-weight:700;
+        color:white;
+    }
+    </style>
+    """
+    st.markdown(ring_css, unsafe_allow_html=True)
+
+    with c10:
+        svg = _progress_ring_svg(score_10, 10, f"{score_10:.1f}", "/ 10", ring_color)
+        st.markdown(
+            f'<div class="ring-wrapper">'
+            f'<div class="ring-title">Score sur 10</div>'
+            f"{svg}"
+            f'<div class="ring-badge" style="background:{ring_color};">{bareme["emoji"]} {bareme["label"]}</div>'
+            f"</div>",
+            unsafe_allow_html=True,
+        )
+
+    with c20:
+        svg = _progress_ring_svg(
+            score_20, 20, f"{score_20:.1f}", "/ 20", ring_color, size=190
+        )
+        st.markdown(
+            f'<div class="ring-wrapper" style="border:2px solid {ring_color}30;">'
+            f'<div class="ring-title" style="color:{ring_color};">⭐ Score sur 20</div>'
+            f"{svg}"
+            f'<div class="ring-badge" style="background:{ring_color};font-size:.9rem;padding:.35rem 1.1rem;">'
+            f"{bareme['emoji']} {bareme['label']}</div>"
+            f"</div>",
+            unsafe_allow_html=True,
+        )
+
+    with c100:
+        svg = _progress_ring_svg(
+            score_100, 100, f"{score_100:.0f}", "/ 100", ring_color
+        )
+        st.markdown(
+            f'<div class="ring-wrapper">'
+            f'<div class="ring-title">Score sur 100</div>'
+            f"{svg}"
+            f'<div class="ring-badge" style="background:{ring_color};">{bareme["emoji"]} {bareme["label"]}</div>'
+            f"</div>",
+            unsafe_allow_html=True,
+        )
+
+    st.markdown("<br>", unsafe_allow_html=True)
+
+    # ── Recommandation + Verdict row ──
+    col_rec, col_ver = st.columns(2)
+
+    with col_rec:
+        rec = report.quality_control.recommandation
+        rec_emoji = {"Oui": "✅", "Non": "❌", "Peut-être": "⚠️"}.get(rec, "❓")
+        rec_color = {"Oui": "#155724", "Non": "#721c24", "Peut-être": "#856404"}.get(
+            rec, "#6c757d"
+        )
+        rec_bg = {"Oui": "#d4edda", "Non": "#f8d7da", "Peut-être": "#fff3cd"}.get(
+            rec, "#f0f2f8"
+        )
+        st.markdown(
+            f"""
+        <div style="display:flex;align-items:center;gap:1rem;padding:1.1rem 1.4rem;
+                    background:{rec_bg};border-radius:12px;border:1px solid {rec_color}30;">
+            <span style="font-size:2rem;">{rec_emoji}</span>
+            <div>
+                <div style="font-size:.72rem;font-weight:600;text-transform:uppercase;
+                            letter-spacing:.06em;color:{rec_color};opacity:.7;">Recommandation</div>
+                <div style="font-size:1.2rem;font-weight:800;color:{rec_color};">{rec}</div>
+            </div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    with col_ver:
+        verdict_label = report.quality_control.verdict.replace("_", " ").title()
+        verdict_emoji = {
+            "profil vendeur": "🌟",
+            "profil banal": "😐",
+            "profil intermediaire": "🤔",
+        }.get(report.quality_control.verdict.replace("_", " "), "❓")
+        st.markdown(
+            f"""
+        <div style="display:flex;align-items:center;gap:1rem;padding:1.1rem 1.4rem;
+                    background:#f5f6fa;border-radius:12px;border:1px solid #e0e2ea;">
+            <span style="font-size:2rem;">{verdict_emoji}</span>
+            <div>
+                <div style="font-size:.72rem;font-weight:600;text-transform:uppercase;
+                            letter-spacing:.06em;color:#888;">Verdict</div>
+                <div style="font-size:1.2rem;font-weight:800;color:#1a1a2e;">{verdict_label}</div>
+            </div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+    st.markdown("<br>", unsafe_allow_html=True)
+
+    # ── Detail by criterion ──
+    st.markdown(
+        '<div class="section-title">📈 Détail par critère</div>', unsafe_allow_html=True
+    )
+    cols = st.columns(4)
+    for i, detail in enumerate(scoring.details):
+        with cols[i]:
+            pct = detail.score_brut * 10
+            bar_color = _bareme_color(
+                detail.score_brut * 2
+            )  # map /10 → /20 scale for colour
+            st.metric(
+                label=f"{detail.critere}",
+                value=f"{detail.score_brut}/10",
+                delta=f"Pondéré : {detail.score_pondere:.2f}  (×{detail.poids})",
+            )
+            st.markdown(
+                f'<div style="height:6px;border-radius:4px;background:#e8eaf0;overflow:hidden;">'
+                f'<div style="width:{pct}%;height:100%;background:{bar_color};'
+                f'border-radius:4px;transition:width 1s ease;"></div></div><br>',
+                unsafe_allow_html=True,
+            )
+
+    with st.expander("🔢 Détail du calcul mathématique"):
+        st.code(scoring.calcul_intermediaire)
+        if scoring.validation_mathematique:
+            st.success("✅ Validation mathématique OK")
+        else:
+            st.error("❌ Erreur de calcul détectée")
+        if scoring.erreur_calcul:
+            st.warning(scoring.erreur_calcul)
+
+
+def render_evaluation_table(report: FinalReport):
+    st.markdown(
+        '<div class="section-title">📋 Tableau d\'Évaluation Détaillé</div>',
+        unsafe_allow_html=True,
+    )
+
+    table = report.evaluation_table
+    if not table.lignes:
+        st.warning("Aucune donnée dans le tableau d'évaluation.")
+        return
+
+    headers = [
+        "Élément",
+        "Clarté",
+        "Cohérence",
+        "Qualité réd.",
+        "Pertinence",
+        "Respect règles",
+        "Erreurs naïves",
+    ]
+    header_row = "| " + " | ".join(headers) + " |"
+    separator = "| " + " | ".join(["---"] * len(headers)) + " |"
+    rows = []
+    for row in table.lignes:
+        cells = [
+            f"**{row.element}**",
+            f"{row.clarte.emoji} {row.clarte.justification[:50]}",
+            f"{row.coherence.emoji} {row.coherence.justification[:50]}",
+            f"{row.qualite_redactionnelle.emoji} {row.qualite_redactionnelle.justification[:50]}",
+            f"{row.pertinence.emoji} {row.pertinence.justification[:50]}",
+            f"{row.respect_regles.emoji} {row.respect_regles.justification[:50]}",
+            f"{row.erreurs_naives.emoji} {row.erreurs_naives.justification[:50]}",
+        ]
+        rows.append("| " + " | ".join(cells) + " |")
+
+    st.markdown("\n".join([header_row, separator] + rows), unsafe_allow_html=True)
+
+    with st.expander("🔎 Voir les justifications complètes"):
+        for row in table.lignes:
+            st.markdown(f"#### {row.element}")
+            detail_cols = st.columns(6)
+            for j, (label, cell) in enumerate(
+                [
+                    ("Clarté", row.clarte),
+                    ("Cohérence", row.coherence),
+                    ("Qualité réd.", row.qualite_redactionnelle),
+                    ("Pertinence", row.pertinence),
+                    ("Respect règles", row.respect_regles),
+                    ("Erreurs naïves", row.erreurs_naives),
+                ]
+            ):
+                with detail_cols[j]:
+                    st.markdown(f"**{label}** {cell.emoji}")
+                    st.caption(cell.justification)
+            st.divider()
+
+    st.info(f"📝 {table.resume_tableau}")
+
+
+def render_experience_analysis(report: FinalReport):
+    st.markdown(
+        '<div class="section-title">🔍 Analyse des Expériences</div>',
+        unsafe_allow_html=True,
+    )
+    exp = report.experience_analysis
+
+    c1, c2 = st.columns([1, 3])
+    with c1:
+        st.metric("Score global", f"{exp.score_global_experiences}/10")
+    with c2:
+        st.info(f"💬 **Synthèse :** {exp.synthese}")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown("#### ✅ Points forts")
+        for p in exp.points_forts:
+            st.markdown(f"- 🟢 {p}")
+    with col2:
+        st.markdown("#### ⚠️ Points faibles")
+        for p in exp.points_faibles:
+            st.markdown(f"- 🔴 {p}")
+
+    if exp.donnees_manquantes:
+        st.warning("**Données manquantes :** " + ", ".join(exp.donnees_manquantes))
+
+    st.markdown(f"#### 💼 Expériences détaillées ({len(exp.experiences)})")
+    for e in exp.experiences:
+        with st.expander(f"💼 {e.poste} @ {e.entreprise} — {e.score}/10"):
+            cols = st.columns([1, 1, 1])
+            with cols[0]:
+                st.markdown(f"📅 **Période :** {e.periode}")
+            with cols[1]:
+                st.markdown(f"⏱️ **Durée :** {e.duree_estimee or 'non précisée'}")
+            with cols[2]:
+                st.metric("Score", f"{e.score}/10")
+
+            st.markdown(f"**Contexte métier :** {e.contexte_metier}")
+            st.markdown(f"**Cohérence technique :** {e.coherence_technique}")
+
+            if e.missions:
+                st.markdown("**Missions :**")
+                for m in e.missions:
+                    st.markdown(f"  - {m}")
+            if e.missions_differenciantes:
+                st.markdown("**🌟 Missions différenciantes :**")
+                for m in e.missions_differenciantes:
+                    st.markdown(f"  - ⭐ {m}")
+            if e.resultats_mesurables:
+                st.markdown("**📊 Résultats mesurables :**")
+                for r in e.resultats_mesurables:
+                    st.markdown(f"  - 📈 {r}")
+            if e.erreurs_naives:
+                st.error("**❌ Erreurs naïves détectées :**")
+                for err in e.erreurs_naives:
+                    st.markdown(f"  - ⚠️ {err}")
+            st.caption(f"**Justification du score :** {e.justification_score}")
+
+
+def render_skills_education(report: FinalReport):
+    st.markdown(
+        '<div class="section-title">🎯 Compétences & Formations</div>',
+        unsafe_allow_html=True,
+    )
+    se = report.skills_education
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.metric("Score Compétences", f"{se.score_competences}/10")
+    with col2:
+        st.metric("Score Formations", f"{se.score_formations}/10")
+
+    st.markdown("#### 🛠️ Compétences")
+    demonstrated = [c for c in se.competences if c.demontree_dans_experience]
+    not_demonstrated = [c for c in se.competences if not c.demontree_dans_experience]
+
+    if demonstrated:
+        st.markdown("**✅ Compétences démontrées**")
+        for c in demonstrated:
+            level = f" ({c.niveau_estime})" if c.niveau_estime else ""
+            assoc = f" → _{c.experience_associee}_" if c.experience_associee else ""
+            st.markdown(f"- ✅ **{c.nom}** `{c.categorie}`{level}{assoc}")
+
+    if not_demonstrated:
+        st.markdown("**❌ Compétences non démontrées**")
+        for c in not_demonstrated:
+            st.markdown(f"- ❌ **{c.nom}** `{c.categorie}` — Déclarée mais non prouvée")
+
+    st.markdown("#### 🎓 Formations")
+    for f in se.formations:
+        year = f" ({f.annee})" if f.annee else ""
+        st.markdown(f"- 📚 **{f.diplome}** — {f.etablissement}{year}")
+        st.caption(f"  Cohérence parcours : {f.coherence_parcours}")
+
+    st.info(f"**Cohérence formation ↔ parcours :** {se.coherence_formation_parcours}")
+
+
+def render_summary_validation(report: FinalReport):
+    st.markdown(
+        '<div class="section-title">✅ Validation du Résumé / Profil</div>',
+        unsafe_allow_html=True,
+    )
+    sv = report.summary_validation
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("Score Résumé", f"{sv.score_resume}/10")
+    with col2:
+        st.metric("Affirmations prouvées", f"{sv.taux_affirmations_prouvees:.0f}%")
+    with col3:
+        total = len(sv.affirmations_analysees)
+        proven = sum(1 for a in sv.affirmations_analysees if a.prouvee)
+        st.metric("Ratio", f"{proven}/{total}")
+
+    col_pos = st.columns(2)
+    with col_pos[0]:
+        st.info(f"📌 **Positionnement déclaré :** {sv.positionnement_declare}")
+    with col_pos[1]:
+        st.info(f"🔎 **Positionnement réel :** {sv.positionnement_reel}")
+
+    if sv.ecarts_alignement:
+        st.warning("**Écarts d'alignement :**")
+        for e in sv.ecarts_alignement:
+            st.markdown(f"- ⚠️ {e}")
+
+    st.markdown("#### 📝 Analyse des affirmations")
+    for a in sv.affirmations_analysees:
+        icon = "✅" if a.prouvee else "❌"
+        label = a.affirmation[:80] + "…" if len(a.affirmation) > 80 else a.affirmation
+        with st.expander(f"{icon} « {label} »"):
+            st.markdown(f"**Prouvée :** {'Oui ✅' if a.prouvee else 'Non ❌'}")
+            if a.preuve:
+                st.markdown(f"**Preuve :** {a.preuve}")
+            st.markdown(f"**Commentaire :** {a.commentaire}")
+
+
+def render_quality_control(report: FinalReport):
+    st.markdown(
+        '<div class="section-title">🏁 Contrôle Qualité Final</div>',
+        unsafe_allow_html=True,
+    )
+    qc = report.quality_control
+
+    verdict_class = {
+        "Oui": "verdict-oui",
+        "Non": "verdict-non",
+        "Peut-être": "verdict-maybe",
+    }.get(qc.recommandation, "verdict-maybe")
+    st.markdown(
+        f"""
+    <div class="verdict-box {verdict_class}">
+        <h3 style="margin:0 0 .4rem 0;">Recommandation : {qc.recommandation}</h3>
+        <p style="margin:0;">{qc.justification_recommandation}</p>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    c1, c2, c3 = st.columns(3)
+    with c1:
+        st.markdown(f"**Verdict :** {qc.verdict.replace('_', ' ').title()}")
+    with c2:
+        st.markdown(f"**Alignement global :** {qc.alignement_global}")
+    with c3:
+        st.metric("Score Alignement", f"{qc.score_alignement}/10")
+
+    st.markdown(f"**Justification :** {qc.justification_verdict}")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown("#### 💪 Forces")
+        for f in qc.forces:
+            st.markdown(f"- 🟢 {f}")
+    with col2:
+        st.markdown("#### 📉 Faiblesses")
+        for f in qc.faiblesses:
+            st.markdown(f"- 🔴 {f}")
+
+    with st.expander("📋 Éléments vérifiés"):
+        quality_colors = {
+            "excellent": "🟢",
+            "bon": "🔵",
+            "moyen": "🟡",
+            "faible": "🟠",
+            "absent": "🔴",
+        }
+        for item in qc.elements_verifies:
+            icon = "✅" if item.present else "❌"
+            q_emoji = quality_colors.get(item.qualite, "⚪")
+            st.markdown(
+                f"{icon} **{item.element}** — {q_emoji} {item.qualite.title()} : {item.commentaire}"
+            )
+
+
+def render_export_section(report: FinalReport):
+    """Render the Export tab with JSON download and CV text download."""
+    st.markdown(
+        '<div class="section-title">📥 Export & Téléchargements</div>',
+        unsafe_allow_html=True,
+    )
+
+    report_json = report.model_dump_json(indent=2)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    col_json, col_txt, col_preview = st.columns([1, 1, 1])
+
+    # ── JSON download ──
+    with col_json:
+        st.markdown("**📄 Rapport complet**")
+        st.download_button(
+            label="⬇️ Télécharger JSON",
+            data=report_json,
+            file_name=f"cv_evaluation_{timestamp}.json",
+            mime="application/json",
+            use_container_width=True,
+        )
+
+    # ── CV text download ──
+    with col_txt:
+        st.markdown("**📝 Texte extrait du CV**")
+        cv_text = st.session_state.get("cv_text", "")
+        if cv_text:
+            st.download_button(
+                label="⬇️ Télécharger CV (.txt)",
+                data=cv_text,
+                file_name=f"cv_extrait_{timestamp}.txt",
+                mime="text/plain",
+                use_container_width=True,
+                help="Télécharger le texte brut extrait du PDF",
+            )
+        else:
+            st.info("Texte du CV non disponible.")
+
+    # ── Copy preview ──
+    with col_preview:
+        st.markdown("**🔍 Aperçu JSON**")
+        if st.button("👁️ Afficher aperçu", use_container_width=True):
+            st.code(report_json[:600] + "\n…", language="json")
+
+    with st.expander("🔎 Voir le JSON complet"):
+        st.json(json.loads(report_json))
+
+
+# ══════════════════════════════════════════════
+# MAIN APPLICATION
+# ══════════════════════════════════════════════
+
+
+def main():
+    render_header()
+    api_key, model, use_ollama = render_sidebar()
+
+    # ── Upload section ──
+    st.markdown(
+        '<div class="section-title">📤 Importer un CV</div>', unsafe_allow_html=True
+    )
+
+    # If a previous result exists, show a reset banner at the top
+    if "report" in st.session_state:
+        fname = st.session_state.get("evaluated_filename", "CV précédent")
+        reset_col1, reset_col2 = st.columns([5, 1])
+        with reset_col1:
+            st.markdown(
+                f'<div class="reset-banner">'
+                f'<span class="label">📌 Résultat actuel : <strong>{fname}</strong> — '
+                f"Pour analyser un nouveau CV, réinitialisez d'abord.</span>"
+                f"</div>",
+                unsafe_allow_html=True,
+            )
+        with reset_col2:
+            if st.button(
+                "🔄 Réinitialiser",
+                type="secondary",
+                use_container_width=True,
+                help="Efface les résultats et permet de déposer un nouveau CV",
+            ):
+                reset_evaluation()
+                st.rerun()
+
+    uploaded_file = st.file_uploader(
+        "Glissez votre CV au format PDF ici",
+        type=["pdf"],
+        help="Format accepté : PDF · Taille max : 10 Mo · 2 pages max recommandées",
+        disabled="report" in st.session_state,  # lock uploader once evaluated
+    )
+
+    # Validate file size early
+    if uploaded_file and uploaded_file.size > 10 * 1024 * 1024:
+        st.error("❌ Le fichier dépasse 10 Mo. Veuillez compresser votre PDF.")
+        return
+
+    if uploaded_file:
+        # File info card
+        st.markdown(
+            f'<div class="file-info-banner">'
+            f'<span class="icon">📄</span>'
+            f'<div><div class="name">{uploaded_file.name}</div>'
+            f'<div class="size">{uploaded_file.size / 1024:.1f} Ko · PDF</div></div>'
+            f"</div>",
+            unsafe_allow_html=True,
+        )
+
+        # API key validation: required for Gemini/OpenAI, not for Ollama Cloud
+        if not use_ollama and not api_key:
+            st.error(
+                "⚠️ Veuillez entrer votre clé API Gemini/OpenAI dans la barre latérale."
+            )
+            return
+
+        # ── Evaluate button ──
+        if "report" not in st.session_state:
+            if st.button(
+                "🚀 Lancer l'évaluation", type="primary", use_container_width=True
+            ):
+                progress_bar = st.progress(0)
+                status_box = st.empty()
+
+                def progress_callback(message: str, percentage: float):
+                    progress_bar.progress(min(percentage, 1.0))
+                    status_box.info(f"⏳ {message}")
+
+                try:
+                    # Step 1 – extract text
+                    with st.spinner("📄 Extraction du texte du PDF…"):
+                        try:
+                            cv_text = extract_text_from_uploaded_file(uploaded_file)
+                        except Exception as e:
+                            # Handle custom PDFExtractionError with user-friendly message
+                            error_msg = str(e)
+                            if "vide" in error_msg.lower():
+                                st.error(
+                                    "❌ Le PDF est vide. Veuillez vérifier le fichier."
+                                )
+                            elif (
+                                "scanné" in error_msg.lower()
+                                or "image" in error_msg.lower()
+                            ):
+                                st.error(
+                                    "❌ Le PDF semble être une image scannée. "
+                                    "Le texte ne peut pas être extrait. "
+                                    "Utilisez un PDF avec du texte sélectionnable."
+                                )
+                            else:
+                                st.error(
+                                    f"❌ Erreur lors de la lecture du PDF : {error_msg}"
+                                )
+                            return
+
+                    if len(cv_text.strip()) < 100:
+                        st.error(
+                            "❌ Le PDF contient très peu de texte (< 100 caractères). "
+                            "Veuillez vérifier le fichier."
+                        )
+                        return
+
+                    # Persist extracted text for download later
+                    st.session_state["cv_text"] = cv_text
+
+                    with st.expander("📄 Texte extrait du CV (aperçu)", expanded=False):
+                        st.text(cv_text[:3000] + ("…" if len(cv_text) > 3000 else ""))
+
+                    # Step 2 – run evaluation
+                    # Force ollama provider when using Ollama Cloud mode
+                    if use_ollama:
+                        # Use API key from environment variable (required for Ollama Cloud)
+                        ollama_api_key = "d3416cecd2bd4e81a52dde8ba54bbd9c.uT8ag03jpMcxjOm5we3zKGYK"
+                        if not ollama_api_key:
+                            st.error(
+                                "⚠️ Clé API Ollama manquante. "
+                                "Ajoutez OLLAMA_API_KEY dans votre fichier .env ou en variable d'environnement."
+                            )
+                            return
+                        orchestrator = CVEvaluationOrchestrator(
+                            api_key=ollama_api_key,
+                            model_name=model,
+                            cache_dir=None,
+                            progress_callback=progress_callback,
+                        )
+                    else:
+                        orchestrator = CVEvaluationOrchestrator(
+                            api_key=api_key,
+                            model_name=model,
+                            cache_dir=None,
+                            progress_callback=progress_callback,
+                        )
+
+                    report = orchestrator.evaluate(cv_text)
+
+                    # Persist results
+                    st.session_state["report"] = report
+                    st.session_state["evaluated_filename"] = uploaded_file.name
+
+                    progress_bar.progress(1.0)
+                    status_box.success("✅ Évaluation terminée avec succès !")
+
+                except Exception as e:
+                    error_msg = str(e)
+                    # User-friendly error messages
+                    if "API" in error_msg or "api" in error_msg.lower():
+                        st.error(
+                            "❌ Erreur de connexion à l'API. Vérifiez votre clé API et votre connexion internet."
+                        )
+                    elif "timeout" in error_msg.lower():
+                        st.error(
+                            "⏱️ La requête a expiré. Le modèle est peut-être surchargé. Réessayez dans quelques instants."
+                        )
+                    elif "JSON" in error_msg or "parsing" in error_msg.lower():
+                        st.error(
+                            "🔧 Erreur d'analyse de la réponse IA. Le modèle a renvoyé un format invalide. Réessayez."
+                        )
+                    else:
+                        st.error(f"❌ Erreur lors de l'évaluation : {error_msg}")
+                    logger.error(f"[App] Evaluation error: {error_msg}", exc_info=True)
+                    return
+
+    # ── Results display ──
+    if "report" in st.session_state:
+        report = st.session_state["report"]
+
+        # ══════════════════════════════════════════════
+        # NEW EVALUATION SECTION - Prominent CTA
+        # ══════════════════════════════════════════════
+        st.markdown(
+            """
+        <style>
+            .new-eval-section {
+                display: flex;
+                align-items: center;
+                justify-content: space-between;
+                padding: 1.5rem 2rem;
+                background: linear-gradient(135deg, rgba(79,110,247,0.08), rgba(118,75,162,0.08));
+                border: 2px solid #4f6ef7;
+                border-radius: 16px;
+                margin: 1.5rem 0;
+                box-shadow: 0 4px 20px rgba(79,110,247,0.15);
+            }
+            .new-eval-text h3 {
+                color: #1a1a2e;
+                margin: 0 0 0.3rem 0;
+                font-size: 1.3rem;
+            }
+            .new-eval-text p {
+                color: #666;
+                margin: 0;
+                font-size: 0.95rem;
+            }
+            .new-eval-btn {
+                background: linear-gradient(135deg, #4f6ef7, #764ba2);
+                color: white;
+                border: none;
+                padding: 0.85rem 2rem;
+                border-radius: 12px;
+                font-size: 1rem;
+                font-weight: 600;
+                cursor: pointer;
+                box-shadow: 0 4px 15px rgba(79,110,247,0.3);
+                transition: transform 0.2s, box-shadow 0.2s;
+            }
+            .new-eval-btn:hover {
+                transform: translateY(-2px);
+                box-shadow: 0 6px 20px rgba(79,110,247,0.4);
+            }
+        </style>
+        """,
+            unsafe_allow_html=True,
+        )
+
+        st.markdown(
+            """
+        <div class="new-eval-section">
+            <div class="new-eval-text">
+                <h3>✨ Évaluation terminée !</h3>
+                <p>Souhaitez-vous analyser un nouveau CV ?</p>
+            </div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+        # Full-width button for new evaluation
+        if st.button(
+            "🔄 Nouvelle évaluation",
+            type="primary",
+            use_container_width=True,
+            help="Réinitialiser tous les résultats et commencer une nouvelle évaluation",
+            key="new_evaluation_btn",
+        ):
+            reset_evaluation()
+            st.rerun()
+
+        st.divider()
+
+        # Sidebar metadata
+        with st.sidebar:
+            st.divider()
+            st.markdown("### 📊 Métadonnées")
+            meta = report.metadata
+            st.caption(f"📅 {meta.get('date_evaluation', 'N/A')}")
+
+            # Display provider badge
+            model_name = meta.get("modele_llm", "N/A")
+            provider_badge = ""
+            if model_name.endswith("-cloud") or "ollama" in model_name.lower():
+                provider_badge = "🆓 Ollama Cloud"
+            elif model_name.startswith("gemini"):
+                provider_badge = "💎 Google Gemini"
+            else:
+                provider_badge = "🔵 OpenAI"
+
+            st.caption(f"🤖 {model_name}")
+            st.markdown(
+                f"<span class='chip'>{provider_badge}</span>", unsafe_allow_html=True
+            )
+            st.caption(f"⏱️ {meta.get('duree_evaluation_secondes', 'N/A')} s")
+            st.caption(f"📂 {', '.join(meta.get('sections_detectees', []))}")
+
+            # Also add a reset button in sidebar for convenience
+            st.divider()
+            if st.button(
+                "🗑️ Effacer les résultats",
+                type="secondary",
+                use_container_width=True,
+                help="Supprimer les résultats actuels",
+                key="sidebar_reset_btn",
+            ):
+                reset_evaluation()
+                st.rerun()
+
+        tabs = st.tabs(
+            [
+                "📊 Scores",
+                "📋 Tableau",
+                "🔍 Expériences",
+                "🎯 Compétences",
+                "✅ Résumé",
+                "🏁 Qualité",
+                "📥 Export",
+            ]
+        )
+
+        with tabs[0]:
+            render_scores(report)
+        with tabs[1]:
+            render_evaluation_table(report)
+        with tabs[2]:
+            render_experience_analysis(report)
+        with tabs[3]:
+            render_skills_education(report)
+        with tabs[4]:
+            render_summary_validation(report)
+        with tabs[5]:
+            render_quality_control(report)
+        with tabs[6]:
+            render_export_section(report)
+
+
+if __name__ == "__main__":
+    main()

docker-compose.prod.yml

@@ -0,0 +1,22 @@
+# docker-compose.prod.yml
+# Configuration pour le déploiement en production
+
+version: "3.8"
+
+services:
+  cv-evaluator:
+    image: ${DOCKER_USERNAME:-yacineberkani}/cv-evaluator:latest
+    container_name: cv-evaluator
+    restart: unless-stopped
+    ports:
+      - "8501:8501"
+    environment:
+      - GOOGLE_API_KEY=${GOOGLE_API_KEY}
+      - GEMINI_MODEL=${GEMINI_MODEL:-gemini-2.5-flash-lite}
+      - GEMINI_TEMPERATURE=${GEMINI_TEMPERATURE:-0}
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8501"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s

models/__init__.py

@@ -0,0 +1 @@
+from models.schemas import *

models/schemas.py

@@ -0,0 +1,222 @@
+"""
+Pydantic schemas for strict JSON validation across all agents.
+Each model enforces deterministic, structured output.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+# ─────────────────────────────────────────────
+# ExperienceAnalysisAgent models
+# ─────────────────────────────────────────────
+
+
+class ExperienceEntry(BaseModel):
+    poste: str = Field(..., description="Intitulé du poste")
+    entreprise: str = Field(..., description="Nom de l'entreprise")
+    periode: str = Field(..., description="Période (ex: Jan 2020 - Dec 2022)")
+    duree_estimee: str | None = Field(None, description="Durée estimée")
+    contexte_metier: str = Field(..., description="Contexte métier décrit ou inféré")
+    missions: list[str] = Field(default_factory=list, description="Liste des missions")
+    missions_differenciantes: list[str] = Field(
+        default_factory=list, description="Missions qui se démarquent"
+    )
+    resultats_mesurables: list[str] = Field(
+        default_factory=list, description="Résultats chiffrés/mesurables"
+    )
+    coherence_technique: str = Field(
+        ..., description="Évaluation de la cohérence technique"
+    )
+    erreurs_naives: list[str] = Field(
+        default_factory=list, description="Erreurs naïves détectées"
+    )
+    score: float = Field(
+        ..., ge=0, le=10, description="Score /10 pour cette expérience"
+    )
+    justification_score: str = Field(..., description="Justification du score attribué")
+
+
+class ExperienceAnalysisOutput(BaseModel):
+    experiences: list[ExperienceEntry] = Field(default_factory=list)
+    score_global_experiences: float = Field(..., ge=0, le=10)
+    synthese: str = Field(..., description="Synthèse globale des expériences")
+    points_forts: list[str] = Field(default_factory=list)
+    points_faibles: list[str] = Field(default_factory=list)
+    donnees_manquantes: list[str] = Field(
+        default_factory=list, description="Informations critiques absentes"
+    )
+
+
+# ─────────────────────────────────────────────
+# SkillsEducationAgent models
+# ─────────────────────────────────────────────
+
+
+class CompetenceEntry(BaseModel):
+    nom: str = Field(..., description="Nom de la compétence")
+    categorie: str = Field(
+        ..., description="Catégorie (technique, soft skill, métier...)"
+    )
+    demontree_dans_experience: bool = Field(
+        ..., description="Si la compétence est démontrée dans les expériences"
+    )
+    experience_associee: str | None = Field(
+        None, description="Expérience où elle est démontrée"
+    )
+    niveau_estime: str | None = Field(None, description="Niveau estimé si mentionné")
+
+
+class FormationEntry(BaseModel):
+    diplome: str = Field(..., description="Intitulé du diplôme")
+    etablissement: str = Field(..., description="Établissement")
+    annee: str | None = Field(None, description="Année d'obtention")
+    coherence_parcours: str = Field(
+        ..., description="Cohérence avec le parcours professionnel"
+    )
+
+
+class SkillsEducationOutput(BaseModel):
+    competences: list[CompetenceEntry] = Field(default_factory=list)
+    formations: list[FormationEntry] = Field(default_factory=list)
+    score_competences: float = Field(..., ge=0, le=10)
+    score_formations: float = Field(..., ge=0, le=10)
+    competences_non_demontrees: list[str] = Field(default_factory=list)
+    coherence_formation_parcours: str = Field(...)
+    points_forts: list[str] = Field(default_factory=list)
+    points_faibles: list[str] = Field(default_factory=list)
+    donnees_manquantes: list[str] = Field(default_factory=list)
+
+
+# ─────────────────────────────────────────────
+# SummaryValidationAgent models
+# ─────────────────────────────────────────────
+
+
+class AffirmationCheck(BaseModel):
+    affirmation: str = Field(..., description="Affirmation extraite du résumé")
+    prouvee: bool = Field(
+        ..., description="Si l'affirmation est prouvée par les expériences"
+    )
+    preuve: str | None = Field(None, description="Preuve trouvée dans les expériences")
+    commentaire: str = Field(..., description="Commentaire sur la validation")
+
+
+class SummaryValidationOutput(BaseModel):
+    affirmations_analysees: list[AffirmationCheck] = Field(default_factory=list)
+    score_resume: float = Field(..., ge=0, le=10)
+    taux_affirmations_prouvees: float = Field(
+        ..., ge=0, le=100, description="Pourcentage d'affirmations prouvées"
+    )
+    ecarts_alignement: list[str] = Field(
+        default_factory=list, description="Écarts entre positionnement et réalité"
+    )
+    positionnement_declare: str = Field(
+        ..., description="Positionnement déclaré dans le résumé"
+    )
+    positionnement_reel: str = Field(
+        ..., description="Positionnement réel basé sur les expériences"
+    )
+    synthese: str = Field(...)
+    donnees_manquantes: list[str] = Field(default_factory=list)
+
+
+# ─────────────────────────────────────────────
+# ScoringAgent models
+# ─────────────────────────────────────────────
+
+
+class ScoreDetail(BaseModel):
+    critere: str = Field(...)
+    score_brut: float = Field(..., ge=0, le=10)
+    poids: float = Field(..., ge=0, le=1)
+    score_pondere: float = Field(..., ge=0, le=10)
+    justification: str = Field(...)
+
+
+class ScoringOutput(BaseModel):
+    details: list[ScoreDetail] = Field(...)
+    note_finale_sur_10: float = Field(..., ge=0, le=10)
+    note_finale_sur_20: float = Field(..., ge=0, le=20)
+    note_finale_sur_100: float = Field(..., ge=0, le=100)
+    calcul_intermediaire: str = Field(..., description="Détail du calcul mathématique")
+    validation_mathematique: bool = Field(
+        ..., description="True si le calcul est cohérent"
+    )
+    erreur_calcul: str | None = Field(
+        None, description="Description de l'erreur si incohérence"
+    )
+
+
+# ─────────────────────────────────────────────
+# QualityControlAgent models
+# ─────────────────────────────────────────────
+
+
+class QualityCheckItem(BaseModel):
+    element: str = Field(...)
+    present: bool = Field(...)
+    qualite: Literal["excellent", "bon", "moyen", "faible", "absent"] = Field(...)
+    commentaire: str = Field(...)
+
+
+class QualityControlOutput(BaseModel):
+    elements_verifies: list[QualityCheckItem] = Field(default_factory=list)
+    alignement_global: str = Field(
+        ..., description="Évaluation de l'alignement compétences ↔ expériences ↔ résumé"
+    )
+    score_alignement: float = Field(..., ge=0, le=10)
+    verdict: Literal["profil_vendeur", "profil_banal", "profil_intermediaire"] = Field(
+        ...
+    )
+    justification_verdict: str = Field(...)
+    recommandation: Literal["Oui", "Non", "Peut-être"] = Field(...)
+    justification_recommandation: str = Field(...)
+    forces: list[str] = Field(default_factory=list)
+    faiblesses: list[str] = Field(default_factory=list)
+
+
+# ─────────────────────────────────────────────
+# TableGeneratorAgent models
+# ─────────────────────────────────────────────
+
+
+class TableCell(BaseModel):
+    emoji: Literal["✅", "⚠️", "❌"] = Field(...)
+    justification: str = Field(..., max_length=200)
+
+
+class TableRow(BaseModel):
+    element: str = Field(
+        ..., description="Nom de l'élément évalué (expérience, compétences, etc.)"
+    )
+    clarte: TableCell = Field(...)
+    coherence: TableCell = Field(...)
+    qualite_redactionnelle: TableCell = Field(...)
+    pertinence: TableCell = Field(...)
+    respect_regles: TableCell = Field(...)
+    erreurs_naives: TableCell = Field(...)
+
+
+class TableGeneratorOutput(BaseModel):
+    lignes: list[TableRow] = Field(default_factory=list)
+    resume_tableau: str = Field(..., description="Résumé textuel du tableau")
+
+
+# ─────────────────────────────────────────────
+# Final Report model
+# ─────────────────────────────────────────────
+
+
+class FinalReport(BaseModel):
+    experience_analysis: ExperienceAnalysisOutput = Field(...)
+    skills_education: SkillsEducationOutput = Field(...)
+    summary_validation: SummaryValidationOutput = Field(...)
+    scoring: ScoringOutput = Field(...)
+    quality_control: QualityControlOutput = Field(...)
+    evaluation_table: TableGeneratorOutput = Field(...)
+    metadata: dict = Field(
+        default_factory=dict, description="Métadonnées (date, modèle, version...)"
+    )

orchestrator.py

@@ -0,0 +1,227 @@
+"""
+Orchestrator - Multi-agent pipeline for CV evaluation.
+Manages the execution flow, caching, and parallel processing where possible.
+
+Architecture:
+    Phase 1 (independent):   ExperienceAnalysisAgent
+    Phase 2 (depends on 1):  SkillsEducationAgent + SummaryValidationAgent  (parallel)
+    Phase 3 (depends on 1+2): ScoringAgent
+    Phase 4 (depends on all): QualityControlAgent + TableGeneratorAgent  (parallel)
+"""
+
+import logging
+import time
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timezone
+
+from agents import (
+    ExperienceAnalysisAgent,
+    QualityControlAgent,
+    ScoringAgent,
+    SkillsEducationAgent,
+    SummaryValidationAgent,
+    TableGeneratorAgent,
+)
+from models.schemas import (
+    FinalReport,
+    QualityControlOutput,
+    SkillsEducationOutput,
+    SummaryValidationOutput,
+    TableGeneratorOutput,
+)
+from utils.cache import ResultCache
+from utils.chunking import chunk_cv_by_sections, get_section_or_full
+
+logger = logging.getLogger(__name__)
+
+
+# Models that belong to OpenAI — everything else is treated as Gemini
+GEMINI_MODEL_PREFIXES = ("gemini-2.5-flash-lite", "gemini-2.5-flash", "gemini-2.5-pro")
+# Ollama Cloud models — identified by "-cloud" suffix
+OLLAMA_MODEL_SUFFIXES = ("-cloud",)
+
+
+def detect_provider(model_name: str) -> str:
+    """Infer the provider from the model name."""
+    model_lower = model_name.lower()
+    if any(model_lower.startswith(p) for p in GEMINI_MODEL_PREFIXES):
+        return "gemini"
+    if any(model_lower.endswith(s) for s in OLLAMA_MODEL_SUFFIXES):
+        return "ollama"
+    return "openai"
+
+
+class CVEvaluationOrchestrator:
+    """Orchestrates the multi-agent CV evaluation pipeline."""
+
+    def __init__(
+        self,
+        api_key: str,
+        model_name: str = "gemini-1.5-flash",
+        cache_dir: str | None = None,
+        progress_callback: Callable[[str, float], None] | None = None,
+    ):
+        self.api_key = api_key
+        self.model_name = model_name
+        self.provider = detect_provider(model_name)
+        self.cache = ResultCache(cache_dir=cache_dir)
+        self.progress_callback = progress_callback or (lambda msg, pct: None)
+
+        logger.info(
+            f"[Orchestrator] Provider detected: '{self.provider}' for model '{model_name}'"
+        )
+
+        # ✅ provider is now passed to every agent
+        agent_kwargs = {
+            "api_key": api_key,
+            "model_name": model_name,
+            "provider": self.provider,
+        }
+        self.experience_agent = ExperienceAnalysisAgent(**agent_kwargs)
+        self.skills_education_agent = SkillsEducationAgent(**agent_kwargs)
+        self.summary_validation_agent = SummaryValidationAgent(**agent_kwargs)
+        self.scoring_agent = ScoringAgent(**agent_kwargs)
+        self.quality_control_agent = QualityControlAgent(**agent_kwargs)
+        self.table_generator_agent = TableGeneratorAgent(**agent_kwargs)
+
+    def _update_progress(self, message: str, percentage: float):
+        """Send progress update."""
+        self.progress_callback(message, percentage)
+        logger.info(f"[Orchestrator] {percentage:.0%} - {message}")
+
+    def evaluate(self, cv_text: str) -> FinalReport:
+        """
+        Run the complete CV evaluation pipeline.
+
+        Args:
+            cv_text: Full text extracted from the CV PDF.
+
+        Returns:
+            FinalReport: Complete evaluation report.
+        """
+        start_time = time.time()
+        self._update_progress("📄 Découpage sémantique du CV...", 0.05)
+
+        # ── Phase 0: Semantic chunking ──
+        sections = chunk_cv_by_sections(cv_text)
+        cv_experiences = get_section_or_full(sections, "experiences")
+        cv_competences = get_section_or_full(sections, "competences")
+        cv_formations = get_section_or_full(sections, "formations")
+        cv_resume = get_section_or_full(sections, "resume")
+        cv_full = get_section_or_full(sections, "full_text")
+
+        logger.info(
+            f"[Orchestrator] Sections detected: {[k for k in sections.keys() if k != 'full_text']}"
+        )
+
+        # ── Phase 1: Experience Analysis (independent) ──
+        self._update_progress("🔍 Agent 1/6 : Analyse des expériences...", 0.10)
+        experience_result = self.experience_agent.run(
+            cv_experiences=cv_experiences,
+            cv_full_text=cv_full,
+        )
+        self.cache.set("experience", cv_text, experience_result.model_dump())
+
+        # ── Phase 2: Skills/Education + Summary Validation (parallel, depend on Phase 1) ──
+        self._update_progress(
+            "🎯 Agents 2-3/6 : Compétences, formations et validation du résumé (parallèle)...",
+            0.30,
+        )
+
+        skills_result: SkillsEducationOutput | None = None
+        summary_result: SummaryValidationOutput | None = None
+
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            future_skills = executor.submit(
+                self.skills_education_agent.run,
+                cv_competences=cv_competences,
+                cv_formations=cv_formations,
+                experience_analysis=experience_result,
+            )
+            future_summary = executor.submit(
+                self.summary_validation_agent.run,
+                cv_resume=cv_resume,
+                experience_analysis=experience_result,
+            )
+
+            for future in as_completed([future_skills, future_summary]):
+                if future == future_skills:
+                    skills_result = future.result()
+                    self.cache.set("skills", cv_text, skills_result.model_dump())
+                    self._update_progress("✅ Compétences & formations analysées", 0.45)
+                else:
+                    summary_result = future.result()
+                    self.cache.set("summary", cv_text, summary_result.model_dump())
+                    self._update_progress("✅ Résumé validé", 0.50)
+
+        # ── Phase 3: Scoring (depends on Phase 1 + 2) ──
+        self._update_progress("📊 Agent 4/6 : Calcul des scores...", 0.60)
+        scoring_result = self.scoring_agent.run(
+            score_experiences=experience_result.score_global_experiences,
+            score_competences=skills_result.score_competences,
+            score_formations=skills_result.score_formations,
+            score_resume=summary_result.score_resume,
+        )
+        self.cache.set("scoring", cv_text, scoring_result.model_dump())
+
+        # ── Phase 4: Quality Control + Table Generation (parallel, depend on all previous) ──
+        self._update_progress(
+            "🏁 Agents 5-6/6 : Contrôle qualité et tableau d'évaluation (parallèle)...",
+            0.75,
+        )
+
+        quality_result: QualityControlOutput | None = None
+        table_result: TableGeneratorOutput | None = None
+
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            future_quality = executor.submit(
+                self.quality_control_agent.run,
+                experience_analysis=experience_result,
+                skills_education=skills_result,
+                summary_validation=summary_result,
+                scoring=scoring_result,
+            )
+            future_table = executor.submit(
+                self.table_generator_agent.run,
+                experience_analysis=experience_result,
+                skills_education=skills_result,
+                summary_validation=summary_result,
+            )
+
+            for future in as_completed([future_quality, future_table]):
+                if future == future_quality:
+                    quality_result = future.result()
+                    self.cache.set("quality", cv_text, quality_result.model_dump())
+                    self._update_progress("✅ Contrôle qualité terminé", 0.88)
+                else:
+                    table_result = future.result()
+                    self.cache.set("table", cv_text, table_result.model_dump())
+                    self._update_progress("✅ Tableau d'évaluation généré", 0.92)
+
+        # ── Phase 5: Assemble final report ──
+        self._update_progress("📋 Assemblage du rapport final...", 0.95)
+
+        elapsed = round(time.time() - start_time, 2)
+
+        report = FinalReport(
+            experience_analysis=experience_result,
+            skills_education=skills_result,
+            summary_validation=summary_result,
+            scoring=scoring_result,
+            quality_control=quality_result,
+            evaluation_table=table_result,
+            metadata={
+                "date_evaluation": datetime.now(timezone.utc).isoformat(),
+                "modele_llm": self.model_name,
+                "temperature": 0,
+                "duree_evaluation_secondes": elapsed,
+                "version": "1.0.0",
+                "sections_detectees": [k for k in sections.keys() if k != "full_text"],
+            },
+        )
+
+        self._update_progress("✅ Évaluation terminée !", 1.0)
+        logger.info(f"[Orchestrator] Evaluation complete in {elapsed}s")
+
+        return report

prompts/__init__.py

@@ -0,0 +1 @@
+from prompts.templates import *

prompts/templates.py

@@ -0,0 +1,307 @@
+"""
+Prompt templates for all 6 agents.
+Each prompt enforces JSON output, low temperature reasoning, and strict evaluation criteria.
+"""
+
+EXPERIENCE_ANALYSIS_PROMPT = """Tu es un expert senior en recrutement et analyse de CV.
+Tu dois analyser la section EXPÉRIENCES du CV fourni avec une rigueur absolue.
+
+## INSTRUCTIONS STRICTES
+1. Extrais CHAQUE expérience professionnelle listée
+2. Pour chaque expérience, évalue :
+   - Le contexte métier (secteur, enjeux, taille d'équipe/projet)
+   - Les missions différenciantes (ce qui distingue le candidat)
+   - Les résultats mesurables (chiffres, KPI, impacts concrets)
+   - La cohérence technique (stack, outils, méthodologies mentionnés)
+   - Les erreurs naïves : mention de concurrents sans contexte, formulations faibles/vagues,
+     absence de contexte métier, buzzwords sans substance
+3. Ne JAMAIS inventer de données absentes. Signale explicitement ce qui manque.
+4. Score chaque expérience de 0 à 10 avec justification.
+5. Calcule un score global des expériences (moyenne pondérée par pertinence).
+
+## CONTENU DU CV - SECTION EXPÉRIENCES
+{cv_experiences}
+
+## CONTENU COMPLET DU CV (pour contexte)
+{cv_full_text}
+
+## FORMAT DE SORTIE OBLIGATOIRE (JSON strict)
+Tu DOIS répondre UNIQUEMENT avec un objet JSON valide respectant exactement ce schéma :
+{{
+  "experiences": [
+    {{
+      "poste": "string",
+      "entreprise": "string",
+      "periode": "string",
+      "duree_estimee": "string ou null",
+      "contexte_metier": "string",
+      "missions": ["string"],
+      "missions_differenciantes": ["string"],
+      "resultats_mesurables": ["string"],
+      "coherence_technique": "string",
+      "erreurs_naives": ["string"],
+      "score": 0.0,
+      "justification_score": "string"
+    }}
+  ],
+  "score_global_experiences": 0.0,
+  "synthese": "string",
+  "points_forts": ["string"],
+  "points_faibles": ["string"],
+  "donnees_manquantes": ["string"]
+}}
+
+Réponds UNIQUEMENT avec le JSON, sans texte avant ni après."""
+
+
+SKILLS_EDUCATION_PROMPT = """Tu es un expert en évaluation des compétences et formations professionnelles.
+Tu dois analyser les sections COMPÉTENCES et FORMATIONS du CV avec une rigueur absolue.
+
+## INSTRUCTIONS STRICTES
+1. Extrais CHAQUE compétence mentionnée et catégorise-la (technique, soft skill, métier, outil)
+2. Vérifie si chaque compétence est DÉMONTRÉE dans une expérience concrète
+3. Identifie les compétences listées mais non prouvées par l'expérience
+4. Pour les formations, vérifie la cohérence avec le parcours professionnel
+5. Évalue la clarté et la structuration de la section compétences
+6. Ne JAMAIS inventer de données absentes.
+
+## CONTENU DU CV - SECTION COMPÉTENCES
+{cv_competences}
+
+## CONTENU DU CV - SECTION FORMATIONS
+{cv_formations}
+
+## RÉSULTATS DE L'ANALYSE DES EXPÉRIENCES (pour cross-check)
+{experience_analysis}
+
+## FORMAT DE SORTIE OBLIGATOIRE (JSON strict)
+Tu DOIS répondre UNIQUEMENT avec un objet JSON valide :
+{{
+  "competences": [
+    {{
+      "nom": "string",
+      "categorie": "string",
+      "demontree_dans_experience": true,
+      "experience_associee": "string ou null",
+      "niveau_estime": "string ou null"
+    }}
+  ],
+  "formations": [
+    {{
+      "diplome": "string",
+      "etablissement": "string",
+      "annee": "string ou null",
+      "coherence_parcours": "string"
+    }}
+  ],
+  "score_competences": 0.0,
+  "score_formations": 0.0,
+  "competences_non_demontrees": ["string"],
+  "coherence_formation_parcours": "string",
+  "points_forts": ["string"],
+  "points_faibles": ["string"],
+  "donnees_manquantes": ["string"]
+}}
+
+Réponds UNIQUEMENT avec le JSON, sans texte avant ni après."""
+
+
+SUMMARY_VALIDATION_PROMPT = """Tu es un analyste spécialisé dans la vérification des affirmations de CV.
+Tu dois valider le résumé/profil du CV en le confrontant aux expériences réelles.
+
+## INSTRUCTIONS STRICTES
+1. Extrais CHAQUE affirmation du résumé/profil du candidat
+2. Pour chaque affirmation, cherche une PREUVE concrète dans les expériences analysées
+3. Distingue clairement :
+   - Affirmations PROUVÉES (avec preuve concrète)
+   - Affirmations NON PROUVÉES (déclaratives sans preuve)
+4. Identifie les écarts entre le positionnement déclaré et la réalité des missions
+5. Calcule le taux d'affirmations prouvées
+6. Ne JAMAIS inventer de preuves absentes.
+
+## CONTENU DU CV - SECTION RÉSUMÉ/PROFIL
+{cv_resume}
+
+## RÉSULTATS DE L'ANALYSE DES EXPÉRIENCES
+{experience_analysis}
+
+## FORMAT DE SORTIE OBLIGATOIRE (JSON strict)
+Tu DOIS répondre UNIQUEMENT avec un objet JSON valide :
+{{
+  "affirmations_analysees": [
+    {{
+      "affirmation": "string",
+      "prouvee": true,
+      "preuve": "string ou null",
+      "commentaire": "string"
+    }}
+  ],
+  "score_resume": 0.0,
+  "taux_affirmations_prouvees": 0.0,
+  "ecarts_alignement": ["string"],
+  "positionnement_declare": "string",
+  "positionnement_reel": "string",
+  "synthese": "string",
+  "donnees_manquantes": ["string"]
+}}
+
+Réponds UNIQUEMENT avec le JSON, sans texte avant ni après."""
+
+
+SCORING_PROMPT = """Tu es un calculateur de scores de CV rigoureux et mathématiquement exact.
+Tu dois calculer le score final du CV selon une formule pondérée STRICTE.
+
+## FORMULE OBLIGATOIRE
+Note /10 = (Expériences × 0.5) + (Compétences × 0.2) + (Formations × 0.1) + (Résumé × 0.2)
+
+## SCORES D'ENTRÉE (fournis par les agents précédents)
+- Score Expériences : {score_experiences}/10
+- Score Compétences : {score_competences}/10
+- Score Formations : {score_formations}/10
+- Score Résumé : {score_resume}/10
+
+## INSTRUCTIONS STRICTES
+1. Applique EXACTEMENT la formule ci-dessus
+2. Affiche CHAQUE calcul intermédiaire
+3. Vérifie mathématiquement la cohérence (la somme des poids = 1.0)
+4. Convertis en /20 et /100
+5. Si une incohérence est détectée, signale-la comme erreur
+
+## FORMAT DE SORTIE OBLIGATOIRE (JSON strict)
+Tu DOIS répondre UNIQUEMENT avec un objet JSON valide :
+{{
+  "details": [
+    {{
+      "critere": "Expériences",
+      "score_brut": 0.0,
+      "poids": 0.5,
+      "score_pondere": 0.0,
+      "justification": "string"
+    }},
+    {{
+      "critere": "Compétences",
+      "score_brut": 0.0,
+      "poids": 0.2,
+      "score_pondere": 0.0,
+      "justification": "string"
+    }},
+    {{
+      "critere": "Formations",
+      "score_brut": 0.0,
+      "poids": 0.1,
+      "score_pondere": 0.0,
+      "justification": "string"
+    }},
+    {{
+      "critere": "Résumé",
+      "score_brut": 0.0,
+      "poids": 0.2,
+      "score_pondere": 0.0,
+      "justification": "string"
+    }}
+  ],
+  "note_finale_sur_10": 0.0,
+  "note_finale_sur_20": 0.0,
+  "note_finale_sur_100": 0.0,
+  "calcul_intermediaire": "string montrant le calcul complet",
+  "validation_mathematique": true,
+  "erreur_calcul": null
+}}
+
+Réponds UNIQUEMENT avec le JSON, sans texte avant ni après."""
+
+
+QUALITY_CONTROL_PROMPT = """Tu es un contrôleur qualité senior spécialisé dans l'évaluation finale de CV.
+Tu dois rendre un verdict global sur la qualité du CV et le profil du candidat.
+
+## INSTRUCTIONS STRICTES
+1. Vérifie la présence des éléments clés :
+   - Enjeux métier clairement exprimés
+   - Livrables différenciants identifiés
+   - Résultats concrets et mesurables
+   - Cohérence du parcours
+2. Évalue l'alignement global : compétences ↔ expériences ↔ résumé
+3. Rends un verdict : "profil_vendeur" (CV bien construit, convaincant) vs "profil_banal" (générique)
+   ou "profil_intermediaire"
+4. Émets une recommandation : "Oui", "Non" ou "Peut-être" avec justification
+5. Liste les forces et faiblesses principales
+
+## DONNÉES D'ENTRÉE
+### Analyse des expériences
+{experience_analysis}
+
+### Analyse compétences/formations
+{skills_education}
+
+### Validation du résumé
+{summary_validation}
+
+### Scores
+{scoring}
+
+## FORMAT DE SORTIE OBLIGATOIRE (JSON strict)
+Tu DOIS répondre UNIQUEMENT avec un objet JSON valide :
+{{
+  "elements_verifies": [
+    {{
+      "element": "string",
+      "present": true,
+      "qualite": "excellent|bon|moyen|faible|absent",
+      "commentaire": "string"
+    }}
+  ],
+  "alignement_global": "string",
+  "score_alignement": 0.0,
+  "verdict": "profil_vendeur|profil_banal|profil_intermediaire",
+  "justification_verdict": "string",
+  "recommandation": "Oui|Non|Peut-être",
+  "justification_recommandation": "string",
+  "forces": ["string"],
+  "faiblesses": ["string"]
+}}
+
+Réponds UNIQUEMENT avec le JSON, sans texte avant ni après."""
+
+
+TABLE_GENERATOR_PROMPT = """Tu es un générateur de tableaux d'évaluation de CV.
+Tu dois produire un tableau structuré évaluant chaque section du CV.
+
+## INSTRUCTIONS STRICTES
+1. Crée une ligne pour CHAQUE expérience individuellement
+2. Crée une ligne pour "Compétences" (global)
+3. Crée une ligne pour "Formations" (global)
+4. Crée une ligne pour "Résumé/Profil" (global)
+5. Chaque cellule contient un emoji + justification courte :
+   - ✅ = Bon/Conforme
+   - ⚠️ = Acceptable avec réserves
+   - ❌ = Insuffisant/Problématique
+6. Les colonnes sont : Clarté, Cohérence, Qualité rédactionnelle, Pertinence, Respect des règles, Erreurs naïves
+
+## DONNÉES D'ENTRÉE
+### Analyse des expériences
+{experience_analysis}
+
+### Analyse compétences/formations
+{skills_education}
+
+### Validation du résumé
+{summary_validation}
+
+## FORMAT DE SORTIE OBLIGATOIRE (JSON strict)
+Tu DOIS répondre UNIQUEMENT avec un objet JSON valide :
+{{
+  "lignes": [
+    {{
+      "element": "string (nom de l'expérience ou section)",
+      "clarte": {{"emoji": "✅|⚠️|❌", "justification": "string (max 200 chars)"}},
+      "coherence": {{"emoji": "✅|⚠️|❌", "justification": "string"}},
+      "qualite_redactionnelle": {{"emoji": "✅|⚠️|❌", "justification": "string"}},
+      "pertinence": {{"emoji": "✅|⚠️|❌", "justification": "string"}},
+      "respect_regles": {{"emoji": "✅|⚠️|❌", "justification": "string"}},
+      "erreurs_naives": {{"emoji": "✅|⚠️|❌", "justification": "string"}}
+    }}
+  ],
+  "resume_tableau": "string résumant les observations du tableau"
+}}
+
+Réponds UNIQUEMENT avec le JSON, sans texte avant ni après."""

pyproject.toml

@@ -0,0 +1,59 @@
+# pyproject.toml
+# Configuration centralisée pour les outils Python
+
+[project]
+name = "cv_evaluator"
+version = "0.1.0"
+description = "Système Multi-Agents d'Évaluation de CV"
+requires-python = ">=3.10"
+dependencies = [
+    # Tes dépendances seront listées ici
+    # (on les gardera aussi dans requirements.txt pour compatibilité)
+]
+
+[tool.ruff]
+# Configuration du linter/formatteur
+target-version = "py310"
+line-length = 88
+
+# Règles activées
+select = [
+    "E",    # pycodestyle (erreurs)
+    "W",    # pycodestyle (warnings)
+    "F",    # pyflakes
+    "I",    # isort (imports)
+    "N",    # pep8-naming
+    "UP",   # pyupgrade
+    "B",    # flake8-bugbear
+    "SIM",  # flake8-simplify
+]
+
+# Règles ignorées (optionnel, ajuste selon tes besoins)
+ignore = [
+    "E501",  # ligne trop longue (parfois inévitable)
+]
+
+# Fichiers à exclure
+exclude = [
+    "venv",
+    ".git",
+    "__pycache__",
+    "*.pyc",
+]
+
+[tool.ruff.format]
+# Configuration du formatage (style black)
+quote-style = "double"
+indent-style = "space"
+
+[tool.pytest.ini_options]
+# Configuration des tests
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = "-v --tb=short"
+
+[tool.bandit]
+# Configuration de la sécurité
+exclude_dirs = ["venv", "tests"]
+skips = ["B101"]  # B101 = assert utilisé (ok dans les tests)

requirements-dev.txt

@@ -0,0 +1,16 @@
+# requirements-dev.txt
+# Dépendances uniquement pour le développement et le CI/CD
+
+# Linting et formatage
+ruff>=0.4.0
+
+# Tests
+pytest>=8.0.0
+pytest-cov>=5.0.0
+
+# Sécurité
+bandit>=1.7.0
+safety>=3.0.0
+
+# Typing (optionnel mais recommandé)
+mypy>=1.10.0

requirements.txt

@@ -1,3 +1,11 @@
-altair
-pandas
-streamlit
+streamlit>=1.30.0
+plotly>=6.6.0
+langchain>=0.1.0
+langchain-google-genai>=1.0.0
+langchain-openai>=1.1.12
+langchain-core>=0.1.0
+google-generativeai>=0.4.0
+pydantic>=2.5.0
+pymupdf>=1.23.0
+tenacity>=9.1.4
+python-dotenv>=1.0.0

tests/test_basic.py

@@ -0,0 +1,39 @@
+# tests/test_basic.py
+# Tests ultra-simples pour vérifier que le CI fonctionne
+
+
+def test_python_works():
+    """Vérifie que Python fonctionne."""
+    assert 1 + 1 == 2
+
+
+def test_string_operations():
+    """Vérifie les opérations sur les chaînes."""
+    text = "CV Evaluator"
+    assert "CV" in text
+    assert text.lower() == "cv evaluator"
+
+
+def test_list_operations():
+    """Vérifie les opérations sur les listes."""
+    items = [1, 2, 3]
+    assert len(items) == 3
+    assert 2 in items
+
+
+def test_dictionary_operations():
+    """Vérifie les opérations sur les dictionnaires."""
+    data = {"score": 85, "max": 100}
+    assert data["score"] == 85
+    assert "max" in data
+
+
+def test_import_standard_library():
+    """Vérifie que les bibliothèques standard sont disponibles."""
+    import json
+    import os
+    import sys
+
+    assert json is not None
+    assert os is not None
+    assert sys is not None

utils/__init__.py

@@ -0,0 +1,7 @@
+from utils.cache import ResultCache
+from utils.chunking import chunk_cv_by_sections, get_section_or_full
+from utils.pdf_parser import (
+    extract_text_from_pdf,
+    extract_text_from_uploaded_file,
+    get_page_count,
+)

utils/cache.py

@@ -0,0 +1,85 @@
+"""
+Caching utility for intermediate agent results.
+Avoids redundant API calls during the evaluation pipeline.
+"""
+
+import hashlib
+import json
+import os
+import time
+from typing import Any
+
+
+class ResultCache:
+    """In-memory + optional file-based cache for agent results."""
+
+    def __init__(self, cache_dir: str | None = None):
+        self._memory: dict[str, Any] = {}
+        self._timestamps: dict[str, float] = {}
+        self.cache_dir = cache_dir
+        if cache_dir:
+            os.makedirs(cache_dir, exist_ok=True)
+
+    def _make_key(self, agent_name: str, input_hash: str) -> str:
+        return f"{agent_name}_{input_hash}"
+
+    def _hash_input(self, input_data: str) -> str:
+        return hashlib.sha256(input_data.encode("utf-8")).hexdigest()[:16]
+
+    def get(self, agent_name: str, input_data: str) -> Any | None:
+        """Retrieve cached result for an agent given input data."""
+        key = self._make_key(agent_name, self._hash_input(input_data))
+
+        # Check memory first
+        if key in self._memory:
+            return self._memory[key]
+
+        # Check file cache
+        if self.cache_dir:
+            filepath = os.path.join(self.cache_dir, f"{key}.json")
+            if os.path.exists(filepath):
+                try:
+                    with open(filepath, encoding="utf-8") as f:
+                        data = json.load(f)
+                    self._memory[key] = data
+                    return data
+                except (OSError, json.JSONDecodeError):
+                    pass
+
+        return None
+
+    def set(self, agent_name: str, input_data: str, result: Any) -> None:
+        """Cache result for an agent."""
+        key = self._make_key(agent_name, self._hash_input(input_data))
+        self._memory[key] = result
+        self._timestamps[key] = time.time()
+
+        # Write to file cache
+        if self.cache_dir:
+            filepath = os.path.join(self.cache_dir, f"{key}.json")
+            try:
+                with open(filepath, "w", encoding="utf-8") as f:
+                    if isinstance(result, str):
+                        json.dump({"raw": result}, f, ensure_ascii=False, indent=2)
+                    else:
+                        json.dump(result, f, ensure_ascii=False, indent=2)
+            except (OSError, TypeError):
+                pass
+
+    def clear(self) -> None:
+        """Clear all cached data."""
+        self._memory.clear()
+        self._timestamps.clear()
+        if self.cache_dir:
+            for f in os.listdir(self.cache_dir):
+                if f.endswith(".json"):
+                    os.remove(os.path.join(self.cache_dir, f))
+
+    def get_stats(self) -> dict[str, Any]:
+        """Return cache statistics."""
+        return {
+            "entries": len(self._memory),
+            "agents_cached": list(
+                set(k.rsplit("_", 1)[0] for k in self._memory.keys())
+            ),
+        }

utils/chunking.py

@@ -0,0 +1,485 @@
+"""
+Découpage dynamique intelligent pour le contenu des CV.
+
+Stratégie : découpage hybride par section + prise en compte des tokens
+───────────────────────────────────────────────────────────────────────
+1. DÉTECTION DES SECTIONS    → expressions régulières (FR + EN) pour localiser
+                               les limites sémantiques
+2. ESTIMATION DES TOKENS     → heuristique ~4 caractères/token, sans librairie externe
+3. DÉCOUPAGE ADAPTATIF       → les sections qui dépassent le budget de tokens sont
+                               sous-découpées par paragraphe / bloc de dates afin
+                               que le LLM ne reçoive jamais un mur de texte tronqué
+                               en pleine phrase
+4. INJECTION DE CONTEXTE     → chaque fragment de dépassement reçoit un « en‑tête »
+                               léger résumant ce qui précède (continuité sémantique)
+5. SOLUTION DE SECOURS       → si aucune section n’est trouvée, le texte complet
+                               est divisé en fenêtres avec chevauchement paramétrable
+
+Budget de tokens par défaut
+───────────────────────────
+  MAX_TOKENS_PER_CHUNK  = 3 000   (sûr pour les modèles avec contexte 4k)
+  OVERLAP_TOKENS        =   200   (préservation du contexte entre fragments)
+  CHARS_PER_TOKEN       =     4   (heuristique conservative pour le français/anglais)
+
+API rétrocompatible
+───────────────────
+  chunk_cv_by_sections()  → interface dict héritée (utilisée par l’orchestrateur actuel)
+  get_section_or_full()   → fonction utilitaire héritée (utilisée par l’orchestrateur actuel)
+
+Nouvelle API
+────────────
+  chunk_cv()                    → renvoie un dataclass CVSections
+  get_best_chunks_for_agent()   → chaîne de caractères adaptée au budget de tokens
+                                  pour l’agent
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass, field
+
+logger = logging.getLogger(__name__)
+
+# ── Tunable constants ────────────────────────────────────────────────────────
+MAX_TOKENS_PER_CHUNK: int = 3_000
+OVERLAP_TOKENS: int = 200
+CHARS_PER_TOKEN: float = 4.0
+MAX_CHARS: int = int(MAX_TOKENS_PER_CHUNK * CHARS_PER_TOKEN)
+OVERLAP_CHARS: int = int(OVERLAP_TOKENS * CHARS_PER_TOKEN)
+
+# ── Section vocabulary (FR + EN) ─────────────────────────────────────────────
+SECTION_PATTERNS: dict[str, list[str]] = {
+    "resume": [
+        r"(?i)(profil\s*pro|profil\s*candidat|résumé\s*pro|summary|about\s*me"
+        r"|à\s*propos|objectif(\s*(pro|career))?|présentation|introduction"
+        r"|accroche|profil$|executive\s*summary)",
+    ],
+    "experiences": [
+        r"(?i)(expérience[s]?\s*(professionnelle[s]?)?|professional\s*experience"
+        r"|work\s*experience|employment|parcours\s*professionnel"
+        r"|postes?\s*occupés?|carrière|career\s*history)",
+    ],
+    "competences": [
+        r"(?i)(compétence[s]?|skills?|savoir[s]?\s*faire|technical\s*skills?"
+        r"|compétences?\s*techniques?|hard\s*skills?|soft\s*skills?"
+        r"|outils?|technologies?|stack\s*technique|expertise)",
+    ],
+    "formations": [
+        r"(?i)(formation[s]?|education|diplôme[s]?|cursus|études"
+        r"|certifications?|parcours\s*académique|academic|qualifications?)",
+    ],
+    "langues": [
+        r"(?i)(langue[s]?|languages?|linguistic)",
+    ],
+    "centres_interet": [
+        r"(?i)(centre[s]?\s*d'intérêt|hobbies?|loisirs?|interests?"
+        r"|activités?\s*extra|passions?)",
+    ],
+    "projets": [
+        r"(?i)(projet[s]?|projects?|réalisations?|portfolio|open.?source)",
+    ],
+    "references": [
+        r"(?i)(référence[s]?|references?|recommendations?)",
+    ],
+    "publications": [
+        r"(?i)(publications?|articles?|recherche[s]?|research|papers?)",
+    ],
+}
+
+REQUIRED_SECTIONS = {"resume", "experiences", "competences", "formations"}
+
+
+# ── Core data structures ──────────────────────────────────────────────────────
+
+
+@dataclass
+class Chunk:
+    """A single text chunk with metadata."""
+
+    section: str
+    index: int
+    total_chunks: int
+    text: str
+    token_estimate: int
+    preceding_context: str = ""
+    is_overflow: bool = False
+
+    @property
+    def full_text(self) -> str:
+        if self.preceding_context:
+            return (
+                f"[CONTEXTE PRÉCÉDENT]\n{self.preceding_context}"
+                f"\n\n[CONTENU PRINCIPAL]\n{self.text}"
+            )
+        return self.text
+
+    def __repr__(self) -> str:
+        return (
+            f"Chunk(section={self.section!r}, "
+            f"idx={self.index}/{self.total_chunks - 1}, "
+            f"~{self.token_estimate} tokens, overflow={self.is_overflow})"
+        )
+
+
+@dataclass
+class CVSections:
+    """Container returned by chunk_cv()."""
+
+    chunks_by_section: dict[str, list[Chunk]] = field(default_factory=dict)
+    full_text: str = ""
+    detected_sections: list[str] = field(default_factory=list)
+
+    def get_section_text(
+        self,
+        section: str,
+        max_tokens: int = MAX_TOKENS_PER_CHUNK,
+        join_sep: str = "\n\n",
+    ) -> str:
+        chunks = self.chunks_by_section.get(section, [])
+        if not chunks or sum(c.token_estimate for c in chunks) < 20:
+            logger.warning(
+                "[CVSections] Section '%s' absent. Using full_text window.", section
+            )
+            return _window(self.full_text, max_tokens)
+        budget = max_tokens
+        parts: list[str] = []
+        for chunk in chunks:
+            if budget <= 0:
+                break
+            parts.append(chunk.full_text)
+            budget -= chunk.token_estimate
+        result = join_sep.join(parts)
+        if budget < 0:
+            result = _truncate(result, max_tokens)
+        return result
+
+    def get_first_chunk(self, section: str) -> Chunk | None:
+        chunks = self.chunks_by_section.get(section, [])
+        return chunks[0] if chunks else None
+
+    def section_token_count(self, section: str) -> int:
+        return sum(c.token_estimate for c in self.chunks_by_section.get(section, []))
+
+    def summary_report(self) -> str:
+        lines = ["=== CV Chunking Report ==="]
+        for sec, chunks in self.chunks_by_section.items():
+            total_tok = sum(c.token_estimate for c in chunks)
+            overflow_tag = (
+                " [OVERFLOW → SPLIT]" if any(c.is_overflow for c in chunks) else ""
+            )
+            lines.append(
+                f"  {sec:<20} {len(chunks)} chunk(s)  ~{total_tok} tokens{overflow_tag}"
+            )
+        return "\n".join(lines)
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+
+def chunk_cv(full_text: str) -> CVSections:
+    """
+    Main entry-point.  Returns a CVSections object.
+
+    Algorithm
+    ─────────
+    1. Detect section header lines via regex.
+    2. Slice raw text between consecutive headers.
+    3. For each raw slice:
+         a. <= MAX_CHARS  → single Chunk
+         b.  > MAX_CHARS  → adaptive split (experience blocks, paragraphs,
+                             hard character split as last resort)
+    4. Ensure all REQUIRED_SECTIONS exist with a full_text fallback.
+    """
+    result = CVSections(full_text=full_text)
+    lines = full_text.splitlines()
+
+    boundaries = _detect_boundaries(lines)
+    logger.info("[Chunking] Detected %d section boundaries.", len(boundaries))
+
+    raw_sections = _slice_sections(lines, boundaries)
+    result.detected_sections = list(raw_sections.keys())
+
+    for section_name, raw_text in raw_sections.items():
+        new_chunks = _adaptive_chunk(section_name, raw_text)
+        if section_name in result.chunks_by_section:
+            existing = result.chunks_by_section[section_name]
+            offset = len(existing)
+            for c in new_chunks:
+                c.index += offset
+            result.chunks_by_section[section_name] = existing + new_chunks
+        else:
+            result.chunks_by_section[section_name] = new_chunks
+
+    # Fix total_chunks after potential merging of duplicate sections
+    for section_name, chunks in result.chunks_by_section.items():
+        total = len(chunks)
+        for c in chunks:
+            c.total_chunks = total
+
+    # Fallback for required but absent sections
+    for sec in REQUIRED_SECTIONS:
+        if sec not in result.chunks_by_section:
+            logger.warning(
+                "[Chunking] Required section '%s' not found. Injecting fallback.", sec
+            )
+            fallback_text = (
+                f"[Section '{sec}' non détectée — contenu complet du CV]\n\n"
+                + _window(full_text, MAX_TOKENS_PER_CHUNK)
+            )
+            result.chunks_by_section[sec] = [
+                Chunk(
+                    section=sec,
+                    index=0,
+                    total_chunks=1,
+                    text=fallback_text,
+                    token_estimate=_tokens(fallback_text),
+                    is_overflow=False,
+                )
+            ]
+
+    logger.info("[Chunking]\n%s", result.summary_report())
+    return result
+
+
+def get_best_chunks_for_agent(
+    cv: CVSections,
+    primary_section: str,
+    context_sections: list[str] | None = None,
+    agent_token_budget: int = MAX_TOKENS_PER_CHUNK * 2,
+) -> str:
+    """
+    Compose optimal input string for an agent within a token budget.
+    primary_section fills the budget first; context_sections are appended
+    in order until the budget is exhausted.
+    """
+    parts: list[str] = []
+    remaining = agent_token_budget
+
+    primary_text = cv.get_section_text(primary_section, max_tokens=remaining)
+    parts.append(primary_text)
+    remaining -= _tokens(primary_text)
+
+    for ctx_sec in context_sections or []:
+        if remaining <= 100:
+            break
+        ctx_text = cv.get_section_text(
+            ctx_sec, max_tokens=min(remaining, MAX_TOKENS_PER_CHUNK)
+        )
+        parts.append(f"\n\n--- [CONTEXTE : {ctx_sec.upper()}] ---\n{ctx_text}")
+        remaining -= _tokens(ctx_text)
+
+    return "\n\n".join(parts)
+
+
+# ── Backward-compatible interfaces ────────────────────────────────────────────
+
+
+def chunk_cv_by_sections(full_text: str) -> dict[str, str]:
+    """
+    Legacy dict interface used by the current orchestrator.
+    Returns {section_name: joined_text, 'full_text': full_text}.
+    """
+    cv = chunk_cv(full_text)
+    out: dict[str, str] = {"full_text": full_text}
+    for sec, chunks in cv.chunks_by_section.items():
+        out[sec] = "\n\n".join(c.full_text for c in chunks)
+    return out
+
+
+def get_section_or_full(
+    sections: dict[str, str],
+    section_name: str,
+    max_chars: int = MAX_CHARS,
+) -> str:
+    """
+    Legacy helper used by the current orchestrator.
+    Retrieves section text, falling back to full_text, truncated to max_chars.
+    """
+    content = sections.get(section_name, "")
+    if len(content) < 100:
+        content = sections.get("full_text", "")
+    return _truncate_chars(content, max_chars)
+
+
+# ── Internal helpers ──────────────────────────────────────────────────────────
+
+
+def _tokens(text: str) -> int:
+    return max(1, int(len(text) / CHARS_PER_TOKEN))
+
+
+def _truncate(text: str, max_tokens: int) -> str:
+    return _truncate_chars(text, int(max_tokens * CHARS_PER_TOKEN))
+
+
+def _truncate_chars(text: str, max_chars: int) -> str:
+    if len(text) <= max_chars:
+        return text
+    return text[:max_chars] + "\n\n[… TRONQUÉ — dépasse la fenêtre de contexte …]"
+
+
+def _window(text: str, max_tokens: int) -> str:
+    return _truncate(text, max_tokens)
+
+
+def _detect_boundaries(lines: list[str]) -> list[tuple[int, str]]:
+    boundaries: list[tuple[int, str]] = []
+    seen_at: dict[str, int] = {}
+
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if not stripped or len(stripped) > 80:
+            continue
+        for section_name, patterns in SECTION_PATTERNS.items():
+            for pattern in patterns:
+                if re.search(pattern, stripped):
+                    last = seen_at.get(section_name, -999)
+                    if i - last > 5:
+                        boundaries.append((i, section_name))
+                        seen_at[section_name] = i
+                    break
+
+    boundaries.sort(key=lambda x: x[0])
+    return boundaries
+
+
+def _slice_sections(
+    lines: list[str],
+    boundaries: list[tuple[int, str]],
+) -> dict[str, str]:
+    raw: dict[str, str] = {}
+    n = len(boundaries)
+
+    for idx, (start_line, section_name) in enumerate(boundaries):
+        end_line = boundaries[idx + 1][0] if idx + 1 < n else len(lines)
+        content = "\n".join(lines[start_line:end_line]).strip()
+        if not content:
+            continue
+        if section_name in raw:
+            raw[section_name] += "\n\n" + content
+        else:
+            raw[section_name] = content
+
+    return raw
+
+
+def _adaptive_chunk(section_name: str, raw_text: str) -> list[Chunk]:
+    """Split raw_text into Chunks, respecting MAX_CHARS."""
+    if len(raw_text) <= MAX_CHARS:
+        return [
+            Chunk(
+                section=section_name,
+                index=0,
+                total_chunks=1,
+                text=raw_text,
+                token_estimate=_tokens(raw_text),
+                is_overflow=False,
+            )
+        ]
+
+    logger.info(
+        "[Chunking] Section '%s' (%d chars). Splitting adaptively.",
+        section_name,
+        len(raw_text),
+    )
+
+    if section_name == "experiences":
+        blocks = _split_by_experience_blocks(raw_text)
+    else:
+        blocks = _split_by_paragraphs(raw_text)
+
+    normalised = _normalise_blocks(blocks)
+
+    chunks: list[Chunk] = []
+    prev_tail = ""
+
+    for i, block in enumerate(normalised):
+        preceding = _make_context_header(prev_tail) if prev_tail else ""
+        chunks.append(
+            Chunk(
+                section=section_name,
+                index=i,
+                total_chunks=len(normalised),
+                text=block,
+                token_estimate=_tokens(block),
+                preceding_context=preceding,
+                is_overflow=True,
+            )
+        )
+        prev_tail = block[-OVERLAP_CHARS:] if len(block) > OVERLAP_CHARS else block
+
+    return chunks
+
+
+def _split_by_experience_blocks(text: str) -> list[str]:
+    """Split on lines that look like experience anchors (caps title or year)."""
+    ANCHOR = re.compile(
+        r"(?m)^(?:"
+        r"[A-ZÁÀÂÉÈÊÎÏÔÙÛÜ][^\n]{5,60}(?:[-–|@•]|chez|at)\s*\S"
+        r"|.*\b(19|20)\d{2}\b.*"
+        r")$"
+    )
+    positions = [m.start() for m in ANCHOR.finditer(text)]
+
+    if len(positions) < 2:
+        return _split_by_paragraphs(text)
+
+    blocks: list[str] = []
+    if positions[0] > 0:
+        blocks.append(text[: positions[0]].strip())
+    for i, pos in enumerate(positions):
+        end = positions[i + 1] if i + 1 < len(positions) else len(text)
+        blocks.append(text[pos:end].strip())
+
+    return [b for b in blocks if b]
+
+
+def _split_by_paragraphs(text: str) -> list[str]:
+    paragraphs = re.split(r"\n{2,}", text)
+    return [p.strip() for p in paragraphs if p.strip()]
+
+
+def _normalise_blocks(blocks: list[str]) -> list[str]:
+    """Merge tiny blocks; hard-split oversized ones."""
+    merged: list[str] = []
+    buffer = ""
+    for block in blocks:
+        if len(buffer) + len(block) + 2 <= MAX_CHARS:
+            buffer = (buffer + "\n\n" + block).strip() if buffer else block
+        else:
+            if buffer:
+                merged.append(buffer)
+            buffer = block
+    if buffer:
+        merged.append(buffer)
+
+    result: list[str] = []
+    for block in merged:
+        if len(block) <= MAX_CHARS:
+            result.append(block)
+        else:
+            result.extend(_hard_split(block))
+    return result
+
+
+def _hard_split(text: str) -> list[str]:
+    """Last-resort split on character count with newline-aware boundary."""
+    chunks: list[str] = []
+    start = 0
+    while start < len(text):
+        end = min(start + MAX_CHARS, len(text))
+        if end < len(text):
+            search_start = end - MAX_CHARS // 5
+            nl = text.rfind("\n", search_start, end)
+            if nl > search_start:
+                end = nl
+        chunks.append(text[start:end].strip())
+        start = max(start + 1, end - OVERLAP_CHARS)
+    return [c for c in chunks if c]
+
+
+def _make_context_header(prev_tail: str) -> str:
+    lines = [l.strip() for l in prev_tail.splitlines() if l.strip()]
+    summary = " | ".join(lines[-3:]) if lines else prev_tail[:120]
+    return f"(Suite — contexte fin du bloc précédent) : {summary}"

utils/pdf_parser.py

@@ -0,0 +1,80 @@
+"""
+PDF Parser utility using PyMuPDF (fitz).
+Extracts raw text from PDF files with page tracking.
+"""
+
+import fitz  # PyMuPDF
+
+
+class PDFExtractionError(Exception):
+    """Custom exception for PDF extraction errors."""
+
+    pass
+
+
+def extract_text_from_pdf(pdf_content: bytes) -> str:
+    """
+    Extract full text from a PDF file.
+
+    Raises:
+        PDFExtractionError: If the PDF is corrupted, empty, or cannot be read.
+    """
+    try:
+        doc = fitz.open(stream=pdf_content, filetype="pdf")
+    except Exception as e:
+        raise PDFExtractionError(f"Impossible d'ouvrir le PDF: {str(e)}")
+
+    if len(doc) == 0:
+        doc.close()
+        raise PDFExtractionError("Le PDF est vide (aucune page).")
+
+    full_text = []
+    for page_num in range(len(doc)):
+        try:
+            page = doc.load_page(page_num)
+            text = page.get_text("text")
+            if text.strip():
+                full_text.append(f"--- PAGE {page_num + 1} ---\n{text}")
+        except Exception as e:
+            raise PDFExtractionError(
+                f"Erreur lors de l'extraction de la page {page_num + 1}: {str(e)}"
+            )
+
+    doc.close()
+
+    if not full_text:
+        raise PDFExtractionError(
+            "Le PDF ne contient aucun texte extractible (scanné ou image uniquement)."
+        )
+
+    return "\n\n".join(full_text)
+
+
+def extract_text_from_uploaded_file(uploaded_file) -> str:
+    """
+    Extract text from a Streamlit uploaded file object.
+
+    Raises:
+        PDFExtractionError: If extraction fails.
+    """
+    try:
+        pdf_bytes = uploaded_file.read()
+    except Exception as e:
+        raise PDFExtractionError(f"Impossible de lire le fichier: {str(e)}")
+
+    if len(pdf_bytes) == 0:
+        raise PDFExtractionError("Le fichier est vide.")
+
+    uploaded_file.seek(0)  # Reset for potential re-read
+    return extract_text_from_pdf(pdf_bytes)
+
+
+def get_page_count(pdf_content: bytes) -> int:
+    """Get the number of pages in a PDF."""
+    try:
+        doc = fitz.open(stream=pdf_content, filetype="pdf")
+        count = len(doc)
+        doc.close()
+        return count
+    except Exception:
+        return 0