Initial commit

.env.example

@@ -0,0 +1,18 @@
+# ========================
+#     LLM API KEYS
+# ========================
+OPENAI_API_KEY=your_openai_api_key
+LANGTRACE_API_KEY=your_langtrace_api_key
+
+# ========================
+#     REDIS
+# ========================
+REDIS_URL=redis://default:password@redis-host:port/0
+
+# ========================
+#     BACKEND API
+# ========================
+# Development
+BACKEND_API_URL=http://localhost:8000
+# Production (uncomment for deployment)
+# BACKEND_API_URL=https://api.yoursite.com

.gitignore

@@ -0,0 +1,34 @@
+# Environnement
+.env
+.env.*
+!.env.example
+venv/
+env/
+ENV/
+.venv/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Tests
+.pytest_cache/
+.coverage
+htmlcov/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# Distribution
+dist/
+build/
+*.egg-info/
+
+# OS
+.DS_Store
+Thumbs.db

main.py

@@ -0,0 +1,73 @@
+import os
+import logging
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from src.services.graph_service import GraphInterviewProcessor
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="Interview Simulation API",
+    description="API for interview simulations.",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+ALLOWED_ORIGINS = os.getenv("CORS_ORIGINS", "http://localhost:8000").split(",")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class HealthCheck(BaseModel):
+    status: str = "ok"
+
+@app.get("/", response_model=HealthCheck, tags=["Status"])
+async def health_check():
+    return HealthCheck()
+
+@app.post("/simulate-interview/")
+async def simulate_interview(request: Request):
+    """
+    This endpoint receives the interview data, instantiates the graph processor
+    and starts the conversation.
+    """
+    try:
+        payload = await request.json()
+
+        if not all(k in payload for k in ["user_id", "job_offer_id", "cv_document", "job_offer"]):
+            raise HTTPException(status_code=400, detail="Missing data in payload (user_id, job_offer_id, cv_document, job_offer).")
+
+        logger.info(f"Starting simulation for user: {payload['user_id']}")
+
+        processor = GraphInterviewProcessor(payload)
+        result = processor.invoke(payload.get("messages", []), cheat_metrics=payload.get("cheat_metrics"))
+
+        return JSONResponse(content=result)
+
+    except ValueError as ve:
+        logger.error(f"Data validation error: {ve}", exc_info=True)
+        return JSONResponse(content={"error": str(ve)}, status_code=400)
+    except Exception as e:
+        logger.error(f"Internal error in simulate-interview endpoint: {e}", exc_info=True)
+        return JSONResponse(
+            content={"error": "An internal error occurred on the assistant's server."},
+            status_code=500
+        )
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 8002)) 
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,21 @@
+langchain
+langchain-openai
+langgraph
+langchain-core
+pydantic
+fastapi
+uvicorn
+python-dotenv
+crewai
+langtrace-python-sdk
+celery
+redis
+langchain-community
+transformers
+torch --extra-index-url https://download.pytorch.org/whl/cpu
+scikit-learn
+textstat
+chromadb
+sentence-transformers
+numpy
+textblob

src/celery_app.py

@@ -0,0 +1,29 @@
+import os
+from celery import Celery
+from dotenv import load_dotenv
+
+load_dotenv()
+
+redis_url = os.getenv("REDIS_URL")
+
+celery_app = Celery(
+    "interview_simulation_api",
+    broker=redis_url,
+    backend=redis_url,
+    include=['src.tasks']
+)
+
+celery_app.conf.update(
+    task_serializer="json",
+    accept_content=["json"],
+    result_serializer="json",
+    timezone="Europe/Paris",
+    enable_utc=True,
+    task_track_started=True,
+    broker_connection_retry_on_startup=True,
+    broker_transport_options={
+        "visibility_timeout": 3600,
+        "socket_timeout": 30,  # Increase socket timeout
+        "socket_connect_timeout": 30
+    }
+)

src/config.py

@@ -0,0 +1,16 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from langchain_openai import ChatOpenAI
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+def crew_openai():
+    """Returns a ChatOpenAI instance configured for CrewAI feedback analysis."""
+    return ChatOpenAI(
+        model="gpt-4o-mini",
+        temperature=0.1,
+        api_key=OPENAI_API_KEY
+    )

src/prompts/agent_auditeur.txt

@@ -0,0 +1,31 @@
+IDENTITY:
+Tu es l'IA de recrutement (Focus Technique).
+Ton style est curieux, précis et fluide. Tu ne lis PAS de script.
+
+PHASE : PROJETS & HARD SKILLS (SOAR)
+
+TA MISSION :
+Engager une discussion technique naturelle sur les projets du candidat, en t'adaptant à son profil (Icebreaker).
+
+1.  **D'abord, REBONDIS sur le profil** :
+    *   Utilise le **CONTEXTE ICEBREAKER** pour personnaliser ton approche.
+    *   Si le candidat est en reconversion, sois encourageant mais vérifie les bases.
+    *   Si le candidat est expérimenté, va directement au but sur des détails complexes.
+    *   Exemple : "Avec votre background en [contexte], comment avez-vous abordé la technique sur ce projet ?"
+
+2.  **Choisis un PROJET** : Analyse le JSON du CV. Repère un projet complexe ou pertinent pour le poste ({poste}).
+
+3.  **Formule TA PROPRE question (SOAR)** : Demande-lui de raconter ce projet sous l'angle "Situation/Obstacle" ou "Architecture".
+    *   Ne pose pas une question générique.
+    *   Utilise les technos citées dans le CV pour rendre la question crédible.
+
+4.  **Si le candidat a déjà répondu** : Creuse un point précis (l'Obstacle technique ou le Résultat mesurable) en fonction de ce qu'il vient de dire.
+
+RÈGLES DE STYLE :
+- PAS de phrases types. Improvise comme un recruteur senior.
+- PAS de "Passons à la suite". Fais une transition conversationnelle.
+- Si le candidat reste vague, demande des précisions techniques (versions, librairies, contraintes).
+
+CONTEXTE :
+{user_id}
+{job_description}

src/prompts/agent_challenger.txt

@@ -0,0 +1,14 @@
+You are the **Challenger Agent**.
+
+**Context**: The candidate gave a vague, generic, or insufficient answer.
+**Goal**: Drill down to get the truth without being aggressive.
+
+**Tone**: "Critical Friend". Firm but fair. "Constructively Skeptical".
+
+**Instructions**:
+1.  Reference the specific part of their answer that was vague.
+2.  Ask for a concrete example or specific detail.
+    - *Example*: "You mentioned 'handling the problem', but could you walk me through the specific steps *you* personally took?"
+    - *Example*: "That sounds like a standard approach. Did you consider any alternatives, and why did you reject them?"
+
+**Constraint**: Do not be rude. The goal is to urge them to use the STAR/SOAR method (Situation, Obstacle, Action, Result).

src/prompts/agent_enqueteur.txt

@@ -0,0 +1,29 @@
+IDENTITY:
+Tu es l'IA de recrutement (Focus Humain & Collaboration).
+Ton style est empathique mais perspicace.
+
+PHASE : SOFT SKILLS (STAR)
+
+TA MISSION :
+Explorer la dimension humaine du candidat en tenant compte de son niveau technique.
+
+1.  **TRANSITION NATURELLE** : Rebondis sur le **BILAN TECHNIQUE**.
+    *   Si le candidat a des lacunes techniques identifiées, interroge sa capacité d'apprentissage ou son humilité.
+    *   Si le candidat est très fort techniquement, interroge son leadership ou sa capacité à mentorer.
+    *   Exemple : "Vous avez une belle maîtrise de [skill], mais comment gérez-vous les désaccords techniques en équipe ?"
+
+2.  **Cible une QUALITÉ** : Regarde les "Soft Skills" du CV ou du poste ({poste}).
+
+3.  **Génère une mise en situation (STAR)** : Demande au candidat de raconter un moment clé lié au travail d'équipe (conflit, feedback, mentoring, adaptation).
+    *   Ne dis pas "Donnez-moi une méthode STAR".
+    *   Dis plutôt : "Racontez-moi une fois où vous avez dû gérer..."
+
+4.  **Creuse** : Si l'histoire manque de "Résultat" ou d'"Action personnelle", demande-lui simplement comment cela s'est fini pour lui.
+
+RÈGLES DE STYLE :
+- Parle naturellement. Pas de robotisme.
+- Sois à l'écoute : Si le candidat a mentionné un contexte difficile avant, utilise-le.
+
+CONTEXTE :
+{user_id}
+{job_description}

src/prompts/agent_icebreaker.txt

@@ -0,0 +1,28 @@
+Tu es l'Agent Icebreaker (RONI).
+
+Ta mission : Mettre en confiance le candidat {first_name} (ID: {user_id}) pour le poste de {poste} chez {entreprise}.
+Tu as le droit de poser exactement {nb_questions} questions au total pour cette phase.
+Tu as accès à son contexte :
+{context_str}
+
+**TON OBJECTIF :**
+Accueillir le candidat de manière personnalisée et aller droit au but pour comprendre ses motivations profondes (Storytelling).
+
+**STRUCTURE OBLIGATOIRE DU PREMIER MESSAGE :**
+1.  **Salutation** : "Bonjour {first_name} !" (ou juste "Bonjour !" si prénom vide).
+2.  **Présentation & Déroulé** : "Je suis RONI, l'IA qui va vous accompagner. L'entretien se déroulera en 3 parties : nous ferons d'abord connaissance, puis nous parlerons technique, et enfin soft skills."
+3.  **Question d'ouverture** : Enchaîne **immédiatement** (dans le même message) sur la phase de découverte/motivation.
+
+**PHASE DE DÉCOUVERTE (Storytelling & Motivation)**
+- Au lieu d'un "Présentez-vous" classique, invite-le au récit.
+- Exemple : "Au-delà du CV que j'ai sous les yeux, racontez-moi votre histoire : qu'est-ce qui vous a amené à postuler aujourd'hui ?"
+- **ADAPTATION AU CONTEXTE** :
+    - Si **RECONVERSION = OUI** : Demande ce qui a déclenché ce changement de cap.
+    - Si **ÉTUDIANT = OUI** : Demande ce qui l'attire dans ce poste pour démarrer sa carrière.
+    - Sinon : Demande ce qui motive sa passion pour ce domaine.
+
+**RÈGLES D'OR :**
+1. PAS de questions "Bateau" sur la météo ou la journée ("Comment allez-vous ?").
+2. PAS de questions sur les hobbies sauf si le candidat en parle spontanément.
+3. Sois chaleureux mais professionnel et direct.
+4. Tu dois absolument passer la main à l'agent suivant après {nb_questions} échanges.

src/prompts/agent_projecteur.txt

@@ -0,0 +1,20 @@
+IDENTITY:
+Tu es l'IA de recrutement (Focus Motivation & Avenir).
+Ton style est ouvert et prospectif.
+
+PHASE : PROJECTION
+
+TA MISSION :
+Vérifier si le candidat se voit vraiment dans CE poste.
+1.  **REBONDIS** : Valide la réponse précédente sur le dilemme (SJT) par un accusé de réception neutre mais courtois.
+2.  **PROJECTION** : Invite le candidat à parler de son avenir DANS L'ENTREPRISE ({entreprise}).
+    *   Choisis un angle : Les compétences qu'il veut acquérir, le type de management qu'il aime, ou ce qui l'attire dans ce secteur spécifique.
+    *   Exemple : "Si vous nous rejoignez demain, quel serait votre premier chantier prioritaire ?"
+
+RÈGLES DE STYLE :
+- Fais sentir au candidat qu'on s'intéresse à SES envies.
+- Évite les questions trop banales type "Où vous voyez-vous dans 5 ans ?". Préfère le concret court-terme (6-12 mois).
+
+CONTEXTE :
+{user_id}
+{job_description}

src/prompts/agent_stratege.txt

@@ -0,0 +1,26 @@
+IDENTITY:
+Tu es l'IA de recrutement (Focus Jugement & Éthique).
+Ton style est un peu plus "challenger" mais reste professionnel.
+
+PHASE : JUGEMENT SITUATIONNEL (SJT)
+
+TA MISSION :
+Tester la prise de décision du candidat face à un dilemme réaliste pour le poste ({poste}), en ciblant ses points faibles potentiels.
+
+1.  **ANALYSE LE BILAN COMPORTEMENTAL** : Regarde les "POINTS À INTÉGRER".
+    *   Construis ton scénario pour tester spécifiquement ces points (ex: gestion du stress, communication, rigueur).
+
+2.  **IMAGINE UN SCÉNARIO** : Basé sur le métier (Data Scientist, Analyst, etc.) ET les points à tester.
+    *   Exemples (à adapter) : Biais de données, pression des délais vs qualité, confidentialité, hallucination d'IA.
+
+3.  **LANCE LE DÉFI** : "Imaginons une situation : [Ton Scénario]. Que faites-vous ?"
+
+4.  **LE TWIST (Si 2ème échange)** : Si le candidat a donné une première réponse "idéale", ajoute une contrainte forte pour voir s'il tient bon. (Ex: "Votre chef refuse cette solution pour des raisons de budget. Vous faites quoi ?").
+
+RÈGLES DE STYLE :
+- Ne te présente pas.
+- Utilise une transition fluide : "Changeons de perspective un instant..." ou "J'aimerais vous projeter dans une situation type du poste."
+
+CONTEXTE :
+{user_id}
+{job_description}

src/prompts/orchestrator_prompt.txt

@@ -0,0 +1,31 @@
+Tu es l'Orchestrateur d'une simulation d'entretien structuré pour un profil Junior/Reconversion Data & IA.
+
+**OBJECTIF** : Guider l'entretien à travers 6 étapes clés en analysant l'historique de la conversation.
+
+**ÉTAPES DU FLOW** :
+1. "icebreaker" : Accueil (RONI), synthèse du parcours, déclic reconversion.
+2. "auditeur" : Hard Skills & Projets (Méthode SOAR).
+3. "enqueteur" : Soft Skills & Collaboration (Méthode STAR).
+4. "stratege" : Jugement Situationnel (SJT) + Twist (Pression).
+5. "projecteur" : Motivation & Culture Add (Projection).
+6. "cloture" : Questions inversées (Candidat pose des questions).
+
+**RÈGLES DE DÉCISION (TRIGGERS)** :
+Analyse la dernière réponse du candidat :
+- Si l'étape est "icebreaker" et réponse < 30 mots ou évasive -> Reste et challenge (Max 1 relance).
+- Si l'étape est "auditeur" et manque de justification ("Pourquoi") ou usage de "Nous" au lieu de "Je" -> Reste et challenge (Max 2 relances).
+- Si l'étape est "enqueteur" et manque de Résultat chiffré ou Action précise (STAR) -> Reste et challenge (Max 2 relances).
+- Si l'étape est "stratege" -> Systématiquement une relance (Stress Test).
+- Si l'étape est "cloture" et que le candidat n'a plus de questions ou dit "C'est bon", "Non", "Merci" -> Renvoie "end_interview" IMMÉDIATEMENT.
+- Si le candidat dit "Au revoir", "Merci", "C'est tout pour moi" ou indique qu'il a fini -> Renvoie "end_interview" IMMÉDIATEMENT.
+- Si l'étape actuelle est terminée (réponse satisfaisante) -> Passe à l'étape SUIVANTE.
+
+
+**ÉTAT ACTUEL** :
+- Étape en cours : {section}
+- Nombre d'échanges dans cette étape : {turn_count}
+
+**SORTIE ATTENDUE** :
+Retourne UNIQUEMENT une chaîne de caractères parmi :
+"icebreaker", "auditeur", "enqueteur", "stratege", "projecteur", "cloture", "end_interview".
+(Si tu dois challenger, renvoie le nom de l'étape actuelle. L'agent gérera le challenge).

src/schemas/__init__.py

@@ -0,0 +1 @@
+# Empty file to mark as Python package

src/schemas/feedback_schemas.py

@@ -0,0 +1,84 @@
+"""Pydantic schemas for interview feedback output."""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+
+class CandidatFeedback(BaseModel):
+    """Feedback section for the candidate."""
+    points_forts: List[str] = Field(..., description="Liste des points forts démontrés")
+    points_a_ameliorer: List[str] = Field(..., description="Liste des axes d'amélioration identifiés")
+    conseils_apprentissage: List[str] = Field(..., description="Ressources ou actions concrètes pour progresser")
+    score_global: int = Field(..., description="Note globale sur 100")
+    feedback_constructif: str = Field(..., description="Message bienveillant et constructif adressé au candidat")
+
+
+class MetricsBreakdown(BaseModel):
+    """Detailed breakdown of scores."""
+    communication: float = Field(..., description="Score 0-10: Orthographe, grammaire, clarté")
+    technique: float = Field(..., description="Score 0-10: Compétence technique (SOAR)")
+    comportemental: float = Field(..., description="Score 0-10: Soft skills (STAR)")
+    fidelite_cv: float = Field(..., description="Score 0-10: Cohérence avec le CV")
+
+
+class FraudDetectionMetrics(BaseModel):
+    """Detailed fraud detection metrics (0-100)."""
+    vocab_score: int = Field(..., description="Usage de mots 'GPT' (delve, tapestry...)")
+    structure_score: int = Field(..., description="Patterns structurels (listes, longueur...)")
+    paste_score: int = Field(..., description="Basé sur l'événement copier-coller")
+    pattern_score: int = Field(..., description="Répétitions, questions en retour, proximité CV")
+
+class FraudDetection(BaseModel):
+    """Complete fraud analysis."""
+    score_global: int = Field(..., description="Probabilité globale d'usage IA (0-100)")
+    red_flag: bool = Field(False, description="Vrai si score > 70")
+    detected_keywords: List[str] = Field(..., description="Mots suspects identifiés")
+    resume: str = Field(..., description="Eplication courte")
+    details: FraudDetectionMetrics
+
+class DashboardCompetences(BaseModel):
+    """Score de similarité basé sur la triade."""
+    technique: float = Field(..., description="Adéquation Hard Skills (0-100)")
+    cognitive: float = Field(..., description="Raisonnement et structure (0-100)")
+    comportementale: float = Field(..., description="Soft Skills & Culture Fit (0-100)")
+    average_score: float = Field(..., description="Moyenne pondérée")
+
+class DecisionStrategique(BaseModel):
+    """Pilier décisionnel du rapport."""
+    recommendation: str = Field(..., description="RECRUTER, APPROFONDIR ou REJETER")
+    action_plan: str = Field(..., description="Recommandation d'action immédiate (ex: Tester sur SQL)")
+    so_what: str = Field(..., description="Impact business direct du candidat (Le 'Pourquoi' stratégique)")
+
+class RolsPcdAnalysis(BaseModel):
+    """Analyse structurée ROLS et PCD."""
+    rols_summary: str = Field(..., description="Résumé ROLS (Résumé, Objectifs, Localisation, Stratégie)")
+    pcd_analysis: str = Field(..., description="Analyse PCD (Produits, Clients, Distribution)")
+
+class EntrepriseInsights(BaseModel):
+    """Insights section for the recruiter/company."""
+    correspondance_profil_offre: str = Field(..., description="Analyse de l'adéquation CV/Poste")
+    
+    # Dashboard
+    dashboard: DashboardCompetences = Field(..., description="Tableau de bord des compétences")
+    
+    # Qualitative Analysis
+    qualitative_analysis: RolsPcdAnalysis = Field(..., description="Analyse structurée ROLS/PCD")
+    
+    # Strategic Decision
+    decision: DecisionStrategique = Field(..., description="Aide à la décision")
+
+    # Fraud & Cheat Detection
+    fraud_detection: FraudDetection = Field(..., description="Analyse complète anti-triche")
+    
+    # Legacy Metrics (kept for backward compatibility if needed, or mapped from dashboard)
+    metrics: MetricsBreakdown = Field(..., description="Détail des notes par catégorie")
+    
+    # Global verification
+    red_flag_detected: bool = Field(False, description="True si un comportement inacceptable est détecté")
+    red_flag_reason: Optional[str] = Field(None, description="Raison du Veto si applicable")
+
+
+class FeedbackOutput(BaseModel):
+    """Complete feedback output with candidate and company sections."""
+    candidat: CandidatFeedback
+    entreprise: EntrepriseInsights

src/services/analysis_service.py

@@ -0,0 +1,160 @@
+import logging
+import json
+from typing import Dict, List, Any, Optional
+from src.services.feedback_crew import FeedbackCrew
+from src.services.integrity_service import IntegrityService
+from src.services.search_service import SearchService
+from src.config import crew_openai
+from langchain_core.messages import HumanMessage, SystemMessage
+
+logger = logging.getLogger(__name__)
+
+
+def _flatten_dict_values(d) -> list:
+    """Recursively flatten all values from a nested dict/list structure into a list of strings."""
+    text = []
+    if not isinstance(d, dict):
+        return [str(d)]
+    for k, v in d.items():
+        if isinstance(v, dict):
+            text.extend(_flatten_dict_values(v))
+        elif isinstance(v, list):
+            for i in v:
+                if isinstance(i, dict):
+                    text.extend(_flatten_dict_values(i))
+                else:
+                    text.append(str(i))
+        else:
+            text.append(str(v))
+    return text
+
+
+class AnalysisService:
+    def __init__(self):
+        self.integrity_service = IntegrityService()
+        self.search_service = SearchService()
+        self.llm = crew_openai()
+
+    def run_analysis(self, conversation_history: List[Dict[str, Any]], job_description: str, cv_content: str, cheat_metrics: Dict[str, Any] = None, simulation_report: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Runs the feedback analysis using CrewAI with enhanced pre-processing (Multi-Agent RAG).
+        If simulation_report is provided, it is used as the result, bypassing CrewAI.
+        """
+        logger.info("Starting Interview Feedback Analysis...")
+        
+        if simulation_report:
+            logger.info("Using pre-computed Simulation Report. Bypassing CrewAI.")
+            try:
+                # Run Integrity Analysis (Cheating detection)
+                transcript_text = " ".join([m.get('content', '') for m in conversation_history if m.get('role') == 'user'])
+                # Extract CV text (flatten values for stylometry)
+                cv_text = ". ".join(_flatten_dict_values(cv_content)) if isinstance(cv_content, dict) else str(cv_content)
+
+                integrity_report = self.integrity_service.analyze_integrity(
+                    cv_text=cv_text,
+                    interview_text=transcript_text,
+                    existing_metrics=cheat_metrics
+                )
+                
+                result = simulation_report.copy()
+                result["integrity_report"] = integrity_report
+                result["cheat_metrics"] = cheat_metrics
+                
+                return result
+                
+            except Exception as e:
+                logger.error(f"Error enriching simulation report: {e}")
+                return simulation_report
+
+        logger.info("No Simulation Report provided. Fallback to CrewAI.")
+        
+        try:
+            # Parse inputs
+            if isinstance(job_description, str):
+                try:
+                    job_offer_data = json.loads(job_description)
+                except json.JSONDecodeError:
+                    job_offer_data = {"description": job_description}
+            else:
+                job_offer_data = job_description
+
+            # Prepare text for analysis
+            transcript_text = " ".join([m.get('content', '') for m in conversation_history if m.get('role') == 'user'])
+            
+            # Extract CV text (flatten values for stylometry)
+            cv_text = ". ".join(_flatten_dict_values(cv_content)) if isinstance(cv_content, dict) else str(cv_content)
+
+            # Run RAG Gap Analysis (Search Agent Grounding)
+            job_mission = job_offer_data.get('mission', '') or job_offer_data.get('description', '')
+            gap_analysis = self.search_service.analyze_gap(cv_text, job_mission)
+            
+            # Run Integrity Analysis
+            integrity_report = self.integrity_service.analyze_integrity(
+                cv_text=cv_text,
+                interview_text=transcript_text,
+                existing_metrics=cheat_metrics
+            )
+            
+            # Detect Job Seniority (Robust LLM Method)
+            seniority = self._analyze_job_context_with_llm(job_offer_data)
+            
+            # Merge Metrics
+            enhanced_metrics = cheat_metrics or {}
+            enhanced_metrics.update({
+                "integrity_report": integrity_report,
+                "semantic_score": gap_analysis.get('semantic_score', 0.0),
+                "required_seniority": seniority
+            })
+            
+            logger.info(f"Enhanced Metrics: {enhanced_metrics}")
+            logger.info(f"Gap Analysis: {gap_analysis}")
+
+            crew = FeedbackCrew(
+                job_offer=job_offer_data,
+                cv_content=cv_content,
+                conversation_history=conversation_history,
+                cheat_metrics=enhanced_metrics,
+                gap_analysis=gap_analysis
+            )
+            
+            result = crew.run()
+            logger.info("Feedback Analysis completed successfully.")
+            return result
+
+        except Exception as e:
+            logger.error(f"Error during feedback analysis: {e}", exc_info=True)
+            return {"error": str(e)}
+
+    def _analyze_job_context_with_llm(self, job_data: Dict[str, Any]) -> str:
+        """
+        Uses LLM to detect seniority context, avoiding false positives (e.g. 'Reporting to Head of Data').
+        """
+        try:
+            description = str(job_data)
+            prompt = f"""
+            ANALYSE LE CONTEXTE DE CETTE OFFRE D'EMPLOI :
+            {description}
+            
+            TÂCHE : Détermine le niveau de séniorité requis pour le CANDIDAT.
+            
+            RÈGLES CRITIQUES :
+            1. "STAGE", "ALTERNANCE", "APPRENTISSAGE" = TOUJOURS "JUNIOR".
+            2. Ignore les mentions de la hiérarchie (ex: "Sous la direction du Senior Manager" -> Le poste n'est PAS Senior).
+            3. "Débutant", "Junior", "0-2 ans", "Sortie d'école" = "JUNIOR".
+            4. "Lead", "Expert", "Manager", "+5 ans", "Architecte" = "SENIOR".
+            5. Sinon -> "MID".
+
+            Réponds UNIQUEMENT par un seul mot : JUNIOR, SENIOR ou MID.
+            """
+            
+            response = self.llm.invoke([HumanMessage(content=prompt)])
+            result = response.content.strip().upper()
+            
+            if result not in ["JUNIOR", "SENIOR", "MID"]:
+                return "MID" # Fallback
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error in LLM seniority detection: {e}")
+            return "MID" # Safe fallback

src/services/config/agents.yaml

@@ -0,0 +1,53 @@
+consistency_analyst:
+  role: "Analyste de Cohérence"
+  goal: "Vérifier la véracité et la cohérence des propos du candidat par rapport à son CV."
+  backstory: >
+    Expert en détection de fraude et de triche. Vous ne tolérez aucune déviation éthique.
+    Votre focus: Trolling, Usage IA générative, Copier-Coller.
+    Vous travaillez avec des données précises de "Gap Analysis".
+  verbose: true
+  allow_delegation: false
+
+search_analyst:
+  role: "Analyste Grounding & RAG"
+  goal: "Identifier les écarts factuels (Hidden Skill Gaps) entre le CV et le poste."
+  backstory: >
+    Spécialiste de l'analyse sémantique et de la comparaison de données.
+    Vous détectez les profils en reconversion et valorisez leur potentiel d'apprentissage.
+    Vous vérifiez si le candidat possède les "Action Verbs" de production (Déployer, Monitorer).
+  verbose: true
+  allow_delegation: false
+
+tech_expert:
+  role: "Expert Technique (Adapté au contexte)"
+  goal: "Valider les compétences techniques spécifiques au rôle ({job_type})."
+  backstory: >
+    CTO pragmatique. Vous adaptez vos exigences au type de poste :
+    - Pour DATA ANALYST : Vous cherchez SQL, PowerBI, la clarté des insights et l'automatisation simple.
+    - Pour DATA SCIENTIST : Vous cherchez la méthode scientifique (Métriques, Biais, Context Engineering).
+    - Pour DATA ENGINEER : Vous cherchez CI/CD, Docker, Cloud, Latence, Production.
+    
+    IMPORTANT : Vous écoutez ce que dit le candidat. S'il mentionne des termes techniques précis ("SLM", "Vector DB", "Context Engineering"), vous VALIDEZ la compétence, même si elle n'est pas dans le CV.
+  verbose: true
+  allow_delegation: false
+
+business_evaluator:
+  role: "Stratège Business (ROLS & PCD)"
+  goal: "Évaluer la capacité du candidat à résoudre des problèmes business complexes."
+  backstory: >
+    Consultant senior en stratégie. Vous évaluez la vision business du candidat.
+    Vous appliquez strictement les cadres ROLS (Résumé, Objectifs, Localisation, Stratégie)
+    et PCD (Produits, Clients, Distribution) pour structurer votre analyse.
+    Vous cherchez le "So What?" dans chaque réponse.
+  verbose: true
+  allow_delegation: false
+
+final_reporter:
+  role: "Responsable Recrutement"
+  goal: "Synthétiser toutes les analyses pour une prise de décision stratégique."
+  backstory: >
+    Décideur final. Vous consolidez les rapports des experts (Tech, Business, Search).
+    Vous devez trancher : RECRUTER, APPROFONDIR ou REJETER.
+    Vous prenez en compte le statut "Reconversion" pour ajuster votre tolérance sur l'expérience.
+  verbose: true
+  allow_delegation: false

src/services/config/tasks.yaml

@@ -0,0 +1,97 @@
+consistency_task:
+  description: >
+    Analyse la conversation pour détecter la fraude.
+    Données d'intégrité: {cheat_metrics}
+    
+    Règles:
+    - Si 'ai_score' > 75 -> STOP/VETO.
+    - Si insultes/trolling -> STOP/VETO.
+  expected_output: "Statut Fraude (RAS, ALERTE, VETO) avec justification."
+  agent: consistency_analyst
+
+search_task:
+  description: >
+    Analyse l'écart CV vs Offre (Gap Analysis).
+    Données Gap Analysis: {gap_analysis}
+    
+    1. Confirme si c'est une RÉCONVERSION (basé sur 'is_reconversion').
+    2. Identifie les compétences manquantes (Hidden Skill Gaps).
+    3. Vérifie la présence des 'Action Verbs' de production.
+  expected_output: "Rapport de Gap Analysis : Confirm Reconversion (O/N), Liste des Gaps, Score Modernité."
+  agent: search_analyst
+
+tech_task:
+  description: >
+    Évaluation Technique Approfondie (Methodologie SOAR) adaptée au poste : {job_type}.
+    
+    CRITIQUE : Analyse les RÉPONSES du candidat dans conversation_history.
+    Ce que le candidat DIT prévaut sur ce qui est écrit dans le CV.
+    Si le candidat démontre une expertise (ex: parle de "Context Engineering", "SLM", "Vectors") -> VALORISE LE, même si absent du CV.
+    
+    1. Si DATA ANALYST :
+       - Cherche : SQL complexe, Nettoyage de données, Visualisation, Storytelling.
+       - Ignore : CI/CD, Docker, Kubernetes.
+    2. Si DATA SCIENTIST :
+       - Cherche : Choix des modèles, Métriques d'évaluation, Feature Engineering.
+    3. Si DATA ENGINEER :
+       - Cherche : CI/CD, Code Quality, Scalabilité, Monitoring.
+       
+    Utilise SOAR (Situation, Obstacle, Action, Résultat).
+    Note sur 10. NE Mets JAMAIS 0 si le candidat a les bases mais manque d'expérience pro.
+  expected_output: "Évaluation Tech détaillée + Note /100."
+  agent: tech_expert
+
+business_task:
+  description: >
+    Évaluation Stratégique & Business (ROLS & PCD).
+    
+    1. Applique ROLS si une étude de cas est présente :
+       - Résumé situation
+       - Objectifs posés
+       - Localisation du problème
+       - Stratégie proposée
+    
+    2. Applique PCD pour l'analyse produit :
+       - Produit (Compréhension)
+       - Clients (Ciblage)
+       - Distribution (Go-to-market)
+       
+    3. Cherche le "So What?" : Le candidat lie-t-il la tech au business ?
+  expected_output: "Analyse ROLS/PCD structurée + Note Business /100."
+  agent: business_evaluator
+
+reporting_task:
+  description: >
+    Synthèse Décisionnelle Finale avec Scoring Dynamique.
+    
+    CONTEXTE :
+    - Poste : {job_type}
+    - Reconversion : {gap_analysis}
+    - Fraude : consistency_task.output
+    
+    RÈGLES DE SCORING STRICTES :
+    1. Si 'consistency_task' indique une FRAUDE ou un RED FLAG (trolling, insultes, incohérence majeure) :
+       -> SCORE FINAL DOIT ÊTRE < 40. REJET IMMÉDIAT.
+    2. Si Pas de Red Flag :
+       -> Utilisez toute l'échelle (10-90).
+       -> Un débutant motivé mérite ~50-60.
+       -> Un expert mérite > 80.
+    
+    SCORING PONDÉRÉ :
+    - Tech: 40% (Expertise & Prod) -> SI ANALYST, Tech = SQL/Viz, pas Infra.
+    - Cognitive (Business/ROLS): 30%
+    - Comportementale (Soft): 30%
+    
+    DECISION STRATEGIQUE :
+    - RECRUTER : Si Score > 75 et aucun Red Flag.
+    - APPROFONDIR : Si Score 50-75 ou doute sur un Gap.
+    - REJETER : Si Score < 50 ou Veto Fraude.
+    
+    Génère le JSON final 'FeedbackOutput'.
+  expected_output: "JSON complet respectant le schéma FeedbackOutput."
+  agent: final_reporter
+  context:
+    - consistency_task
+    - search_task
+    - tech_task
+    - business_task

src/services/feedback_crew.py

@@ -0,0 +1,130 @@
+"""Feedback Crew for interview analysis using CrewAI."""
+
+import json
+import logging
+from typing import Dict, Any, List
+
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, task, crew
+
+from src.config import crew_openai
+from src.schemas.feedback_schemas import FeedbackOutput
+
+logger = logging.getLogger(__name__)
+
+
+@CrewBase
+class FeedbackCrew:
+    """Crew for analyzing interview conversations and generating structured feedback."""
+    
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+    
+    def __init__(self, job_offer: Dict[str, Any], cv_content: str, conversation_history: List[Dict[str, Any]], cheat_metrics: Dict[str, Any] = None, gap_analysis: Dict[str, Any] = None):
+        self.job_offer = json.dumps(job_offer, ensure_ascii=False)
+        self.cv_content = cv_content
+        self.conversation_history = json.dumps(conversation_history, ensure_ascii=False)
+        self.cheat_metrics = json.dumps(cheat_metrics or {}, ensure_ascii=False)
+        self.gap_analysis = json.dumps(gap_analysis or {}, ensure_ascii=False)
+        self._llm = crew_openai()
+    
+    # --- Agents ---
+    
+    @agent
+    def consistency_analyst(self) -> Agent:
+        return Agent(config=self.agents_config["consistency_analyst"], llm=self._llm)
+    
+    @agent
+    def search_analyst(self) -> Agent:
+        return Agent(config=self.agents_config["search_analyst"], llm=self._llm)
+
+    @agent
+    def tech_expert(self) -> Agent:
+        return Agent(config=self.agents_config["tech_expert"], llm=self._llm)
+    
+    @agent
+    def business_evaluator(self) -> Agent:
+        return Agent(config=self.agents_config["business_evaluator"], llm=self._llm)
+    
+    @agent
+    def final_reporter(self) -> Agent:
+        return Agent(config=self.agents_config["final_reporter"], llm=self._llm)
+    
+    # --- Tasks ---
+    
+    @task
+    def consistency_task(self) -> Task:
+        return Task(config=self.tasks_config["consistency_task"])
+    
+    @task
+    def search_task(self) -> Task:
+        return Task(config=self.tasks_config["search_task"])
+
+    @task
+    def tech_task(self) -> Task:
+        return Task(config=self.tasks_config["tech_task"])
+    
+    @task
+    def business_task(self) -> Task:
+        return Task(config=self.tasks_config["business_task"])
+    
+    @task
+    def reporting_task(self) -> Task:
+        return Task(
+            config=self.tasks_config["reporting_task"],
+            output_pydantic=FeedbackOutput
+        )
+    
+    # --- Crew ---
+    
+    @crew
+    def crew(self) -> Crew:
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True
+        )
+    
+    # --- Public API ---
+    
+    def run(self) -> Dict[str, Any]:
+        """Execute the feedback crew and return structured output."""
+        logger.info("Starting Feedback Crew analysis...")
+        
+        # Safe extraction of job_type from gap_analysis string or dict
+        job_type = "GENERAL_TECH"
+        try:
+            ga_data = json.loads(self.gap_analysis) if isinstance(self.gap_analysis, str) else self.gap_analysis
+            job_type = ga_data.get("job_type", "GENERAL_TECH")
+        except:
+            pass
+
+        inputs = {
+            "job_offer": self.job_offer,
+            "cv_content": self.cv_content,
+            "conversation_history": self.conversation_history,
+            "cheat_metrics": self.cheat_metrics,
+            "gap_analysis": self.gap_analysis,
+            "job_type": job_type
+        }
+        
+        result = self.crew().kickoff(inputs=inputs)
+        
+        # Handle structured output
+        if result.pydantic:
+            return result.pydantic.model_dump()
+        elif result.json_dict:
+            return result.json_dict
+        else:
+            logger.warning("No structured output, parsing raw result")
+            try:
+                raw_str = str(result.raw)
+                start = raw_str.find('{')
+                end = raw_str.rfind('}') + 1
+                if start != -1 and end > start:
+                    return json.loads(raw_str[start:end])
+            except json.JSONDecodeError as e:
+                logger.error(f"JSON parsing failed: {e}")
+            
+            return {"error": "Could not parse output", "raw": str(result.raw)}

src/services/graph_service.py

@@ -0,0 +1,504 @@
+import os
+import logging
+import json
+from pathlib import Path
+from typing import TypedDict, Annotated, Dict, Any, List, Optional
+
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import BaseMessage, AIMessage, HumanMessage, SystemMessage
+from langgraph.graph import StateGraph, END
+from langgraph.graph.message import add_messages
+from langtrace_python_sdk import langtrace
+
+from src.services.simulation.agents import InterviewAgentExtractor
+from src.services.simulation.schemas import (
+    IceBreakerOutput, TechnicalOutput, BehavioralOutput, SituationOutput, SimulationReport
+)
+
+langtrace.init(api_key=os.getenv("LANGTRACE_API_KEY"))
+
+logger = logging.getLogger(__name__)
+PROMPTS_DIR = Path(__file__).parent.parent / "prompts"
+
+# Number of questions per agent
+QUESTIONS_PER_AGENT = {
+    "icebreaker": 2,
+    "auditeur": 3,
+    "enqueteur": 2,
+    "stratege": 2,
+    "projecteur": 1  
+}
+
+AGENT_ORDER = ["icebreaker", "auditeur", "enqueteur", "stratege", "projecteur"]
+
+
+EXIT_MESSAGE = """L'entretien est maintenant terminé.
+
+Merci pour cet échange. Je finalise l'analyse de votre candidature, votre rapport sera disponible dans quelques instants."""
+
+
+class AgentState(TypedDict):
+    messages: Annotated[list[BaseMessage], add_messages]
+    user_id: str
+    job_offer_id: str
+    cv_data: Dict[str, Any]
+    job_data: Dict[str, Any]
+    section: str
+    turn_count: int
+    context: Dict[str, Any]
+    cheat_metrics: Dict[str, Any]
+    
+    # Structured Data
+    icebreaker_data: Optional[IceBreakerOutput]
+    technical_data: Optional[TechnicalOutput]
+    behavioral_data: Optional[BehavioralOutput]
+    situation_data: Optional[SituationOutput]
+    simulation_report: Optional[SimulationReport]
+
+
+class GraphInterviewProcessor:
+    """Strict interview simulation with per-agent question limits."""
+    
+    def __init__(self, payload: Dict[str, Any]):
+        logging.info("Initialisation de RONI GraphInterviewProcessor...")
+        
+        self.user_id = payload["user_id"]
+        self.job_offer_id = payload["job_offer_id"]
+        self.job_offer = payload["job_offer"]
+        self.cv_data = payload.get("cv_document", {}).get('candidat', {})
+
+        if not self.cv_data:
+            raise ValueError("Données du candidat non trouvées.")
+
+        self.prompts = self._load_all_prompts()
+        self.llm = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-4o-mini", temperature=0.7)
+        self.extractor = InterviewAgentExtractor(self.llm)
+        
+        self.graph = self._build_graph()
+        logging.info("RONI Graph initialisé.")
+
+    def _load_all_prompts(self) -> Dict[str, str]:
+        prompts = {}
+        prompt_files = {
+            "icebreaker": PROMPTS_DIR / "agent_icebreaker.txt",
+            "auditeur": PROMPTS_DIR / "agent_auditeur.txt",
+            "enqueteur": PROMPTS_DIR / "agent_enqueteur.txt",
+            "stratege": PROMPTS_DIR / "agent_stratege.txt",
+            "projecteur": PROMPTS_DIR / "agent_projecteur.txt"
+        }
+        for key, path in prompt_files.items():
+            try:
+                prompts[key] = path.read_text(encoding='utf-8-sig')
+            except FileNotFoundError:
+                logger.error(f"Missing prompt: {path}")
+                prompts[key] = f"You are {key}."
+            except UnicodeDecodeError:
+                logger.warning(f"Encoding issue with {path}, trying latin-1")
+                prompts[key] = path.read_text(encoding='latin-1')
+        return prompts
+
+    def _count_user_messages(self, messages: List[BaseMessage]) -> int:
+        """Count user messages from conversation history."""
+        return sum(1 for m in messages if isinstance(m, HumanMessage))
+
+    def _determine_section_and_status(self, user_msg_count: int) -> tuple[str, bool]:
+        """
+        Determine current section based on user message count.
+        Returns: (section_name, should_end)
+        """
+        cumulative = 0
+        
+        for agent in AGENT_ORDER:
+            agent_questions = QUESTIONS_PER_AGENT[agent]
+            
+            # Check if user is still within this agent's range
+            if user_msg_count < cumulative + agent_questions:
+                return agent, False
+            
+            cumulative += agent_questions
+        
+        # Past all agents -> END (projecteur completed)
+        return "end", True
+
+    # --- Context builders ---
+    
+    def _get_icebreaker_context(self, state: AgentState) -> str:
+        candidat = state["cv_data"].get("info_personnelle", {})
+        job = state["job_data"]
+        
+        # Extract Hobbies/Interests if available
+        hobbies = ", ".join(state["cv_data"].get("centres_interet", []))
+        if not hobbies:
+            hobbies = "Non spécifiés"
+            
+        # Extract Reconversion Context
+        reconversion_data = state["cv_data"].get("reconversion", {})
+        is_reco = reconversion_data.get("is_reconversion", False)
+        reco_context = "OUI" if is_reco else "NON"
+        
+        # Extract Student Context
+        etudiant_data = state["cv_data"].get("etudiant", {})
+        is_etudiant = etudiant_data.get("is_etudiant", False)
+        etudiant_context = f"OUI ({etudiant_data.get('niveau_etudes', '')})" if is_etudiant else "NON"
+        
+        return f"""
+        === CONTEXTE CANDIDAT ===
+        NOM: {candidat.get('nom', 'Candidat')} {candidat.get('prenom', '')}
+        POSTE VISÉ: {job.get('poste', 'Non spécifié')}
+        ENTREPRISE: {job.get('entreprise', 'Non spécifié')}
+        
+        === DOSSIER PERSONNEL ===
+        CENTRES D'INTÉRÊT: {hobbies}
+        EN RECONVERSION ?: {reco_context}
+        ÉTUDIANT ?: {etudiant_context}
+        """
+
+    def _get_auditeur_context(self, state: AgentState) -> str:
+        cv = state["cv_data"]
+        job = state["job_data"]
+        experiences = json.dumps(cv.get("expériences", []), ensure_ascii=False)
+        
+        # Format Projects with details
+        projets_list = cv.get("projets", {}).get("professional", []) + cv.get("projets", {}).get("personal", [])
+        projets_formatted = []
+        for p in projets_list:
+            techs = ", ".join(p.get("technologies", []))
+            outcomes = ", ".join(p.get("outcomes", []))
+            projets_formatted.append(f"- {p.get('title')}: {techs} (Résultats: {outcomes})")
+        projets_str = "\n".join(projets_formatted)
+        
+        # Format Skills with Context
+        skills_ctx = cv.get("compétences", {}).get("skills_with_context", [])
+        skills_formatted = [f"{s.get('skill')} ({s.get('context')})" for s in skills_ctx]
+        skills_str = ", ".join(skills_formatted)
+        
+        # Fallback to hard_skills if no context
+        if not skills_str:
+            skills_str = ", ".join(cv.get("compétences", {}).get("hard_skills", []))
+        
+        # Add Icebreaker Data
+        ib_data = state.get("icebreaker_data")
+        ib_context = ""
+        if ib_data:
+            ib_context = f"""
+            === PROFIL DÉTECTÉ (ICEBREAKER) ===
+            TYPE: {ib_data.profil_type}
+            EXPÉRIENCE DOMAINE: {ib_data.annees_experience_domaine}
+            MOTIVATION: {"OUI" if ib_data.motivation_detectee else "NON"}
+            CONTEXTE: {ib_data.contexte_specifique}
+            """
+            
+        return f"""
+        === CONTEXTE TECHNIQUE ===
+        MISSION DU POSTE: {job.get('mission', '')}
+        EXPÉRIENCES CANDIDAT: {experiences}
+        PROJETS SIGNIFICATIFS:
+        {projets_str}
+        
+        COMPÉTENCES ET CONTEXTE: 
+        {skills_str}
+        {ib_context}
+        """
+
+    def _get_enqueteur_context(self, state: AgentState) -> str:
+        cv = state["cv_data"]
+        soft_skills = ", ".join(cv.get("compétences", {}).get("soft_skills", []))
+        reconversion = cv.get("reconversion", {})
+        is_reco = reconversion.get("is_reconversion", False)
+        reco_txt = "OUI" if is_reco else "NON"
+        
+        # Add Technical Data (Gaps)
+        tech_data = state.get("technical_data")
+        tech_context = ""
+        if tech_data:
+            lacunes = [f"- {l.skill} (Niveau {l.niveau_detecte})" for l in tech_data.lacunes_explorees]
+            tech_context = f"""
+            === BILAN TECHNIQUE ===
+            SCORE GLOBAL: {tech_data.score_technique_global}/5
+            LACUNES IDENTIFIÉES:
+            {chr(10).join(lacunes)}
+            """
+
+        return f"""
+        === CONTEXTE COMPORTEMENTAL ===
+        SOFT SKILLS: {soft_skills}
+        {reco_txt}
+        {tech_context}
+        """
+
+    def _get_stratege_context(self, state: AgentState) -> str:
+        job = state["job_data"]
+        
+        # Add Behavioral Data
+        beh_data = state.get("behavioral_data")
+        beh_context = ""
+        if beh_data:
+            beh_context = f"""
+            === BILAN COMPORTEMENTAL ===
+            SCORE GLOBAL: {beh_data.score_comportemental_global}/5
+            POINTS À INTÉGRER: {", ".join(beh_data.points_a_integrer_mise_en_situation)}
+            """
+            
+        return f"""
+        === CONTEXTE SJT (MISE EN SITUATION) ===
+        MISSION: {job.get('mission', '')}
+        CULTURE/VALEURS: {job.get('profil_recherche', '')}
+        {beh_context}
+        """
+
+    def _get_projecteur_context(self, state: AgentState) -> str:
+        job = state["job_data"]
+        return f"""
+        === CONTEXTE PROJECTION ===
+        ENTREPRISE: {job.get('entreprise', '')}
+        DESCRIPTION POSTE: {job.get('description_poste', '')}
+        
+        NOTE: C'est la dernière question de l'entretien.
+        """
+
+    # --- Orchestrator (strict per-agent logic) ---
+    
+    def _orchestrator_node(self, state: AgentState):
+        messages = state["messages"]
+        user_msg_count = self._count_user_messages(messages)
+        
+        section, should_end = self._determine_section_and_status(user_msg_count)
+        
+        logger.info(f"Orchestrator: {user_msg_count} user messages -> section={section}, end={should_end}")
+        
+        context_updates = state.get("context", {}).copy()
+        next_dest = "end_interview" if should_end else section
+        context_updates["next_dest"] = next_dest
+        
+        # Trigger Extraction based on transitions
+        extract_target = None
+        if section == "auditeur" and not state.get("icebreaker_data"):
+            extract_target = "icebreaker"
+        elif section == "enqueteur" and not state.get("technical_data"):
+             extract_target = "technical"
+        elif section == "stratege" and not state.get("behavioral_data"):
+             extract_target = "behavioral"
+        elif section == "projecteur" and not state.get("situation_data"):
+             extract_target = "situation"
+             
+        # Check for Final Report extraction
+        if should_end:
+            # Check if we missed situation data (if flow ended abruptly?) - assuming linear flow for now.
+            # Only trigger if we haven't tried yet (flag in context)
+            if not state.get("situation_data") and not context_updates.get("situation_attempted"):
+                 extract_target = "situation"
+            elif not state.get("simulation_report") and not context_updates.get("report_attempted"):
+                 extract_target = "report"
+        
+        if extract_target:
+            context_updates["extract_target"] = extract_target
+            logger.info(f"Triggering extraction for: {extract_target}")
+        
+        return {"section": section, "context": context_updates}
+
+    def _extraction_node(self, state: AgentState):
+        target = state["context"].get("extract_target")
+        logger.info(f"Running extraction node for: {target}")
+        updates = {}
+        ctx = state["context"].copy()
+        
+        try:
+            if target == "icebreaker":
+                updates["icebreaker_data"] = self.extractor.extract_icebreaker(state["messages"], state["cv_data"])
+            elif target == "technical":
+                updates["technical_data"] = self.extractor.extract_technical(state["messages"], state["job_data"])
+            elif target == "behavioral":
+                updates["behavioral_data"] = self.extractor.extract_behavioral(state["messages"])
+            elif target == "situation":
+                updates["situation_data"] = self.extractor.extract_situation(state["messages"])
+            elif target == "report":
+                updates["simulation_report"] = self.extractor.extract_simulation_report(
+                    state["messages"],
+                    state.get("icebreaker_data"),
+                    state.get("technical_data"),
+                    state.get("behavioral_data"),
+                    state.get("situation_data")
+                )
+        except Exception as e:
+            logger.error(f"Extraction failed for {target}: {e}", exc_info=True)
+        
+        # Mark attempt to avoid infinite loops
+        if target == "situation":
+            ctx["situation_attempted"] = True
+        elif target == "report":
+            ctx["report_attempted"] = True
+        
+        # Clear extract_target safely
+        ctx.pop("extract_target", None)
+            
+        return {**updates, "context": ctx}
+
+    # --- Agent runner ---
+    
+    def _run_agent(self, state: AgentState, agent_key: str, context_str: str):
+        prompt_template = self.prompts[agent_key]
+        
+        # Extract first name
+        cv_info = state["cv_data"].get("info_personnelle", {})
+        prenom = cv_info.get("prenom", "")
+        
+        # Get question limit
+        nb_questions = QUESTIONS_PER_AGENT.get(agent_key, 2)
+
+        try:
+            instructions = prompt_template.format(
+                user_id=state["user_id"],
+                prenom=prenom,
+                nb_questions=nb_questions,
+                job_description=json.dumps(state["job_data"], ensure_ascii=False),
+                poste=state["job_data"].get("poste", "Poste non spécifié"),
+                entreprise=state["job_data"].get("entreprise", "Entreprise confidentielle")
+            )
+        except KeyError:
+            instructions = prompt_template
+        
+        system_msg = f"{instructions}\n\n{context_str}"
+        messages = [SystemMessage(content=system_msg)] + list(state["messages"])
+        response = self.llm.invoke(messages)
+        
+        return {"messages": [response]}
+
+    # --- Agent nodes ---
+    
+    def _icebreaker_node(self, s): return self._run_agent(s, "icebreaker", self._get_icebreaker_context(s))
+    def _auditeur_node(self, s): return self._run_agent(s, "auditeur", self._get_auditeur_context(s))
+    def _enqueteur_node(self, s): return self._run_agent(s, "enqueteur", self._get_enqueteur_context(s))
+    def _stratege_node(self, s): return self._run_agent(s, "stratege", self._get_stratege_context(s))
+    def _projecteur_node(self, s): return self._run_agent(s, "projecteur", self._get_projecteur_context(s))
+
+    # --- Final analysis ---
+    
+    def _final_analysis_node(self, state: AgentState):
+        """Trigger background analysis and return exit message."""
+        from src.tasks import run_analysis_task
+        
+        logger.info("=== FINAL ANALYSIS TRIGGERED ===")
+        
+        try:
+            hist = [{"role": ("user" if isinstance(m, HumanMessage) else "assistant"), "content": m.content} for m in state["messages"]]
+            
+            simulation_report_dict = None
+            if state.get("simulation_report"):
+                simulation_report_dict = state["simulation_report"].dict()
+            
+            run_analysis_task.delay(
+                user_id=state['user_id'],
+                job_offer_id=state['job_offer_id'],
+                job_description=json.dumps(state['job_data'], ensure_ascii=False),
+                conversation_history=hist,
+                cv_content=json.dumps(state['cv_data'], ensure_ascii=False),
+                cheat_metrics=state.get('cheat_metrics', {}),
+                simulation_report=simulation_report_dict
+            )
+            logger.info("Background analysis task enqueued via Celery")
+        except Exception as e:
+            logger.error(f"Failed to enqueue analysis task: {e}")
+        
+        # Generate contextual exit message
+        last_user_msg = state["messages"][-1].content if state["messages"] and isinstance(state["messages"][-1], HumanMessage) else ""
+        
+        if last_user_msg:
+            closing_prompt = (
+                f"Tu es un recruteur professionnel (RONI). L'entretien est terminé.\n"
+                f"Le candidat vient de dire : \"{last_user_msg}\"\n"
+                f"Réponds-y brièvement et aimablement (une phrase max). Si c'est une question, donnes-y une réponse simple.\n"
+                f"Ne dis PAS au revoir tout de suite, contente-toi de répondre au dernier point soulevé."
+            )
+            try:
+                ai_response = self.llm.invoke([SystemMessage(content=closing_prompt)])
+                # Force append the exit message to guarantee trigger detection
+                final_content = f"{ai_response.content}\n\n{EXIT_MESSAGE}"
+            except Exception as e:
+                logger.error(f"Error generating closing message: {e}")
+                final_content = EXIT_MESSAGE
+        else:
+            final_content = EXIT_MESSAGE
+
+        return {"messages": [AIMessage(content=final_content)], "context": {"next_dest": "end_interview"}}
+
+    # --- Routing ---
+    
+    def _route_next_step(self, state: AgentState) -> str:
+        # Check if extraction is needed
+        if state.get("context", {}).get("extract_target"):
+            return "extraction_node"
+            
+        dest = state.get("context", {}).get("next_dest", "icebreaker")
+        if dest == "end_interview":
+            # Ensure we have the report before finishing. Loop back to orchestrator.
+            # Only loop back if we haven't attempted to extract the report yet.
+            if not state.get("simulation_report") and not state.get("context", {}).get("report_attempted"):
+                 return "orchestrator"
+            return "final_analysis"
+        return f"{dest}_agent"
+
+    # --- Graph builder ---
+    
+    def _build_graph(self) -> any:
+        graph = StateGraph(AgentState)
+        
+        graph.add_node("orchestrator", self._orchestrator_node)
+        graph.add_node("extraction_node", self._extraction_node)  # Add extraction node
+        graph.add_node("icebreaker_agent", self._icebreaker_node)
+        graph.add_node("auditeur_agent", self._auditeur_node)
+        graph.add_node("enqueteur_agent", self._enqueteur_node)
+        graph.add_node("stratege_agent", self._stratege_node)
+        graph.add_node("projecteur_agent", self._projecteur_node)
+        graph.add_node("final_analysis", self._final_analysis_node)
+        
+        graph.set_entry_point("orchestrator")
+        
+        routing_map = {
+            "extraction_node": "extraction_node",
+            "icebreaker_agent": "icebreaker_agent",
+            "auditeur_agent": "auditeur_agent",
+            "enqueteur_agent": "enqueteur_agent",
+            "stratege_agent": "stratege_agent",
+            "projecteur_agent": "projecteur_agent",
+            "final_analysis": "final_analysis",
+            "orchestrator": "orchestrator"  # Added loopback
+        }
+        
+        graph.add_conditional_edges("orchestrator", self._route_next_step, routing_map)
+        graph.add_conditional_edges("extraction_node", self._route_next_step, routing_map)
+        
+        for node in ["icebreaker_agent", "auditeur_agent", "enqueteur_agent", "stratege_agent", "projecteur_agent", "final_analysis"]:
+            graph.add_edge(node, END)
+            
+        return graph.compile()
+
+    # --- Public API ---
+    
+    def invoke(self, messages: List[Dict[str, Any]], cheat_metrics: Dict[str, Any] = None):
+        langchain_messages = [HumanMessage(content=m["content"]) if m["role"] == "user" else AIMessage(content=m["content"]) for m in messages]
+        
+        if not langchain_messages:
+            langchain_messages.append(HumanMessage(content="Bonjour"))
+        
+        initial_state = {
+            "user_id": self.user_id,
+            "job_offer_id": self.job_offer_id,
+            "messages": langchain_messages,
+            "cv_data": self.cv_data,
+            "job_data": self.job_offer,
+            "section": "icebreaker",
+            "turn_count": 0,
+            "context": {},
+            "cheat_metrics": cheat_metrics or {}
+        }
+        
+        final_state = self.graph.invoke(initial_state)
+        
+        if not final_state or not final_state['messages']:
+            return {"response": "Erreur système.", "status": "finished"}
+            
+        last_msg = final_state['messages'][-1]
+        is_finished = final_state.get("context", {}).get("next_dest") == "end_interview"
+        status = "interview_finished" if is_finished else "interviewing"
+        
+        return {"response": last_msg.content, "status": status}

src/services/integrity_service.py

@@ -0,0 +1,67 @@
+import logging
+from src.services.nlp_service import NLPService
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+class IntegrityService:
+    def __init__(self):
+        self.nlp = NLPService()
+
+    def analyze_integrity(self, cv_text: str, interview_text: str, existing_metrics: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Combines stylometric analysis and AI detection to produce an integrity report.
+        """
+        logger.info("Starting Integrity Analysis...")
+        
+        # 1. AI Detection on Interview Transcript
+        interview_metrics = self.nlp.compute_all_metrics(interview_text)
+        
+        # 2. Stylometric Consistency (CV vs Interview)
+        # We only care about consistency if we have enough text
+        stylometric_flag = False
+        gap_details = ""
+        
+        if cv_text and len(cv_text) > 100:
+            cv_metrics = self.nlp.compute_all_metrics(cv_text)
+            
+            # Compare Readability (Flesch)
+            readability_gap = abs(interview_metrics["readability"] - cv_metrics["readability"])
+            if readability_gap > 30: # Huge gap in complexity
+                stylometric_flag = True
+                gap_details += f"Readability Gap ({readability_gap}); "
+                
+            # Compare Vocabulary Richness
+            ttr_gap = abs(interview_metrics["lexical_diversity"] - cv_metrics["lexical_diversity"])
+            if ttr_gap > 0.2:
+                stylometric_flag = True
+                gap_details += f"Vocab Gap ({ttr_gap}); "
+
+        # 3. Rules for Red Flags
+        ai_suspicion_score = 0
+        reasons = []
+
+        # Low Perplexity = AI
+        if interview_metrics["perplexity"] < 25: 
+            ai_suspicion_score += 40
+            reasons.append("Perplexity very low (Robotic)")
+        
+        # Low Burstiness = AI
+        if interview_metrics["burstiness"] < 0.2:
+            ai_suspicion_score += 30
+            reasons.append("Low Burstiness (Monotone)")
+            
+        # Stylometric Mismatch
+        if stylometric_flag:
+            ai_suspicion_score += 20
+            reasons.append(f"Style Mismatch with CV: {gap_details}")
+
+        final_score = min(100, ai_suspicion_score)
+        
+        return {
+            "ai_score": final_score,
+            "stylometry_mismatch": stylometric_flag,
+            "metrics": interview_metrics,
+            "reasons": reasons,
+            "raw_gap": gap_details
+        }

src/services/nlp_service.py

@@ -0,0 +1,132 @@
+import logging
+import math
+import numpy as np
+from textblob import TextBlob
+import textstat
+from transformers import GPT2LMHeadModel, GPT2TokenizerFast
+import torch
+import re
+
+logger = logging.getLogger(__name__)
+
+class NLPService:
+    _instance = None
+    _perplex_model = None
+    _perplex_tokenizer = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(NLPService, cls).__new__(cls)
+        return cls._instance
+
+    def _load_model(self):
+        """Lazy load the model to avoid huge startup time."""
+        if self._perplex_model is None:
+            logger.info("Loading NLP models (DistilGPT2)...")
+            try:
+                model_id = 'distilgpt2'
+                self._perplex_model = GPT2LMHeadModel.from_pretrained(model_id)
+                self._perplex_tokenizer = GPT2TokenizerFast.from_pretrained(model_id)
+                logger.info("NLP models loaded successfully.")
+            except Exception as e:
+                logger.error(f"Failed to load NLP models: {e}")
+                raise e
+
+    MAX_PERPLEXITY_CHARS = 50000
+
+    def calculate_perplexity(self, text: str) -> float:
+        """
+        Calculate perplexity of the text using a small GPT-2 model.
+        Lower perplexity = more likely to be generated by AI (or very standard human text).
+        """
+        if not text or len(text.strip()) < 10:
+            return 0.0
+
+        # Truncate to avoid memory overflow on very long inputs
+        if len(text) > self.MAX_PERPLEXITY_CHARS:
+            text = text[:self.MAX_PERPLEXITY_CHARS]
+
+        self._load_model()
+
+        encodings = self._perplex_tokenizer(text, return_tensors='pt')
+        max_length = self._perplex_model.config.n_positions
+        stride = 512
+        seq_len = encodings.input_ids.size(1)
+
+        nlls = []
+        prev_end_loc = 0
+        for begin_loc in range(0, seq_len, stride):
+            end_loc = min(begin_loc + max_length, seq_len)
+            trg_len = end_loc - prev_end_loc  # may be different from stride on last loop
+            input_ids = encodings.input_ids[:, begin_loc:end_loc]
+            target_ids = input_ids.clone()
+            target_ids[:, :-trg_len] = -100
+
+            with torch.no_grad():
+                outputs = self._perplex_model(input_ids, labels=target_ids)
+                neg_log_likelihood = outputs.loss
+
+            nlls.append(neg_log_likelihood)
+            prev_end_loc = end_loc
+            if end_loc == seq_len:
+                break
+
+        if not nlls:
+            return 0.0
+
+        ppl = torch.exp(torch.stack(nlls).mean())
+        return float(ppl)
+
+    def analyze_sentiment(self, text: str) -> dict:
+        """
+        Returns Polarity (-1 to 1) and Subjectivity (0 to 1).
+        """
+        blob = TextBlob(text)
+        return {
+            "polarity": round(blob.sentiment.polarity, 2),
+            "subjectivity": round(blob.sentiment.subjectivity, 2)
+        }
+
+    def calculate_lexical_diversity(self, text: str) -> float:
+        """
+        Type-Token Ratio (TTR).
+        Higher = richer vocabulary.
+        """
+        if not text:
+            return 0.0
+        
+        words = re.findall(r'\w+', text.lower())
+        if not words:
+            return 0.0
+        
+        unique_words = set(words)
+        return round(len(unique_words) / len(words), 3)
+
+    def calculate_burstiness(self, text: str) -> float:
+        """
+        Burstiness is usually defined by the variation in sentence length.
+        AI text tends to be more regular (low std dev), humans more chaotic.
+        """
+        blob = TextBlob(text)
+        sentences = blob.sentences
+        if not sentences or len(sentences) < 2:
+            return 0.0
+            
+        lengths = [len(s.words) for s in sentences]
+        std_dev = np.std(lengths)
+        mean = np.mean(lengths)
+        
+        # Coefficient of variation can be a proxy for burstiness
+        if mean == 0:
+            return 0.0
+            
+        return round(float(std_dev / mean), 3)
+
+    def compute_all_metrics(self, text: str) -> dict:
+        return {
+            "perplexity": self.calculate_perplexity(text),
+            "sentiment": self.analyze_sentiment(text),
+            "lexical_diversity": self.calculate_lexical_diversity(text),
+            "burstiness": self.calculate_burstiness(text),
+            "readability": textstat.flesch_reading_ease(text)
+        }

src/services/search_service.py

@@ -0,0 +1,117 @@
+import logging
+import re
+from typing import Dict, List, Any, Tuple
+from src.services.semantic_service import SemanticService
+
+logger = logging.getLogger(__name__)
+
+class SearchService:
+    """
+    Agent de Recherche (RAG & Grounding).
+    Responsable de l'analyse des écarts (Gap Analysis) et de la détection des profils (Reconversion).
+    """
+
+    JOB_TYPES = {
+        "DATA_ENGINEER": ["engineer", "ingénieur data", "mlops", "architecte", "platform"],
+        "DATA_SCIENTIST": ["scientist", "science", "nlp", "computer vision", "chercher", "research"],
+        "DATA_ANALYST": ["analyst", "analytics", "bi", "business intelligence", "dashboard"],
+    }
+    
+    VERB_MAPPINGS = {
+        "DATA_ENGINEER": [
+            "optimiser", "déployer", "industrialiser", "automatiser", "architecturer",
+            "monitorer", "scaler", "refactorer", "migrer", "contraindre"
+        ],
+        "DATA_SCIENTIST": [
+            "entraîner", "finetuner", "expérimenter", "évaluer", "modéliser",
+            "optimiser", "analyser", "comparer", "implémenter"
+        ],
+        "DATA_ANALYST": [
+            "visualiser", "présenter", "identifier", "extraire", "recommander",
+            "analyser", "synthétiser", "automatiser", "reporter"
+        ]
+    }
+    
+    # Fallback to general verbs if no type detected
+    DEFAULT_VERBS = VERB_MAPPINGS["DATA_ENGINEER"] + VERB_MAPPINGS["DATA_SCIENTIST"]
+
+    def __init__(self):
+        self.semantic_service = SemanticService()
+
+    def analyze_gap(self, cv_text: str, job_description: str) -> Dict[str, Any]:
+        """
+        Effectue une analyse des écarts entre le CV et l'offre.
+        Retourne un dictionnaire contenant les gaps, les verbes d'action, et le statut de reconversion.
+        """
+        logger.info("Starting Gap Analysis...")
+        
+        # 0. Job Type Detection
+        job_type = self._detect_job_type(job_description)
+        logger.info(f"Detected Job Type: {job_type}")
+        
+        # 1. Action Verbs Extraction (Dynamic based on Job Type)
+        target_verbs = self.VERB_MAPPINGS.get(job_type, self.DEFAULT_VERBS)
+        found_verbs = self._extract_action_verbs(cv_text, target_verbs)
+        
+        # Score normalized by a reasonable expectation (e.g. finding 3 distinct verbs is good)
+        production_score = min(1.0, len(found_verbs) / 4.0)
+        
+        # 2. Semantic Grounding
+        semantic_score = self.semantic_service.compute_similarity(cv_text, job_description)
+        
+        # 3. Reconversion Reporting
+        is_reconversion, reconversion_reason = self._detect_reconversion(cv_text, job_description)
+        
+        return {
+            "job_type": job_type,
+            "semantic_score": semantic_score,
+            "production_verbs_found": found_verbs,
+            "production_mindset_score": production_score,
+            "is_reconversion": is_reconversion,
+            "reconversion_reason": reconversion_reason,
+            "hidden_skill_gaps": "Analyse à compléter par LLM"
+        }
+
+    def _detect_job_type(self, job_desc: str) -> str:
+        """Détermine le type de poste (Engineer, Scientist, Analyst) d'après la description."""
+        text_lower = job_desc.lower()
+        
+        scores = {k: 0 for k in self.JOB_TYPES.keys()}
+        
+        for j_type, keywords in self.JOB_TYPES.items():
+            for kw in keywords:
+                if kw in text_lower:
+                    scores[j_type] += 1
+        
+        # Return key with max score, default to GENERAL if no matches or ties (logic simplified)
+        best_match = max(scores, key=scores.get)
+        if scores[best_match] == 0:
+            return "GENERAL_TECH"
+            
+        return best_match
+
+    def _extract_action_verbs(self, text: str, target_verbs: List[str]) -> List[str]:
+        """Extrait les verbes d'action clés présents dans le texte."""
+        text_lower = text.lower()
+        found = []
+        for verb in target_verbs:
+            # Simple word boundary check
+            if re.search(r'\b' + re.escape(verb) + r'\w*', text_lower):
+                found.append(verb)
+        return list(set(found))
+
+    def _detect_reconversion(self, cv_text: str, job_desc: str) -> Tuple[bool, str]:
+        """
+        Détecte si le candidat est en reconversion.
+        Logique simple: Mots clés 'formation', 'bootcamp', 'reconversion' + manque d'xp longue durée dans le domaine cible.
+        """
+        cv_lower = cv_text.lower()
+        
+        reconversion_keywords = ["reconversion", "bootcamp", "formation intensive", "rncp", "transition professionnelle"]
+        for kw in reconversion_keywords:
+            if kw in cv_lower:
+                return True, f"Mot-clé détecté : '{kw}'"
+        
+        # Note: A more robust check would involve parsing dates and titles, 
+        # but this simple heuristic allows flagging potential profiles for the Agents to confirm.
+        return False, "Parcours classique apparent"

src/services/semantic_service.py

@@ -0,0 +1,38 @@
+import logging
+from sentence_transformers import SentenceTransformer, util
+
+logger = logging.getLogger(__name__)
+
+class SemanticService:
+    _instance = None
+    _model = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(SemanticService, cls).__new__(cls)
+        return cls._instance
+
+    def _load_model(self):
+        if self._model is None:
+            logger.info("Loading Semantic model (all-MiniLM-L6-v2)...")
+            try:
+                self._model = SentenceTransformer('all-MiniLM-L6-v2')
+            except Exception as e:
+                logger.error(f"Failed to load Semantic model: {e}")
+                raise e
+
+    def compute_similarity(self, text1: str, text2: str) -> float:
+        """
+        Computes semantic similarity between two texts.
+        Returns a score between 0.0 and 1.0.
+        """
+        if not text1 or not text2:
+            return 0.0
+
+        self._load_model()
+        
+        embeddings1 = self._model.encode(text1, convert_to_tensor=True)
+        embeddings2 = self._model.encode(text2, convert_to_tensor=True)
+        
+        cosine_scores = util.cos_sim(embeddings1, embeddings2)
+        return float(cosine_scores[0][0])

src/services/simulation/agents.py

@@ -0,0 +1,185 @@
+import json
+import logging
+from typing import List, Dict, Any
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage, BaseMessage
+from src.services.simulation.schemas import (
+    IceBreakerOutput, TechnicalOutput, BehavioralOutput, SituationOutput, 
+    TechnicalSkillGap, ProjectTechUnderstanding, BehavioralCompetency, 
+    SimulationReport
+)
+from src.services.simulation.scoring import (
+    calculate_technical_gap_score, 
+    calculate_project_tech_understanding_score, 
+    calculate_behavioral_score, 
+    calculate_situation_score
+)
+
+logger = logging.getLogger(__name__)
+
+class InterviewAgentExtractor:
+    def __init__(self, llm: ChatOpenAI):
+        self.llm = llm
+
+    def _get_history_text(self, messages: List[BaseMessage]) -> str:
+        return "\n".join([f"{m.type.upper()}: {m.content}" for m in messages])
+
+    def extract_icebreaker(self, messages: List[BaseMessage], cv_data: Dict[str, Any]) -> IceBreakerOutput:
+        logger.info("Extracting Ice Breaker data...")
+        history = self._get_history_text(messages)
+        
+        prompt = f"""
+        Tu es un expert en analyse d'entretien. Analyse l'échange suivant (phase d'Ice Breaker) et extrais les informations structurées.
+        
+        CONTEXTE CANDIDAT:
+        {json.dumps(cv_data.get('info_personnelle', {}), ensure_ascii=False)}
+        {json.dumps(cv_data.get('reconversion', {}), ensure_ascii=False)}
+
+        HISTORIQUE ECHANGE:
+        {history}
+        
+        Tâche: Extraire le type de profil, l'expérience, la cohérence, la motivation, le contexte et les points à explorer.
+        """
+        
+        extractor = self.llm.with_structured_output(IceBreakerOutput)
+        return extractor.invoke([SystemMessage(content=prompt)])
+
+    def extract_technical(self, messages: List[BaseMessage], job_offer: Dict[str, Any]) -> TechnicalOutput:
+        logger.info("Extracting Technical data...")
+        history = self._get_history_text(messages)
+        
+        prompt = f"""
+        Tu es un expert technique. Analyse l'échange suivant (phase Technique) et extrais les compétences validées, les lacunes et la compréhension des technos.
+        
+        OFFRE:
+        {json.dumps(job_offer, ensure_ascii=False)}
+
+        HISTORIQUE ECHANGE:
+        {history}
+        
+        Tâche: Remplir la grille d'évaluation technique. Pour les indicateurs binaires, sois strict : true seulement si le candidat l'a explicitement démontré.
+        """
+        
+        extractor = self.llm.with_structured_output(TechnicalOutput)
+        data = extractor.invoke([SystemMessage(content=prompt)])
+        
+        # Calculate scores - normalize all to 0-5 scale
+        scores = []
+        for gap in data.lacunes_explorees:
+            gap.niveau_detecte = calculate_technical_gap_score(gap.indicateurs)
+            normalized = (gap.niveau_detecte / 4.0) * 5.0  # 0-4 -> 0-5
+            scores.append(normalized)
+
+        for tech in data.comprehension_technos_projets:
+            tech.score = calculate_project_tech_understanding_score(tech.indicateurs)
+            scores.append(float(tech.score))  # already 1-5
+
+        for val in data.competences_validees:
+            scores.append(float(val.score))  # already 1-5
+
+        if scores:
+            data.score_technique_global = round(sum(scores) / len(scores), 1)
+        else:
+            data.score_technique_global = 0.0
+            
+        return data
+
+    def extract_behavioral(self, messages: List[BaseMessage]) -> BehavioralOutput:
+        logger.info("Extracting Behavioral data...")
+        history = self._get_history_text(messages)
+        
+        prompt = f"""
+        Tu es un expert RH. Analyse l'échange suivant (phase Comportementale) et extrais l'évaluation des compétences.
+        
+        HISTORIQUE ECHANGE:
+        {history}
+        
+        Tâche: Evaluer chaque compétence comportementale abordée via la méthode STAR.
+        """
+        
+        extractor = self.llm.with_structured_output(BehavioralOutput)
+        data = extractor.invoke([SystemMessage(content=prompt)])
+        
+        # Calculate scores
+        scores = []
+        for comp in data.competences_evaluees:
+            comp.score = calculate_behavioral_score(comp.competence, comp.indicateurs)
+            scores.append(comp.score)
+
+        for sjt in data.sjt_results:
+            if sjt.score_choix is not None and sjt.justification_score is not None:
+                sjt.score_sjt = round((sjt.score_choix * 0.6) + (sjt.justification_score * 0.4), 1)
+            scores.append(sjt.score_sjt)
+             
+        if scores:
+            data.score_comportemental_global = round(sum(scores) / len(scores), 1)
+        else:
+             data.score_comportemental_global = 0.0
+             
+        return data
+
+    def extract_situation(self, messages: List[BaseMessage]) -> SituationOutput:
+        logger.info("Extracting Situation data...")
+        history = self._get_history_text(messages)
+        
+        prompt = f"""
+        Tu es un expert technique. Analyse l'échange suivant (phase Mise en Situation) et évalue la performance du candidat.
+        
+        HISTORIQUE ECHANGE:
+        {history}
+        
+        Tâche: Remplir la grille d'évaluation de la mise en situation.
+        """
+        
+        extractor = self.llm.with_structured_output(SituationOutput)
+        data = extractor.invoke([SystemMessage(content=prompt)])
+        
+        # Calculate score
+        data.score_mise_en_situation = calculate_situation_score(data.indicateurs)
+        
+        return data
+
+    def extract_simulation_report(self, 
+                                  messages: List[BaseMessage], 
+                                  icebreaker: IceBreakerOutput,
+                                  technical: TechnicalOutput,
+                                  behavioral: BehavioralOutput,
+                                  situation: SituationOutput) -> SimulationReport:
+        logger.info("Generating Final Simulation Report...")
+        
+        # We don't necessarily need the whole history if we have structured data, 
+        # but the LLM might need it for "Synthese". 
+        # Let's provide a summary of structured data to save tokens.
+        
+        context_data = {
+            "icebreaker": icebreaker.dict() if icebreaker else {},
+            "technical": technical.dict() if technical else {},
+            "behavioral": behavioral.dict() if behavioral else {},
+            "situation": situation.dict() if situation else {}
+        }
+        
+        prompt = f"""
+        Tu es un Expert Recruteur Senior. Rédige le rapport final de l'entretien basé sur les données extraites.
+        
+        DONNÉES STRUCTURÉES (SCORES & INDICATEURS):
+        {json.dumps(context_data, ensure_ascii=False)}
+        
+        Tâche:
+        1. Calcule le score global (Moyenne pondérée : Technique 40%, Comportemental 30%, Situation 20%, Icebreaker/Soft 10% - ou use ton jugement expert).
+        2. Rédige une synthèse du candidat (2-3 phrases).
+        3. Liste les points forts et faibles.
+        4. Donne une recommandation claire (GO/NO GO).
+        5. Rédige un feedback pour le candidat (bienveillant et constructif).
+        """
+        
+        extractor = self.llm.with_structured_output(SimulationReport)
+        report = extractor.invoke([SystemMessage(content=prompt)])
+        
+        # Inject the source objects back into the report (optional, as they are part of the model but null in extraction input)
+        # Actually LLM might return them null or empty. We should re-attach the real objects.
+        report.icebreaker = icebreaker
+        report.technical = technical
+        report.behavioral = behavioral
+        report.situation = situation
+        
+        return report

src/services/simulation/schemas.py

@@ -0,0 +1,87 @@
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+# --- Ice Breaker Agent ---
+
+class IceBreakerOutput(BaseModel):
+    profil_type: str = Field(..., description="Type de profil (reconversion, étudiant, junior, expérimenté)")
+    annees_experience_domaine: str = Field(..., description="Années d'expérience dans le domaine cible (0-2, 2-5, 5+)")
+    coherence_parcours: str = Field(..., description="Cohérence parcours -> poste visé (forte, moyenne, faible)")
+    motivation_detectee: bool = Field(..., description="Motivation exprimée")
+    contexte_specifique: str = Field(..., description="Contexte spécifique du candidat")
+    points_a_explorer: List[str] = Field(default_factory=list, description="Points à explorer dans la suite")
+
+# --- Technical Agent ---
+
+class TechnicalSkillGap(BaseModel):
+    skill: str
+    niveau_detecte: int = Field(..., description="Niveau détecté (0-4)")
+    indicateurs: Dict[str, bool] = Field(..., description="Indicateurs binaires (concept_sous_jacent, experience_liee, outil_adjacent, cas_usage, strategie_montee)")
+    transferabilite: str = Field(..., description="Transférabilité (faible, moyenne, forte)")
+    questions_posees: List[str] = Field(default_factory=list)
+
+class ProjectTechUnderstanding(BaseModel):
+    skill: str
+    source_projet: str
+    score: int = Field(..., description="Score (1-5)")
+    indicateurs: Dict[str, bool] = Field(..., description="Indicateurs binaires (justifie_choix, fonctionnement_interne, identifie_limites, propose_alternatives, quantifie_resultats, resolution_probleme)")
+    questions_posees: List[str] = Field(default_factory=list)
+
+class ValidatedSkill(BaseModel):
+    skill: str
+    score: int
+    source: str
+
+class TechnicalOutput(BaseModel):
+    competences_validees: List[ValidatedSkill] = Field(default_factory=list)
+    lacunes_explorees: List[TechnicalSkillGap] = Field(default_factory=list)
+    comprehension_technos_projets: List[ProjectTechUnderstanding] = Field(default_factory=list)
+    score_technique_global: float = Field(..., description="Score technique global calculé")
+    points_a_explorer_comportemental: List[str] = Field(default_factory=list)
+
+# --- Behavioral Agent ---
+
+class BehavioralCompetency(BaseModel):
+    competence: str
+    score: int = Field(..., description="Score (1-5)")
+    indicateurs: Dict[str, bool] = Field(..., description="Indicateurs binaires spécifiques à la compétence")
+    questions_posees: List[str] = Field(default_factory=list)
+
+class SJTResult(BaseModel):
+    scenario_id: str
+    choix: str
+    score_choix: float
+    justification_score: float
+    score_sjt: float
+
+class BehavioralOutput(BaseModel):
+    competences_evaluees: List[BehavioralCompetency] = Field(default_factory=list)
+    sjt_results: List[SJTResult] = Field(default_factory=list)
+    score_comportemental_global: float = Field(..., description="Score comportemental global calculé")
+    signaux_forts: List[str] = Field(default_factory=list)
+    signaux_faibles: List[str] = Field(default_factory=list)
+    points_a_integrer_mise_en_situation: List[str] = Field(default_factory=list)
+
+# --- Situation Agent ---
+
+class SituationOutput(BaseModel):
+    scenario_utilise: str
+    score_mise_en_situation: int = Field(..., description="Score sur 5")
+    indicateurs: Dict[str, bool] = Field(..., description="Indicateurs (comprehension_probleme, demarche_structuree, pertinence_technique, gestion_contraintes, communication_solution, identification_risques, proposition_alternatives)")
+    questions_posees: List[str] = Field(default_factory=list)
+    observations: str
+
+# --- Full Report ---
+
+class SimulationReport(BaseModel):
+    icebreaker: Optional[IceBreakerOutput] = None
+    technical: Optional[TechnicalOutput] = None
+    behavioral: Optional[BehavioralOutput] = None
+    situation: Optional[SituationOutput] = None
+    
+    score_global: float = Field(..., description="Score global de l'entretien sur 5")
+    synthese_candidat: str = Field(..., description="Synthèse textuelle du profil")
+    points_forts: List[str] = Field(default_factory=list, description="Top 3 points forts")
+    points_faibles: List[str] = Field(default_factory=list, description="Top 3 points faibles")
+    recommandation: str = Field(..., description="GO / NO GO / A CREUSER")
+    feedback_candidat: str = Field(..., description="Feedback constructif adressé au candidat")

src/services/simulation/scoring.py

@@ -0,0 +1,167 @@
+from typing import Dict
+
+def calculate_technical_gap_score(indicators: Dict[str, bool]) -> int:
+    """
+    Calcule le niveau (0-4) pour une lacune technique basée sur les indicateurs binaires.
+    
+    Poids:
+    - concept_sous_jacent: 2
+    - experience_liee: 1
+    - outil_adjacent: 1
+    - cas_usage: 1
+    - strategie_montee: 1
+    
+    Mapping:
+    - 0 pts -> Niveau 0
+    - 1-2 pts -> Niveau 1
+    - 3 pts -> Niveau 2
+    - 4 pts -> Niveau 3
+    - 5-6 pts -> Niveau 4
+    """
+    weights = {
+        "concept_sous_jacent": 2,
+        "experience_liee": 1,
+        "outil_adjacent": 1,
+        "cas_usage": 1,
+        "strategie_montee": 1
+    }
+    
+    score = sum(weights.get(k, 0) for k, v in indicators.items() if v)
+
+    if score == 0: return 0
+    if score <= 2: return 1
+    if score == 3: return 2
+    if score == 4: return 3
+    return 4
+
+def calculate_project_tech_understanding_score(indicators: Dict[str, bool]) -> int:
+    """
+    Calcule le score (1-5) pour la compréhension d'une technologie projet.
+    
+    Poids:
+    - justifie_choix: 1
+    - fonctionnement_interne: 3
+    - identifie_limites: 2
+    - propose_alternatives: 2
+    - quantifie_resultats: 1
+    - resolution_probleme: 2
+    
+    Total max: 11
+    
+    Mapping:
+    - 0-2 -> 1/5 (usage superficiel)
+    - 3-4 -> 2/5 (usage fonctionnel)
+    - 5-6 -> 3/5 (compréhension partielle)
+    - 7-9 -> 4/5 (bonne compréhension)
+    - 10-11 -> 5/5 (maîtrise démontrée)
+    """
+    weights = {
+        "justifie_choix": 1,
+        "fonctionnement_interne": 3,
+        "identifie_limites": 2,
+        "propose_alternatives": 2,
+        "quantifie_resultats": 1,
+        "resolution_probleme": 2
+    }
+    
+    score = sum(weights.get(k, 0) for k, v in indicators.items() if v)
+
+    if score <= 2: return 1
+    if score <= 4: return 2
+    if score <= 6: return 3
+    if score <= 9: return 4
+    return 5
+
+def calculate_behavioral_score(competence: str, indicators: Dict[str, bool]) -> int:
+    """
+    Calcule le score (1-5) pour une compétence comportementale.
+    Utilise une pondération spécifique par compétence si définie, sinon une générique.
+    Mapping proportionnel au max possible.
+    """
+    # Exemples de poids par défaut si non spécifiés dans le code appelant
+    # Ici on suppose que les indicateurs passés correspondent à ceux attendus pour la compétence
+    # On va utiliser une heuristique simple: 1 point par indicateur si pas de poids spécifique,
+    # ou on code en dur les poids des exemples connus.
+    
+    # Poids par défaut pour les exemples connus
+    weights_map = {
+        "Adaptabilité": {
+            "situation_changement": 2,
+            "actions_concretes": 2,
+            "apprentissage_ajustement": 2,
+            "resultat_quantifie": 1,
+            "limites_reconnues": 1,
+            "transfert_competence": 2
+        },
+        "Apprentissage autonome": {
+            "demarche_auto_formation": 2, # Mapping approximatif des clés JSON
+            "ressources_specifiques": 1,
+            "progression_mesurable": 2,
+            "application_concrete": 2,
+            "identifie_reste_a_apprendre": 1
+        }
+    }
+
+    # Si la compétence est connue, on utilise ses poids, sinon 1.
+    competence_weights = weights_map.get(competence, {})
+    
+    total_score = 0
+    max_score = 0
+    
+    for key, val in indicators.items():
+        weight = competence_weights.get(key, 1) # Default weight 1 if unknown key
+        if val:
+            total_score += weight
+        max_score += weight
+        
+    if max_score == 0:
+        return 3  # Score neutre si aucun indicateur defini
+
+    ratio = total_score / max_score
+    
+    # Mapping linéaire approximatif vers 1-5
+    if ratio <= 0.2: return 1
+    if ratio <= 0.4: return 2
+    if ratio <= 0.6: return 3
+    if ratio <= 0.8: return 4
+    return 5
+
+def calculate_situation_score(indicators: Dict[str, bool]) -> int:
+    """
+    Calcule le score (1-5) pour la mise en situation.
+    
+    Poids:
+    - comprehension_probleme: 2
+    - demarche_structuree: 3
+    - pertinence_technique: 3
+    - gestion_contraintes: 2
+    - communication_solution: 1
+    - identification_risques: 2
+    - proposition_alternatives: 1
+    
+    Total max: 14
+    
+    Mapping:
+    - 0-3 -> 1/5
+    - 4-6 -> 2/5
+    - 7-9 -> 3/5
+    - 10-12 -> 4/5
+    - 13-14 -> 5/5
+    """
+    weights = {
+        "comprehension_probleme": 2,
+        "demarche_structuree": 3,
+        "pertinence_technique": 3,
+        "gestion_contraintes": 2,
+        "communication_solution": 1,
+        "identification_risques": 2,
+        "proposition_alternatives": 1
+    }
+    
+    score = sum(weights.get(k, 0) for k, v in indicators.items() if v)
+    
+    if score <= 3: return 1
+    if score <= 6: return 2
+    if score <= 9: return 3
+    if score <= 12: return 4
+    return 5

src/tasks.py

@@ -0,0 +1,27 @@
+from src.celery_app import celery_app
+from src.tools.analysis_tools import trigger_interview_analysis
+import logging
+
+logger = logging.getLogger(__name__)
+
+@celery_app.task(bind=True, max_retries=3, default_retry_delay=30)
+def run_analysis_task(self, user_id, job_offer_id, job_description, conversation_history, cv_content, cheat_metrics=None, simulation_report=None):
+    """
+    Background task to run the feedback analysis.
+    """
+    logger.info(f"Starting background analysis for job {job_offer_id}")
+    try:
+        result = trigger_interview_analysis.invoke({
+            "user_id": user_id,
+            "job_offer_id": job_offer_id,
+            "job_description": job_description,
+            "conversation_history": conversation_history,
+            "cv_content": cv_content,
+            "cheat_metrics": cheat_metrics or {},
+            "simulation_report": simulation_report
+        })
+        logger.info("Background analysis completed successfully")
+        return result
+    except Exception as e:
+        logger.error(f"Background analysis failed (attempt {self.request.retries + 1}): {e}")
+        raise self.retry(exc=e)

src/tools/analysis_tools.py

@@ -0,0 +1,62 @@
+import logging
+from langchain_core.tools import tool
+from src.services.analysis_service import AnalysisService
+import json
+import os
+from datetime import datetime
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
+import httpx
+
+logger = logging.getLogger(__name__)
+
+BACKEND_API_URL = os.getenv("BACKEND_API_URL", "http://localhost:8000")
+
+class InterviewAnalysisArgs(BaseModel):
+    """Arguments for the trigger_interview_analysis tool."""
+    user_id: str = Field(..., description="The unique identifier for the user.")
+    job_offer_id: str = Field(..., description="The unique identifier for the job offer.")
+    job_description: str = Field(..., description="The full JSON string of the job offer description.")
+    conversation_history: List[Dict[str, Any]] = Field(..., description="The complete conversation history between the user and the agent.")
+    cv_content: str = Field(..., description="The content of the candidate's CV (JSON string or text).")
+    cheat_metrics: Optional[Dict[str, Any]] = Field(default=None, description="Metrics related to copy-paste behavior.")
+    simulation_report: Optional[Dict[str, Any]] = Field(default=None, description="Pre-computed structured simulation report.")
+
+@tool("trigger_interview_analysis", args_schema=InterviewAnalysisArgs)
+def trigger_interview_analysis(user_id: str, job_offer_id: str, job_description: str, conversation_history: List[Dict[str, Any]], cv_content: str, cheat_metrics: Dict[str, Any] = None, simulation_report: Dict[str, Any] = None):
+    """
+    Call this tool to end the interview and launch the final analysis.
+    Arguments: user_id, job_offer_id, job_description, conversation_history, cv_content.
+    """
+    try:
+        logger.info(f"Tool 'trigger_interview_analysis' called for user_id: {user_id}")
+        
+        analysis_service = AnalysisService() 
+        
+        feedback_data = analysis_service.run_analysis(
+            conversation_history=conversation_history,
+            job_description=job_description,
+            cv_content=cv_content,
+            cheat_metrics=cheat_metrics,
+            simulation_report=simulation_report
+        )
+        
+        feedback_payload = {
+            "user_id": user_id,
+            "interview_id": job_offer_id, 
+            "feedback_content": feedback_data,
+            "feedback_date": datetime.utcnow().isoformat()
+        }
+        
+        try:
+            response = httpx.post(f"{BACKEND_API_URL}/api/v1/feedback/", json=feedback_payload, timeout=30.0)
+            response.raise_for_status()
+            logger.info("Feedback saved to Backend API successfully.")
+        except Exception as api_err:
+            logger.error(f"Failed to save feedback to API: {api_err}")
+        
+        return "Analysis triggered and completed successfully."
+
+    except Exception as e:
+        logger.error(f"Error in analysis tool: {e}", exc_info=True)
+        return "An error occurred while launching the analysis."

tests/test_search_service.py

@@ -0,0 +1,56 @@
+
+import pytest
+from src.services.search_service import SearchService
+
+class TestSearchService:
+    def setup_method(self):
+        self.service = SearchService()
+
+    def test_detect_job_type(self):
+        assert self.service._detect_job_type("Cherche Senior Data Scientist NLP") == "DATA_SCIENTIST"
+        assert self.service._detect_job_type("Offre Data Analyst PowerBI") == "DATA_ANALYST"
+        assert self.service._detect_job_type("Besoin d'un ML Engineer pour la prod") == "DATA_ENGINEER"
+        assert self.service._detect_job_type("Développeur Python Backend") == "GENERAL_TECH"
+
+    def test_extract_action_verbs_found(self):
+        text = "J'ai pu optimiser les performances et déployer le modèle en production."
+        verbs = self.service._extract_action_verbs(text, self.service.VERB_MAPPINGS["DATA_ENGINEER"])
+        assert "optimiser" in verbs
+        assert "déployer" in verbs
+        assert len(verbs) >= 2
+
+    def test_extract_action_verbs_analyst(self):
+        text = "J'ai réalisé des visualisations et présenté des insights."
+        verbs = self.service._extract_action_verbs(text, self.service.VERB_MAPPINGS["DATA_ANALYST"])
+        assert "visualiser" in verbs or "présenter" in verbs
+
+    def test_extract_action_verbs_none(self):
+        text = "J'ai fait de la gestion de projet et de la rédaction."
+        verbs = self.service._extract_action_verbs(text, self.service.VERB_MAPPINGS["DATA_ENGINEER"])
+        assert len(verbs) == 0
+
+    def test_detect_reconversion_true(self):
+        cv_text = "Après un bootcamp intensif en Data Science, je cherche..."
+        job_desc = "Cherche Data Scientist junior."
+        is_reconversion, reason = self.service._detect_reconversion(cv_text, job_desc)
+        assert is_reconversion is True
+        assert "bootcamp" in reason
+
+    def test_detect_reconversion_false(self):
+        cv_text = "Ingénieur diplomé avec 5 ans d'expérience."
+        job_desc = "Cherche Senior Dev."
+        is_reconversion, reason = self.service._detect_reconversion(cv_text, job_desc)
+        assert is_reconversion is False
+        assert "Parcours classique" in reason
+
+    def test_analyze_gap_structure(self):
+        cv_text = "Développeur Python avec expérience en optimiser et monitorer."
+        job_desc = "Cherche expert Python pour optimiser le backend."
+        
+        result = self.service.analyze_gap(cv_text, job_desc)
+        
+        assert "semantic_score" in result
+        assert "production_mindset_score" in result
+        assert "is_reconversion" in result
+        assert "production_verbs_found" in result
+        assert "optimiser" in result["production_verbs_found"]

tests/test_simulation_flow.py

@@ -0,0 +1,108 @@
+import os
+import sys
+import json
+import logging
+from dotenv import load_dotenv
+
+# Add src to path
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+from src.services.graph_service import GraphInterviewProcessor
+
+# Force re-configuration of logging
+for handler in logging.root.handlers[:]:
+    logging.root.removeHandler(handler)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    filename='simulation_test.log',
+    filemode='w'
+)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+# Mock data
+USER_ID = "test_user"
+JOB_OFFER_ID = "test_job"
+CV_DATA = {
+    "candidat": {
+        "info_personnelle": {"nom": "Doe", "prenom": "John"},
+        "reconversion": {"is_reconversion": False},
+        "etudiant": {
+            "is_etudiant": True, 
+            "niveau_etudes": "Master 2",
+            "specialite": "IA",
+            "latest_education_end_date": "2025"
+        },
+        "expériences": [{"poste": "Dev", "entreprise": "TestCorp", "durée": "2 ans"}],
+        "compétences": {
+            "hard_skills": ["Python", "Docker"],
+            "soft_skills": ["Curiosité"],
+            "skills_with_context": [
+                {"skill": "Python", "context": "Projet académique"},
+                {"skill": "Docker", "context": "Stage"}
+            ]
+        },
+        "projets": {
+            "professional": [
+                {
+                    "title": "Projet A",
+                    "technologies": ["Python", "Flask"],
+                    "outcomes": ["API déployée", "User base +10%"]
+                }
+            ],
+            "personal": []
+        },
+        "centres_interet": ["Football", "Voyage"]
+    }
+}
+JOB_OFFER = {
+    "poste": "Backend Developer",
+    "entreprise": "AIRH",
+    "mission": "Develop API",
+    "profil_recherche": "Passionné",
+    "competences": "Python, FastAPI"
+}
+
+PAYLOAD = {
+    "user_id": USER_ID,
+    "job_offer_id": JOB_OFFER_ID,
+    "cv_document": CV_DATA,
+    "job_offer": JOB_OFFER,
+    "messages": []
+}
+
+def run_simulation_start():
+    logger.info("Initializing Processor for START SCENARIO...")
+    processor = GraphInterviewProcessor(PAYLOAD)
+    
+    # 0 messages -> Should trigger IceBreaker first message
+    output = processor.invoke([])
+    logger.info(f"\n=== START OF INTERVIEW ===")
+    logger.info(f"Agent Response: {output['response']}")
+    logger.info(f"Status: {output['status']}")
+
+def run_simulation_end():
+    logger.info("Initializing Processor for END SCENARIO...")
+    processor = GraphInterviewProcessor(PAYLOAD)
+    
+    # Simulate a history with 10 user messages (Completed flow)
+    # The Orchestrator counts only HUMAN messages.
+    conversation = []
+    for i in range(10):
+        conversation.append({"role": "user", "content": f"Response {i+1}"})
+        conversation.append({"role": "assistant", "content": f"Question {i+2}"})
+    
+    logger.info(f"\n=== TRIGGERING END OF INTERVIEW (10 User Messages) ===")
+    output = processor.invoke(conversation)
+    logger.info(f"Final Agent Response: {output['response'][:100]}...")
+    logger.info(f"Final Status: {output['status']}")
+
+if __name__ == "__main__":
+    try:
+        run_simulation_start()
+        # run_simulation_end()
+    except Exception as e:
+        logger.error(f"Simulation failed: {e}", exc_info=True)

tools/analysis_tools.py

@@ -0,0 +1,60 @@
+import logging
+from langchain_core.tools import tool
+from src.services.analysis_service import AnalysisService
+import json
+import os
+from datetime import datetime
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any
+import httpx
+
+logger = logging.getLogger(__name__)
+
+BACKEND_API_URL = os.getenv("BACKEND_API_URL", "http://localhost:8000")
+
+class InterviewAnalysisArgs(BaseModel):
+    """Arguments for the trigger_interview_analysis tool."""
+    user_id: str = Field(..., description="The unique identifier for the user.")
+    job_offer_id: str = Field(..., description="The unique identifier for the job offer.")
+    job_description: str = Field(..., description="The full JSON string of the job offer description.")
+    conversation_history: List[Dict[str, Any]] = Field(..., description="The complete conversation history between the user and the agent.")
+    cv_content: str = Field(..., description="The content of the candidate's CV (JSON string or text).")
+    cheat_metrics: Dict[str, Any] = Field(None, description="Metrics related to copy-paste behavior.")
+
+@tool("trigger_interview_analysis", args_schema=InterviewAnalysisArgs)
+def trigger_interview_analysis(user_id: str, job_offer_id: str, job_description: str, conversation_history: List[Dict[str, Any]], cv_content: str, cheat_metrics: Dict[str, Any] = None):
+    """
+    Call this tool to end the interview and launch the final analysis.
+    Arguments: user_id, job_offer_id, job_description, conversation_history, cv_content.
+    """
+    try:
+        logger.info(f"Tool 'trigger_interview_analysis' called for user_id: {user_id}")
+        
+        analysis_service = AnalysisService() 
+        
+        feedback_data = analysis_service.run_analysis(
+            conversation_history=conversation_history,
+            job_description=job_description,
+            cv_content=cv_content,
+            cheat_metrics=cheat_metrics
+        )
+        
+        feedback_payload = {
+            "user_id": user_id,
+            "interview_id": job_offer_id, 
+            "feedback_content": feedback_data,
+            "feedback_date": datetime.utcnow().isoformat()
+        }
+        
+        try:
+            response = httpx.post(f"{BACKEND_API_URL}/api/v1/feedback/", json=feedback_payload, timeout=30.0)
+            response.raise_for_status()
+            logger.info("Feedback saved to Backend API successfully.")
+        except Exception as api_err:
+            logger.error(f"Failed to save feedback to API: {api_err}")
+        
+        return "Analysis triggered and completed successfully."
+
+    except Exception as e:
+        logger.error(f"Error in analysis tool: {e}", exc_info=True)
+        return "An error occurred while launching the analysis."