ai_interview

Dockerfile

@@ -1,39 +1,44 @@
 FROM python:3.11-slim
 
+# Variables d'environnement
 ENV PYTHONUNBUFFERED=1 \
     PYTHONDONTWRITEBYTECODE=1 \
     PIP_NO_CACHE_DIR=1 \
     PIP_DISABLE_PIP_VERSION_CHECK=1 \
-    PYTHONPATH=/app \
-    HOME=/app \
-    HF_HOME=/tmp/cache \
+    PYTHONPATH=/app
+
+# Variables pour les modèles ML - utilisation de /tmp (toujours writable)
+ENV HF_HOME=/tmp/cache \
     TRANSFORMERS_CACHE=/tmp/cache \
     HF_HUB_CACHE=/tmp/cache/hub \
-    SENTENCE_TRANSFORMERS_HOME=/tmp/cache/sentence_transformers \
-    XDG_DATA_HOME="/app/.local/share" \
-    CREWAI_TELEMETRY_OPT_OUT=true
+    SENTENCE_TRANSFORMERS_HOME=/tmp/cache/sentence_transformers
 
+# Répertoire de travail
 WORKDIR /app
 
+# Installer les dépendances système
 RUN apt-get update && apt-get install -y \
     curl \
     && rm -rf /var/lib/apt/lists/*
 
+# Installer uv
 RUN pip install uv
 
+# Copier et installer les dépendances Python
 COPY requirements.txt .
 RUN uv pip install --system --no-cache -r requirements.txt
 
+# Copier le code source
 COPY . .
 
+# Créer les répertoires de cache dans /tmp (toujours writable)
 RUN mkdir -p /tmp/cache/hub \
              /tmp/cache/sentence_transformers \
-             /tmp/vector_store \
-             /app/.local/share/crewai \
-             /app/.chroma
-
-
-RUN chmod -R 777 /tmp /app
+             /tmp/vector_store && \
+    chmod -R 777 /tmp
 
+# Exposer le port HF Spaces
 EXPOSE 7860
+
+# Commande de démarrage
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -1,27 +1,56 @@
+import tempfile
+import requests
 import os
 import logging
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.concurrency import run_in_threadpool
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-
-from src.services.graph_service import GraphInterviewProcessor
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
+os.environ['HOME'] = '/tmp'
+# Configuration du logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-from langtrace_python_sdk import langtrace
+# Imports avec gestion d'erreurs robuste
+try:
+    from src.cv_parsing_agents import CvParserAgent, create_fallback_cv_data
+    CV_PARSING_AVAILABLE = True
+    logger.info("✅ CV Parsing disponible")
+except Exception as e:
+    logger.error(f"❌ CV Parsing indisponible: {e}")
+    CV_PARSING_AVAILABLE = False
+    CvParserAgent = None
+    create_fallback_cv_data = None
 
-langtrace.init(api_key=os.getenv("LANGTRACE_API_KEY"))
+try:
+    from src.interview_simulator.entretient_version_prod import InterviewProcessor
+    INTERVIEW_AVAILABLE = True
+    logger.info("✅ Interview Simulator disponible")
+except Exception as e:
+    logger.error(f"❌ Interview Simulator indisponible: {e}")
+    INTERVIEW_AVAILABLE = False
+    InterviewProcessor = None
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+try:
+    from src.scoring_engine import ContextualScoringEngine
+    SCORING_AVAILABLE = True
+    logger.info("✅ Scoring Engine disponible")
+except Exception as e:
+    logger.error(f"❌ Scoring Engine indisponible: {e}")
+    SCORING_AVAILABLE = False
+    ContextualScoringEngine = None
 
+# Application FastAPI
 app = FastAPI(
-    title="Interview Simulation API",
-    description="API for interview simulations.",
-    version="1.0.0",
+    title="AIrh Interview Assistant",
+    description="API pour l'analyse de CV et la simulation d'entretiens d'embauche",
+    version="1.3.0",
     docs_url="/docs",
     redoc_url="/redoc"
 )
 
+# Configuration CORS pour HF Spaces
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -30,44 +59,212 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Configuration API Celery
+CELERY_API_URL = os.getenv("CELERY_API_URL", "https://celery-7as1.onrender.com")
+
+# Modèles Pydantic
+class InterviewRequest(BaseModel):
+    user_id: str = Field(..., example="user_12345")
+    job_offer_id: str = Field(..., example="job_offer_abcde")
+    cv_document: Dict[str, Any]
+    job_offer: Dict[str, Any]
+    messages: List[Dict[str, Any]]
+    conversation_history: List[Dict[str, Any]]
+
+class AnalysisRequest(BaseModel):
+    conversation_history: List[Dict[str, Any]]
+    job_description_text: str
+    candidate_id: Optional[str] = None
+
+class TaskResponse(BaseModel):
+    task_id: str
+    status: str
+    result: Any = None
+    message: Optional[str] = None
+
 class HealthCheck(BaseModel):
     status: str = "ok"
+    celery_api_status: Optional[str] = None
+    services: Dict[str, bool] = Field(default_factory=dict)
+    message: str = "API AIrh fonctionnelle"
 
+# Endpoints
 @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.
-    """
-    logger = logging.getLogger(__name__)
+    """Health check de l'API avec test de connectivité Celery."""
+    
+    # Test connexion Celery
+    celery_status = "unknown"
     try:
-        payload = await request.json()
+        response = requests.get(f"{CELERY_API_URL}/", timeout=5)
+        celery_status = "connected" if response.status_code == 200 else "error"
+    except Exception:
+        celery_status = "disconnected"
+    
+    services = {
+        "cv_parsing": CV_PARSING_AVAILABLE,
+        "interview_simulation": INTERVIEW_AVAILABLE,
+        "scoring_engine": SCORING_AVAILABLE,
+        "celery_api": celery_status == "connected"
+    }
+    
+    return HealthCheck(
+        celery_api_status=celery_status,
+        services=services
+    )
 
-        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']}")
+@app.post("/parse-cv/", tags=["CV Parsing"])
+async def parse_cv(file: UploadFile = File(...)):
+    """Analyse un CV PDF et extrait les informations structurées."""
+    
+    if not CV_PARSING_AVAILABLE:
+        # Fallback si le parsing n'est pas disponible
+        return create_fallback_cv_data() if create_fallback_cv_data else {
+            "error": "Service de parsing de CV temporairement indisponible",
+            "candidat": {
+                "informations_personnelles": {"nom": "Test User"},
+                "compétences": {"hard_skills": [], "soft_skills": []}
+            }
+        }
+    
+    if file.content_type != "application/pdf":
+        raise HTTPException(status_code=400, detail="Fichier PDF requis")
+    
+    tmp_path = None
+    try:
+        # Sauvegarder le fichier temporairement
+        contents = await file.read()
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+            tmp.write(contents)
+            tmp_path = tmp.name
+        
+        # Traiter le CV
+        cv_agent = CvParserAgent(pdf_path=tmp_path)
+        parsed_data = await run_in_threadpool(cv_agent.process)
+        
+        if not parsed_data and create_fallback_cv_data:
+            parsed_data = create_fallback_cv_data(tmp_path)
+        
+        # Scoring si disponible
+        if SCORING_AVAILABLE and ContextualScoringEngine and parsed_data:
+            try:
+                scoring_engine = ContextualScoringEngine(parsed_data)
+                scored_data = await run_in_threadpool(scoring_engine.calculate_scores)
+                if parsed_data.get("candidat"):
+                    parsed_data["candidat"].update(scored_data)
+            except Exception as e:
+                logger.warning(f"Scoring échoué: {e}")
+        
+        return parsed_data
+        
+    except Exception as e:
+        logger.error(f"Erreur parsing CV: {e}")
+        if create_fallback_cv_data:
+            return create_fallback_cv_data(tmp_path)
+        raise HTTPException(status_code=500, detail=str(e))
+    
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            try:
+                os.remove(tmp_path)
+            except Exception:
+                pass
 
-        processor = GraphInterviewProcessor(payload)
-        result = processor.invoke(payload.get("messages", []))
+@app.post("/simulate-interview/", tags=["Interview"])
+async def simulate_interview(request: InterviewRequest):
+    """Gère une conversation d'entretien d'embauche."""
+    
+    if not INTERVIEW_AVAILABLE:
+        raise HTTPException(
+            status_code=503, 
+            detail="Service de simulation d'entretien indisponible"
+        )
+    
+    try:
+        processor = InterviewProcessor(
+            cv_document=request.cv_document,
+            job_offer=request.job_offer,
+            conversation_history=request.conversation_history
+        )
+        
+        result = await run_in_threadpool(processor.run, messages=request.messages)
+        return {"response": result["messages"][-1].content}
+        
+    except Exception as e:
+        logger.error(f"Erreur simulation entretien: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-        return JSONResponse(content=result)
+@app.post("/trigger-analysis/", response_model=TaskResponse, status_code=202, tags=["Analysis"])
+async def trigger_analysis(request: AnalysisRequest):
+    """Déclenche une analyse asynchrone via l'API Celery."""
+    
+    try:
+        response = requests.post(
+            f"{CELERY_API_URL}/trigger-analysis",
+            json=request.dict(),
+            headers={"Content-Type": "application/json"},
+            timeout=30
+        )
+        
+        if response.status_code == 202:
+            data = response.json()
+            return TaskResponse(
+                task_id=data["task_id"],
+                status=data["status"],
+                message="Analyse démarrée"
+            )
+        else:
+            raise HTTPException(status_code=503, detail="Service d'analyse indisponible")
+            
+    except requests.RequestException:
+        raise HTTPException(status_code=503, detail="API Celery inaccessible")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
-    except ValueError as ve:
-        logger.error(f"Data validation error: {ve}", exc_info=True)
-        return JSONResponse(content={"error": str(ve)}, status_code=400)
+@app.get("/analysis-status/{task_id}", response_model=TaskResponse, tags=["Analysis"])
+async def get_analysis_status(task_id: str):
+    """Récupère le statut d'une analyse."""
+    
+    try:
+        response = requests.get(f"{CELERY_API_URL}/task-status/{task_id}", timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            return TaskResponse(
+                task_id=task_id,
+                status=data["status"],
+                result=data.get("result"),
+                message=data.get("progress", "Statut récupéré")
+            )
+        else:
+            raise HTTPException(status_code=503, detail="Service d'analyse indisponible")
+            
+    except requests.RequestException:
+        raise HTTPException(status_code=503, detail="API Celery inaccessible")
     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
-        )
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Endpoint de debug pour HF Spaces
+@app.get("/debug", tags=["Debug"])
+async def debug_info():
+    """Informations de debug pour le déploiement."""
+    return {
+        "environment": {
+            "HF_HOME": os.getenv("HF_HOME"),
+            "CELERY_API_URL": CELERY_API_URL,
+            "PYTHONPATH": os.getenv("PYTHONPATH")
+        },
+        "services": {
+            "cv_parsing": CV_PARSING_AVAILABLE,
+            "interview_simulation": INTERVIEW_AVAILABLE,
+            "scoring_engine": SCORING_AVAILABLE
+        },
+        "cache_dirs": {
+            "/tmp/cache": os.path.exists("/tmp/cache"),
+            "/app/cache": os.path.exists("/app/cache")
+        }
+    }
 
 if __name__ == "__main__":
     import uvicorn
-    port = int(os.getenv("PORT", 8002)) # Use PORT environment variable, default to 8002
-    uvicorn.run(app, host="0.0.0.0", port=port)
+    uvicorn.run(app, host="0.0.0.0", port=7860)

prompts/rag_prompt_old.txt

@@ -1,89 +1,35 @@
-Tu es un recruteur expert, menant un premier entretien de qualification. Ton ton est professionnel mais engageant.
-Ta mission est d'évaluer l'adéquation d'un candidat pour un poste.
-CONTEXTE DE L'ENTRETIEN
-Tu dois baser ta conversation sur les informations suivantes :
-
-1. Informations à utiliser activement dans la conversation :
-Entreprise : {entreprise}
-Intitulé du poste : {poste}
-Équipe / Pôle : {pole}
-Missions principales : {mission}
-
-2. Informations pour guider tes questions :
-Profil recherché : {profil_recherche}
-Compétences clés attendues : {competences}
-
-3. Informations sur le candidat :
-Les données de son CV sont : {cv}
-
-4. ANALYSE DES COMPÉTENCES DU CANDIDAT :
-{skills_analysis}
-
-5. ANALYSE DE RECONVERSION (si applicable) :
-{reconversion_analysis}
-
-IMPORTANT: La description complète du poste à utiliser pour l'analyse est la suivante:
-{job_description}
-
-DIRECTIVES D'ADAPTATION SELON LE PROFIL
-
-1. Adaptation aux niveaux de compétences :
-   - Pour les compétences "expert" : Pose des questions techniques approfondies, demande des exemples concrets d'optimisation, de leadership technique, ou d'innovation
-   - Pour les compétences "avance" : Explore les défis rencontrés, la résolution de problèmes complexes, et l'autonomie
-   - Pour les compétences "intermediaire" : Vérifie la compréhension pratique, demande des exemples d'application
-   - Pour les compétences "debutant" : Teste les connaissances de base, évalue la motivation à apprendre
-
-2. Prise en compte de la reconversion (si détectée) :
-   - Explore les motivations du changement de carrière
-   - Identifie les compétences transférables
-   - Évalue l'engagement dans la nouvelle voie
-   - Rassure sur la valorisation de l'expérience passée
-
-3. Questions adaptées au contexte :
-   - Si le candidat a de l'expérience dans le domaine : Questions sur l'évolution, les projets marquants
-   - Si le candidat est en reconversion : Questions sur la transition, l'apprentissage, l'adaptation
-
-4. Pour le candidat qui a des projets : 
-  - Essaye de creuser les skills utilisé pour ce projet
-  - n'hésite pas a poser des questions technique sur les skills d'un projet
-
-DÉROULEMENT DE L'ENTRETIEN
-
-1. Déroulement de l'entretien :
-Introduction : Commence par te présenter en utilisant le prénom Roni. 
-Présente l'entreprise ({entreprise}) et le contexte du recrutement en t'appuyant sur l'intitulé du poste ({poste}) et les missions ({mission}).
-
-
-2. Présentation du candidat : Ta première question doit inviter le candidat à se présenter.
-
-3. Questions adaptées au profil :
-   - Utilise l'analyse des compétences pour calibrer tes questions
-   - Creuse les compétences avec des questions techniques
-   - Explore les motivations si reconversion détectée
-   - Adapte ton niveau de questionnement au profil
-
-4. Une question à la fois : Pose une seule question à la fois et attends la réponse complète.
-
-STYLE ET COMPORTEMENT
-
-- Personnalisation : Appelle toujours le candidat par son nom
-- Langage Naturel : Évite le jargon RH, utilise des formulations fluides
-- Écoute active : Montre que tu écoutes avec des relances appropriées
-- Évaluation subtile : Adapte tes questions au niveau détecté sans le mentionner explicitement
-- Conserve toujours une intéraction la plus naturelle et professionelle possible
-
---- CONTEXTE TECHNIQUE POUR L'AGENT (ne pas mentionner à l'utilisateur) ---
-L'ID de l'utilisateur actuel est : {user_id}
-L'ID de l'offre d'emploi actuelle est : {job_offer_id}
-
-Quand tu appelleras l'outil 'trigger_interview_analysis', tu devras OBLIGATOIREMENT utiliser ces IDs exacts.
-Tu devras aussi OBLIGATOIREMENT fournir l'argument 'conversation_history' en utilisant l'historique complet des messages de la conversation en cours.
---- FIN DU CONTEXTE TECHNIQUE ---
-
-COMMANDE DE DÉVELOPPEMENT
-Si le dernier message de l'utilisateur est EXACTEMENT la phrase "LANCEMENT_ANALYSE_DEV", tu dois ignorer toutes les autres instructions de conversation, conclure brièvement et immédiatement appeler l'outil `trigger_interview_analysis`.
-
-CONCLUSION
-
-Quand tu estimes avoir assez d'informations, conclus l'échange de manière positive.
-Action finale OBLIGATOIRE : Appelle l'outil `trigger_interview_analysis` pour lancer l'analyse finale. C'est ta seule et dernière action. Ne réponds rien d'autre.
+Tu es un recruteur expert, menant un premier entretien de qualification. Ton ton est professionnel mais engageant. Ta mission est d'évaluer l'adéquation d'un candidat pour un poste.
+
+CONTEXTE DE L'ENTRETIEN
+Tu dois baser ta conversation sur les informations suivantes :
+
+1. Informations à utiliser activement dans la conversation :
+Entreprise : {entreprise}
+Intitulé du poste : {poste}
+Équipe / Pôle : {pole}
+Missions principales : {mission}
+
+2. Informations pour guider tes questions (à ne PAS mentionner directement) :
+Profil recherché : {profil_recherche}
+Compétences clés attendues : {competences}
+(Utilise ces deux points comme une grille d'analyse interne pour formuler des questions pertinentes. Tes questions doivent permettre de vérifier si le candidat possède ces compétences et correspond au profil.)
+3. Informations sur le candidat :
+Les données de son CV sont : {cv}
+
+DIRECTIVES PRÉCISES
+
+1. Déroulement de l'entretien :
+Introduction : Commence par te présenter avec un prénom (ex: Camille, Thomas...). Présente l'entreprise ({entreprise}) et le contexte du recrutement en t'appuyant sur l'intitulé du poste ({poste}) et les missions ({mission}).
+Présentation du candidat : Ta toute première question doit inviter le candidat à se présenter. Par exemple : "Pour commencer, parlez-moi un peu de votre parcours."
+Questions ciblées : En te basant sur les compétences et le profil recherché (que tu gardes en tête), pose des questions ouvertes pour évaluer le candidat. Fais des liens entre ses expériences ({cv}) et les missions du poste ({mission}). Par exemple, si une compétence attendue est "l'analyse de données", demande au candidat de décrire un projet où il a dû analyser un ensemble de données complexe.
+Une question à la fois : Pose une seule question à la fois et attends la réponse complète du candidat avant de poursuivre.
+
+2. Style et Comportement :
+Personnalisation : Appelle toujours le candidat par son nom (présent dans le CV).
+Langage Naturel : Évite le jargon RH. Utilise des formulations fluides comme "J'ai noté dans votre CV que...", "Racontez-moi l'expérience chez...". Montre que tu écoutes avec des relances comme "D'accord, je vois.", "C'est intéressant.".
+Évaluation subtile : Ne dis jamais "la compétence requise est...". À la place, évalue la compétence à travers des questions situationnelles ou comportementales.
+
+3. Conclusion de l'entretien :
+Quand tu estimes avoir assez d'informations, conclus l'échange de manière positive.
+Termine par une phrase de politesse.
+Action finale OBLIGATOIRE : Ta toute dernière phrase, après la politesse, doit être exactement : "nous allons maintenant passer a l'analyse". Juste après, tu dois utiliser l'outil interview_analyser.

requirements.txt

@@ -18,9 +18,8 @@ sentencepiece
 accelerate
 pypdf
 python-dotenv
-pymongo
+
 requests
 faiss-cpu
-langtrace-python-sdk
 
 httpx==0.28.1

src/agents/cv_agents.py

@@ -1,251 +0,0 @@
-import json
-import logging
-from typing import Dict, Any, List
-from crewai import Agent, Task, Crew, Process
-
-logger = logging.getLogger(__name__)
-
-class CVAgentOrchestrator:
-    def __init__(self, llm):
-        self.llm = llm
-        self._create_agents()
-    
-    def _create_agents(self):
-        self.section_splitter = Agent(
-            role="Analyseur de Structure de CV",
-            goal="Découper intelligemment un CV en sections thématiques",
-            backstory="Expert en analyse documentaire spécialisé dans la reconnaissance de structures de CV.",
-            verbose=False,
-            llm=self.llm
-        )
-        
-        self.contact_extractor = Agent(
-            role="Extracteur d'informations de contact",
-            goal="Extraire les coordonnées du candidat",
-            backstory="Expert en extraction d'informations de contact avec précision.",
-            verbose=False,
-            llm=self.llm
-        )
-        
-        self.skills_extractor = Agent(
-            role="Extracteur de compétences",
-            goal="Identifier hard skills et soft skills",
-            backstory="Spécialiste en identification de compétences techniques et comportementales.",
-            verbose=False,
-            llm=self.llm
-        )
-        
-        self.experience_extractor = Agent(
-            role="Extracteur d'expériences",
-            goal="Extraire les expériences professionnelles",
-            backstory="Expert en analyse de parcours professionnels.",
-            verbose=False,
-            llm=self.llm
-        )
-        
-        self.project_extractor = Agent(
-            role="Extracteur de projets",
-            goal="Identifier projets professionnels et personnels",
-            backstory="Spécialiste en identification de projets significatifs.",
-            verbose=False,
-            llm=self.llm
-        )
-        
-        self.education_extractor = Agent(
-            role="Extracteur de formations",
-            goal="Extraire formations et diplômes",
-            backstory="Expert en analyse de parcours académiques.",
-            verbose=False,
-            llm=self.llm
-        )
-        
-        self.reconversion_detector = Agent(
-            role="Détecteur de reconversion",
-            goal="Analyser les changements de carrière",
-            backstory="Conseiller d'orientation expert en transitions de carrière.",
-            verbose=False,
-            llm=self.llm
-        )
-        
-        self.profile_builder = Agent(
-            role="Constructeur de profil",
-            goal="Assembler le profil candidat final",
-            backstory="Expert en structuration de données JSON.",
-            verbose=False,
-            llm=self.llm
-        )
-    
-    def split_cv_sections(self, cv_content: str) -> Dict[str, str]:
-        task = Task(
-            description=f"Analyser ce CV et l'organiser en sections: {cv_content}",
-            expected_output="""JSON avec sections: contact, experiences, projects, education, skills, other""",
-            agent=self.section_splitter
-        )
-        
-        crew = Crew(
-            agents=[self.section_splitter],
-            tasks=[task],
-            process=Process.sequential,
-            verbose=False,
-            telemetry=False
-        )
-        
-        result = crew.kickoff()
-        return self._parse_sections_result(result)
-    
-    def extract_all_sections(self, sections: Dict[str, str]) -> Dict[str, Any]:
-        # Créer les tâches avec les sections en input
-        tasks = self._create_extraction_tasks(sections)
-        
-        crew = Crew(
-            agents=[
-                self.contact_extractor,
-                self.skills_extractor,
-                self.experience_extractor,
-                self.project_extractor,
-                self.education_extractor,
-                self.reconversion_detector,
-                self.profile_builder
-            ],
-            tasks=tasks,
-            process=Process.sequential,
-            verbose=True,  # Activer pour debug
-            telemetry=False
-        )
-        
-        # Passer les sections comme inputs
-        inputs = {
-            "contact": sections.get("contact", ""),
-            "experiences": sections.get("experiences", ""),
-            "projects": sections.get("projects", ""),
-            "education": sections.get("education", ""),
-            "skills": sections.get("skills", ""),
-            "other": sections.get("other", "")
-        }
-        
-        logger.info(f"Starting crew with inputs: {list(inputs.keys())}")
-        result = crew.kickoff(inputs=inputs)
-        logger.info(f"Crew completed. Raw result: {result.raw if hasattr(result, 'raw') else str(result)[:200]}...")
-        
-        return self._parse_final_result(result)
-    
-    def _create_extraction_tasks(self, sections: Dict[str, str]) -> List[Task]:
-        contact_task = Task(
-            description=(
-                "Voici la section contact du CV : {contact}\n"
-                "Extraire précisément le nom, email, téléphone et localisation du candidat."
-            ),
-            expected_output='{"nom": "...", "email": "...", "numero_de_telephone": "...", "localisation": "..."}',
-            agent=self.contact_extractor
-        )
-        
-        skills_task = Task(
-            description=(
-                "Voici les sections pertinentes du CV :\n"
-                "Expériences: {experiences}\n"
-                "Projets: {projects}\n"
-                "Compétences: {skills}\n"
-                "Extraire toutes les compétences techniques (hard skills) et comportementales (soft skills) mentionnées."
-            ),
-            expected_output='{"hard_skills": ["compétence1", "compétence2"], "soft_skills": ["compétence1", "compétence2"]}',
-            agent=self.skills_extractor
-        )
-        
-        experience_task = Task(
-            description=(
-                "Voici la section expériences du CV : {experiences}\n"
-                "Extraire toutes les expériences professionnelles avec poste, entreprise, dates et responsabilités."
-            ),
-            expected_output='[{"Poste": "titre", "Entreprise": "nom", "start_date": "date", "end_date": "date", "responsabilités": ["resp1", "resp2"]}]',
-            agent=self.experience_extractor
-        )
-        
-        project_task = Task(
-            description=(
-                "Voici les sections projets et expériences du CV :\n"
-                "Projets: {projects}\n"
-                "Identifier et extraire les projets professionnels et personnels distincts des responsabilités générales."
-            ),
-            expected_output='{"professional": [{"title": "titre", "technologies": ["tech1"], "outcomes": ["résultat1"]}], "personal": []}',
-            agent=self.project_extractor
-        )
-        
-        education_task = Task(
-            description=(
-                "Voici la section formations du CV : {education}\n"
-                "Extraire toutes les formations, diplômes et certifications avec institution et dates."
-            ),
-            expected_output='[{"degree": "diplôme", "institution": "établissement", "start_date": "date", "end_date": "date"}]',
-            agent=self.education_extractor
-        )
-        
-        reconversion_task = Task(
-            description=(
-                "En analysant les expériences extraites précédemment, déterminer si le candidat est en reconversion professionnelle. "
-                "Chercher des changements de secteur, de type de poste ou des transitions significatives."
-            ),
-            expected_output='{"reconversion_analysis": {"is_reconversion": true, "analysis": "Explication détaillée..."}}',
-            agent=self.reconversion_detector,
-            context=[experience_task]
-        )
-        
-        profile_task = Task(
-            description=(
-                "Assembler toutes les informations extraites des tâches précédentes en un profil candidat complet. "
-                "Créer un JSON valide avec une clé 'candidat' contenant toutes les sections."
-            ),
-            expected_output=(
-                '{"candidat": {'
-                '"informations_personnelles": {...}, '
-                '"compétences": {...}, '
-                '"expériences": [...], '
-                '"projets": {...}, '
-                '"formations": [...], '
-                '"reconversion": {...}'
-                '}}'
-            ),
-            agent=self.profile_builder,
-            context=[contact_task, skills_task, experience_task, project_task, education_task, reconversion_task]
-        )
-        
-        return [contact_task, skills_task, experience_task, project_task, education_task, reconversion_task, profile_task]
-    
-    def _parse_sections_result(self, result) -> Dict[str, str]:
-        result_str = result.raw if hasattr(result, 'raw') else str(result)
-        
-        if '```json' in result_str:
-            result_str = result_str.split('```json')[1].split('```')[0].strip()
-        elif '```' in result_str:
-            parts = result_str.split('```')
-            if len(parts) >= 3:
-                result_str = parts[1].strip()
-        
-        parsed = json.loads(result_str)
-        
-        # Assurer que toutes les sections nécessaires existent
-        default_sections = {
-            "contact": "",
-            "experiences": "",
-            "projects": "",
-            "education": "",
-            "skills": "",
-            "other": ""
-        }
-        
-        for key in default_sections:
-            if key not in parsed:
-                parsed[key] = default_sections[key]
-        
-        return parsed
-    
-    def _parse_final_result(self, result) -> Dict[str, Any]:
-        result_str = result.raw if hasattr(result, 'raw') else str(result)
-        
-        if '```json' in result_str:
-            result_str = result_str.split('```json')[1].split('```')[0].strip()
-        elif '```' in result_str:
-            parts = result_str.split('```')
-            if len(parts) >= 3:
-                result_str = parts[1].strip()
-        
-        return json.loads(result_str)

src/agents/scoring_agent.py

@@ -1,183 +0,0 @@
-import json
-import re
-import logging
-from datetime import datetime
-from typing import Dict, List, Any
-
-logger = logging.getLogger(__name__)
-
-class SimpleScoringAgent:
-    
-    def calculate_scores(self, candidat_data: Dict[str, Any]) -> Dict[str, List[Dict[str, Any]]]:
-        if not candidat_data or not isinstance(candidat_data, dict):
-            return {"analyse_competences": []}
-            
-        skills_data = candidat_data.get("compétences", {})
-        skills_list = self._extract_skills_list(skills_data)
-        
-        if not skills_list:
-            return {"analyse_competences": []}
-
-        skill_analysis = []
-        
-        for skill in skills_list:
-            level = self._determine_skill_level(skill, candidat_data)
-            skill_analysis.append({
-                "skill": skill,
-                "level": level
-            })
-        
-        return {"analyse_competences": skill_analysis}
-
-    def _extract_skills_list(self, skills_data: Dict[str, Any]) -> List[str]:
-        """Extrait la liste des compétences"""
-        skills_list = []
-        
-        if isinstance(skills_data, dict):
-            skills_list.extend(skills_data.get("hard_skills", []))
-            skills_list.extend(skills_data.get("soft_skills", []))
-        elif isinstance(skills_data, list):
-            skills_list = [item.get("nom") for item in skills_data if item.get("nom")]
-        
-        return [skill for skill in skills_list if skill and isinstance(skill, str) and skill.strip()]
-
-    def _determine_skill_level(self, skill: str, candidat_data: Dict[str, Any]) -> str:
-        """Détermine le niveau d'une compétence selon des règles simples"""
-        
-        frequency = self._count_skill_mentions(skill, candidat_data)
-        max_duration = self._get_max_duration_for_skill(skill, candidat_data)
-        has_pro_experience = self._has_professional_experience(skill, candidat_data)
-        
-        # Règles simples de classification
-        if has_pro_experience and max_duration >= 3.0:
-            return "expert"
-        elif has_pro_experience and max_duration >= 1.0:
-            return "avance"
-        elif frequency >= 3 or max_duration >= 0.5:
-            return "intermediaire"
-        else:
-            return "debutant"
-
-    def _count_skill_mentions(self, skill: str, candidat_data: Dict[str, Any]) -> int:
-        """Compte le nombre de mentions de la compétence"""
-        skill_lower = skill.lower()
-        total_mentions = 0
-        
-        # Recherche dans toutes les sections
-        all_text = self._get_all_text_content(candidat_data).lower()
-        total_mentions = all_text.count(skill_lower)
-        
-        return total_mentions
-
-    def _get_max_duration_for_skill(self, skill: str, candidat_data: Dict[str, Any]) -> float:
-        """Trouve la durée maximum d'utilisation de la compétence"""
-        skill_lower = skill.lower()
-        max_duration = 0.0
-        
-        experiences_key = "expériences" if "expériences" in candidat_data else "experiences_professionnelles"
-        experiences = candidat_data.get(experiences_key, [])
-        
-        if not isinstance(experiences, list):
-            return 0.0
-        
-        for exp in experiences:
-            if not isinstance(exp, dict):
-                continue
-                
-            exp_text = json.dumps(exp, ensure_ascii=False).lower()
-            
-            if skill_lower in exp_text:
-                duration = self._calculate_experience_duration(exp)
-                max_duration = max(max_duration, duration)
-        
-        return max_duration
-
-    def _has_professional_experience(self, skill: str, candidat_data: Dict[str, Any]) -> bool:
-        """Vérifie si la compétence a été utilisée en contexte professionnel"""
-        skill_lower = skill.lower()
-        
-        experiences_key = "expériences" if "expériences" in candidat_data else "experiences_professionnelles"
-        experiences = candidat_data.get(experiences_key, [])
-        
-        if not isinstance(experiences, list):
-            return False
-        
-        for exp in experiences:
-            if not isinstance(exp, dict):
-                continue
-                
-            exp_text = json.dumps(exp, ensure_ascii=False).lower()
-            if skill_lower in exp_text:
-                return True
-        
-        return False
-
-    def _get_all_text_content(self, candidat_data: Dict[str, Any]) -> str:
-        """Récupère tout le contenu textuel du CV"""
-        all_content = []
-        
-        # Expériences
-        experiences_key = "expériences" if "expériences" in candidat_data else "experiences_professionnelles"
-        for exp in candidat_data.get(experiences_key, []):
-            if isinstance(exp, dict):
-                all_content.append(json.dumps(exp, ensure_ascii=False))
-        
-        # Projets
-        projects = candidat_data.get("projets", {})
-        if isinstance(projects, dict):
-            for project_type in ["professional", "personal"]:
-                for project in projects.get(project_type, []):
-                    if isinstance(project, dict):
-                        all_content.append(json.dumps(project, ensure_ascii=False))
-        
-        # Formations
-        for formation in candidat_data.get("formations", []):
-            if isinstance(formation, dict):
-                all_content.append(json.dumps(formation, ensure_ascii=False))
-        
-        return " ".join(all_content)
-
-    def _calculate_experience_duration(self, exp: Dict[str, Any]) -> float:
-        """Calcule la durée d'une expérience en années"""
-        start_date_str = exp.get("date_debut", exp.get("start_date", ""))
-        end_date_str = exp.get("date_fin", exp.get("end_date", ""))
-        
-        if not isinstance(start_date_str, str):
-            start_date_str = str(start_date_str) if start_date_str else ""
-        if not isinstance(end_date_str, str):
-            end_date_str = str(end_date_str) if end_date_str else ""
-        
-        return self._calculate_duration_in_years(start_date_str, end_date_str)
-
-    def _calculate_duration_in_years(self, start_date_str: str, end_date_str: str) -> float:
-        """Calcule la durée entre deux dates en années"""
-        start_date = self._parse_date(start_date_str)
-        end_date = self._parse_date(end_date_str)
-        
-        if start_date and end_date:
-            if end_date < start_date:
-                return 0.0
-            return (end_date - start_date).days / 365.25
-        
-        return 0.0
-
-    def _parse_date(self, date_str: str) -> datetime:
-        """Parse une date de manière simple"""
-        if not date_str or not isinstance(date_str, str):
-            return None
-            
-        date_str_lower = date_str.lower().strip()
-        if date_str_lower in ["aujourd'hui", "maintenant", "en cours", "current", "présent", "actuellement"]:
-            return datetime.now()
-        
-        # Extraction simple de l'année
-        year_match = re.search(r'\b(20\d{2}|19\d{2})\b', date_str)
-        if year_match:
-            year = int(year_match.group(1))
-            return datetime(year, 1, 1)
-        
-        return None
-
-# Alias pour maintenir la compatibilité
-ScoringAgent = SimpleScoringAgent
-ImprovedScoringAgent = SimpleScoringAgent

src/core/rag_handler.py

@@ -1,130 +0,0 @@
-import os
-import logging
-from typing import Optional, List
-from langchain_community.document_loaders import DirectoryLoader, TextLoader
-from langchain_community.vectorstores import FAISS
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-
-logger = logging.getLogger(__name__)
-
-_embeddings_model = None
-_rag_handler_instance = None
-
-VECTOR_STORE_PATH = "/tmp/vector_store" 
-
-def get_embeddings_model():
-    global _embeddings_model
-    if _embeddings_model is None:
-        from langchain_huggingface import HuggingFaceEmbeddings
-        logger.info("Initialisation du modèle d'embeddings...")
-        _embeddings_model = HuggingFaceEmbeddings(
-            model_name='sentence-transformers/all-MiniLM-L6-v2',
-            model_kwargs={'device': 'cpu'},
-            encode_kwargs={'normalize_embeddings': True}
-        )
-        logger.info("✅ Modèle d'embeddings initialisé avec succès")
-    return _embeddings_model
-
-class RAGHandler:
-    def __init__(self, knowledge_base_path: str = "/app/knowledge_base", lazy_init: bool = True):
-        self.knowledge_base_path = knowledge_base_path
-        self.embeddings = None
-        self.vector_store = None
-        self._initialized = False
-        
-        os.makedirs(VECTOR_STORE_PATH, exist_ok=True)
-        
-        if not lazy_init:
-            self._initialize()
-
-    def _initialize(self):
-        if self._initialized:
-            return
-        
-        logger.info("Initialisation du RAG Handler...")
-        self.embeddings = get_embeddings_model()
-        
-        if self.embeddings is None:
-            logger.error("Impossible d'initialiser les embeddings")
-            return
-        
-        self.vector_store = self._load_or_create_vector_store(self.knowledge_base_path)
-        self._initialized = True
-        logger.info("✅ RAG Handler initialisé avec succès")
-
-    def _load_documents(self, path: str) -> List:
-        if not os.path.exists(path):
-            logger.warning(f"Répertoire {path} non trouvé")
-            return []
-            
-        loader = DirectoryLoader(
-            path,
-            glob="**/*.md", 
-            loader_cls=TextLoader,
-            loader_kwargs={"encoding": "utf-8"}
-        )
-        logger.info(f"Chargement des documents depuis : {path}")
-        documents = loader.load()
-        logger.info(f"✅ {len(documents)} documents chargés")
-        return documents
-
-    def _create_vector_store(self, knowledge_base_path: str) -> Optional[FAISS]:
-        documents = self._load_documents(knowledge_base_path)
-        if not documents:
-            logger.warning("Aucun document trouvé - création d'un vector store vide")
-            from langchain.schema import Document
-            dummy_doc = Document(
-                page_content="Document de test pour initialiser le vector store",
-                metadata={"source": "dummy"}
-            )
-            documents = [dummy_doc]
-        
-        logger.info(f"{len(documents)} documents chargés. Création des vecteurs...")
-        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
-        texts = text_splitter.split_documents(documents)
-        
-        vector_store = FAISS.from_documents(texts, self.embeddings)
-        
-        vector_store.save_local(VECTOR_STORE_PATH)
-        logger.info(f"✅ Vector store créé et sauvegardé dans : {VECTOR_STORE_PATH}")
-        
-        return vector_store
-
-    def _load_or_create_vector_store(self, knowledge_base_path: str) -> Optional[FAISS]:
-        index_path = os.path.join(VECTOR_STORE_PATH, "index.faiss")
-        if os.path.exists(index_path):
-            logger.info(f"Chargement du vector store existant depuis : {VECTOR_STORE_PATH}")
-            return FAISS.load_local(
-                VECTOR_STORE_PATH, 
-                embeddings=self.embeddings, 
-                allow_dangerous_deserialization=True 
-            )
-        else:
-            logger.info("Aucun vector store trouvé. Création d'un nouveau...")
-            return self._create_vector_store(knowledge_base_path)
-
-    def get_relevant_feedback(self, query: str, k: int = 1) -> List[str]:
-        if not self._initialized:
-            self._initialize()
-        
-        if not self.vector_store:
-            logger.warning("Vector store non disponible - retour de conseils génériques")
-            return [
-                "Préparez vos réponses aux questions comportementales",
-                "Montrez votre motivation pour le poste",
-                "Donnez des exemples concrets de vos réalisations"
-            ]
-        
-        results = self.vector_store.similarity_search(query, k=k)
-        feedback = [doc.page_content for doc in results if doc.page_content.strip()]
-        
-        if not feedback:
-            return ["Conseil général: Préparez-vous bien pour les entretiens futurs."]
-            
-        return feedback
-
-def get_rag_handler() -> Optional[RAGHandler]:
-    global _rag_handler_instance
-    if _rag_handler_instance is None:
-        _rag_handler_instance = RAGHandler(lazy_init=True)
-    return _rag_handler_instance

src/crew/__pycache__/__init__.cpython-312.pycZone.Identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

src/crew/__pycache__/agents.cpython-312.pycZone.Identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

src/crew/__pycache__/analysis_crew.cpython-312.pycZone.Identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

src/crew/__pycache__/crew_pool.cpython-312.pycZone.Identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

src/crew/__pycache__/tasks.cpython-312.pycZone.Identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

src/crew/agents.py

@@ -0,0 +1,75 @@
+from crewai import Agent
+from crewai import LLM
+from src.config import crew_openai
+
+LLM_agent = crew_openai()
+
+# Interview Simulation Agents
+report_generator_agent = Agent(
+    role='Rédacteur de Rapports Synthétiques',
+    goal='Générer un feedback pertinent, a partir du deroulement de lentretient',
+    backstory=(
+        "Sepcialisé dans le recrutement et les ressources humaines, capable d'evaluer les candidats"
+        "sur la communication et la pertinences des reponses en fonction des questions posées, redige"
+        "en un rapport clair, un feedback détaillé sur le candidat."
+    ),
+    allow_delegation=False,
+    verbose=False,
+    llm=LLM_agent
+)
+
+# CV Parsing Agents
+skills_extractor_agent = Agent(
+    role="Spécialiste de l'extraction de compétences (hard & soft skills)",
+    goal="Identifier et extraire toutes les compétences pertinentes du CV.",
+    backstory="Vous êtes un spécialiste des compétences techniques et comportementales. Votre mission est de parcourir les CV et de lister de manière exhaustive toutes les compétences mentionnées.",
+    verbose=False,
+    llm=LLM_agent
+)
+experience_extractor_agent = Agent(
+    role="Expert en extraction d'expérience professionnelle",
+    goal="Extraire en détail l'expérience professionnelle du candidat.",
+    backstory="Vous êtes un expert en recrutement spécialisé dans l'analyse des parcours professionnels. Vous devez extraire chaque expérience de manière précise, en notant les rôles, les entreprises, les dates et les responsabilités.",
+    verbose=False,
+    llm=LLM_agent
+)
+project_extractor_agent = Agent(
+    role="Spécialiste de l'identification de projets (pro & perso)",
+    goal="Identifier et décrire les projets significatifs mentionnés.",
+    backstory="Vous êtes passionné par l'innovation et les réalisations. Votre rôle est de repérer et de décrire les projets professionnels et personnels qui mettent en lumière les compétences et l'initiative des candidats.",
+    verbose=False,
+    llm=LLM_agent
+)
+education_extractor_agent = Agent(
+    role="Expert en extraction d'informations sur la formation",
+    goal="Extraire les détails des études et des diplômes obtenus.",
+    backstory="Vous êtes un spécialiste des parcours académiques. Votre tâche est d'extraire avec précision les informations relatives aux études, aux diplômes et aux établissements fréquentés par les candidats.",
+    verbose=False,
+    llm=LLM_agent
+)
+informations_personnelle_agent = Agent(
+    role="Spécialiste de l'extraction des coordonnées",
+    goal="Identifier et extraire précisément les coordonnées du candidat.",
+    backstory="Vous êtes un expert en analyse de CV, particulièrement doué pour localiser et extraire les informations de contact. Votre rôle est de trouver le nom, l'adresse e-mail, le numéro de téléphone et la localisation (ville ou région) du candidat, généralement situés en haut ou à la fin du CV.",
+    verbose=False,
+    llm=LLM_agent
+)
+ProfileBuilderAgent = Agent(
+    role='Constructeur de Profil CV',
+    goal='Créer un profil JSON structuré et valide avec la clé candidat',
+    backstory=(
+        "Tu es un expert en structuration de données JSON. "
+        "Ta mission est de créer un profil candidat parfaitement formaté "
+        "en respectant scrupuleusement la structure JSON demandée."
+    ),
+    verbose=True,
+    llm=LLM_agent
+)
+
+reconversion_detector_agent = Agent(
+    role="Détecteur de Reconversion Professionnelle",
+    goal="Analyser la chronologie des expériences pour identifier les changements de carrière significatifs.",
+    backstory="Vous êtes un conseiller d'orientation expert, capable de repérer les transitions de carrière, d'identifier les compétences transférables et de valoriser les parcours non linéaires. Votre analyse doit mettre en lumière les changements de secteur, de type de poste ou de niveau de responsabilité.",
+    verbose=False,
+    llm=LLM_agent
+)

src/crew/crew_pool.py

@@ -0,0 +1,81 @@
+from crewai import Crew, Process
+from langchain_core.tools import tool
+import json
+from pydantic import BaseModel, Field
+from typing import Dict, List, Any, Type
+from .agents import report_generator_agent, skills_extractor_agent, experience_extractor_agent, project_extractor_agent, education_extractor_agent, ProfileBuilderAgent, informations_personnelle_agent, reconversion_detector_agent
+from .tasks import generate_report_task, task_extract_skills, task_extract_experience, task_extract_projects, task_extract_education, task_build_profile, task_extract_informations, task_detect_reconversion
+from src.deep_learning_analyzer import MultiModelInterviewAnalyzer
+from src.rag_handler import RAGHandler 
+from langchain_core.tools import BaseTool
+
+@tool
+def interview_analyser(conversation_history: list, job_description_text: list) -> str:
+    """
+    Appelle cet outil à la toute fin d'un entretien d'embauche pour analyser
+    l'intégralité de la conversation et générer un rapport de feedback.
+    Ne l'utilise PAS pour répondre à une question normale, mais seulement pour conclure et analyser l'entretien.
+    """
+    # 1. Analyse DL de la conversation
+    analyzer = MultiModelInterviewAnalyzer()
+    structured_analysis = analyzer.run_full_analysis(conversation_history, job_description_text)
+
+    # 2. Enrichissement avec RAG
+    rag_handler = RAGHandler()
+    rag_feedback = []
+    # Extraire les intentions et sentiments pour trouver des conseils pertinents
+    if structured_analysis.get("intent_analysis"):
+        for intent in structured_analysis["intent_analysis"]:
+            # Exemple de requête basée sur l'intention
+            query = f"Conseils pour un candidat qui cherche à {intent['labels'][0]}"
+            rag_feedback.extend(rag_handler.get_relevant_feedback(query))
+    
+    if structured_analysis.get("sentiment_analysis"):
+        for sentiment_group in structured_analysis["sentiment_analysis"]:
+            for sentiment in sentiment_group:
+                if sentiment['label'] == 'stress' and sentiment['score'].item() > 0.6:
+                    rag_feedback.extend(rag_handler.get_relevant_feedback("gestion du stress en entretien"))
+    unique_feedback = list(set(rag_feedback))
+    interview_crew = Crew(
+        agents=[report_generator_agent],
+        tasks=[generate_report_task],
+        process=Process.sequential,
+        verbose=False,
+        telemetry=False
+    )
+
+    final_report = interview_crew.kickoff(inputs={
+        'structured_analysis_data': json.dumps(structured_analysis, indent=2),
+        'rag_contextual_feedback': "\n".join(unique_feedback)
+    })
+    return final_report
+
+def analyse_cv(cv_content: str) -> json:
+    crew = Crew(
+        agents=[            
+            informations_personnelle_agent,
+            skills_extractor_agent,
+            experience_extractor_agent,
+            project_extractor_agent,
+            education_extractor_agent,
+            reconversion_detector_agent,
+
+            ProfileBuilderAgent       
+        ],
+        tasks=[
+            task_extract_informations,
+            task_extract_skills,
+            task_extract_experience,
+            task_extract_projects,
+            task_extract_education,
+            task_detect_reconversion,
+            task_build_profile     
+        ],
+        process=Process.sequential,
+        verbose=False,
+        telemetry=False
+    )
+    result = crew.kickoff(inputs={"cv_content": cv_content})
+    return result
+ 
+    

src/crew/tasks.py

@@ -0,0 +1,184 @@
+from crewai import Task
+from .agents import report_generator_agent, skills_extractor_agent, experience_extractor_agent, project_extractor_agent, education_extractor_agent, ProfileBuilderAgent, informations_personnelle_agent, reconversion_detector_agent
+
+generate_report_task = Task(
+    description=(
+        """Tu es un rédacteur expert en RH. Ta mission est de rédiger un rapport d'évaluation final.
+        Tu dois utiliser deux sources d'information principales :
+        1. Les données d'analyse structurées de l'entretien : '{structured_analysis_data}'.
+        2. Une liste de conseils et de feedback pertinents issus de notre base de connaissances : '{rag_contextual_feedback}'.
+
+        Ta tâche est de synthétiser ces informations en un rapport cohérent et actionnable."""
+    ),
+    expected_output=(
+        """Un rapport final exceptionnel basé sur l'analyse fournie. Le rapport doit être structuré comme suit:
+        1. **Résumé et Score d'Adéquation** : Synthétise le score de similarité sémantique et donne un aperçu global.
+        2. **Analyse Comportementale** : Interprète les résultats de l'analyse de sentiment et d'intention pour décrire le comportement du candidat.
+        3. **Adéquation Sémantique avec le Poste** : Explique ce que signifie le score de similarité.
+        4. **Points Forts & Axes d'Amélioration Personnalisés** : Utilise les données d'analyse pour identifier les points à améliorer. Ensuite, intègre de manière fluide et naturelle les conseils pertinents de '{rag_contextual_feedback}' pour proposer des pistes d'amélioration concrètes et personnalisées. Ne te contente pas de copier-coller le feedback, mais reformule-le pour qu'il s'intègre parfaitement au rapport.
+        5. **Recommandation Finale**."""
+    ),
+    agent=report_generator_agent,
+)
+
+task_extract_skills = Task(
+    description=(
+        "Voici le contenu du CV :\n\n{cv_content}\n\n"
+        "Extraire uniquement les compétences mentionnées explicitement dans le texte du CV. "
+        "Séparer les hard skills (techniques) et les soft skills (comportementales) en analysant les listes ou phrases les contenant. "
+        "Les hards skills doivent comprendre des compétences techniques, outils, langages de programmation, etc. "
+        "Ne rien inventer. Ne pas déduire de compétences à partir d'un poste ou d'une expérience implicite. "
+        "Identifie clairement les compétences, et n'en exclue aucune. "
+        "\n\n**CONTRAINTES JSON STRICTES:**\n"
+        "- Utiliser UNIQUEMENT des guillemets doubles (\") pour les chaînes\n"
+        "- Aucune virgule finale dans les listes ou objets\n"
+        "- Vérifier la syntaxe JSON avant de retourner le résultat\n"
+        "- Échapper correctement les caractères spéciaux (\\, \", \\n, etc.)"
+    ),
+    agent=skills_extractor_agent,
+    input_keys=["cv_content"],
+    expected_output=(
+        "Un dictionnaire JSON VALIDE 'Compétences' avec deux clés : 'hard_skills' et 'soft_skills', "
+        "contenant uniquement des listes de compétences présentes dans le texte. "
+        "FORMAT EXACT: {\"hard_skills\": [\"compétence1\", \"compétence2\"], \"soft_skills\": [\"compétence1\", \"compétence2\"]}"
+    )
+)
+
+task_extract_experience = Task(
+    description=(
+        "Voici le contenu du CV :\n\n{cv_content}\n\n"
+        """
+        Extrais toutes les expériences professionnelles du CV. Pour chaque expérience, tu DOIS fournir les informations suivantes :
+        - Poste: Le titre du poste.
+        - Entreprise: Le nom de l'entreprise.
+        - start_date: La date de début. Si non trouvée, retourne "Non spécifié".
+        - end_date: La date de fin. Si le poste est actuel, utilise "Aujourd'hui". Si non trouvée, retourne "Non spécifié".
+        - responsabilités: Une liste des tâches et missions.
+
+        RÈGLES STRICTES :
+        1.  NE JAMAIS laisser un champ vide (""). Si une information est introuvable, utilise la valeur "Non spécifié".
+        2.  Analyse attentivement les dates. "Depuis 2023" signifie que la date de fin est "Aujourd'hui".
+        """
+    ),
+    agent=experience_extractor_agent,
+    input_keys=["cv_content"],
+    expected_output=(
+        "Un tableau JSON VALIDE d'objets 'Expérience Professionnelle' avec 5 clés par expérience : "
+        "'Poste', 'Entreprise', 'start_date', 'end_date', 'responsabilités'. "
+        "FORMAT EXACT: [{\"Poste\": \"titre\", \"Entreprise\": \"nom\", \"start_date\": \"année\", \"end_date\": \"année\", \"responsabilités\": [\"resp1\", \"resp2\"]}]"
+    )
+)
+
+task_extract_projects = Task(
+    description=(
+        "Voici le contenu du CV :\n\n{cv_content}\n\n"
+        """
+        Identifie et extrais les PROJETS SPÉCIFIQUES mentionnés dans le CV.
+        Un projet est distinct d'une expérience professionnelle générale. Il a un nom ou un objectif clair.
+
+        RÈGLES STRICTES :
+        1.  NE PAS extraire les responsabilités générales d'un poste en tant que projet. Par exemple, si le CV dit "Alternant chez Enedis où j'ai mené le projet 'Simulateur IA'", alors extrais 'Simulateur IA' comme projet. Ne copie pas toutes les tâches de l'alternance.
+        2.  Si un projet est clairement lié à une expérience professionnelle, essaie de le noter, mais le plus important est de décrire le projet lui-même.
+        """
+    ),
+    agent=project_extractor_agent,
+    input_keys=["cv_content"],
+    expected_output=(
+        "Un dictionnaire JSON VALIDE 'Projets' avec deux clés : 'professional' et 'personal'. "
+        "Chaque clé contient une liste de dictionnaires, chaque dictionnaire représentant un projet avec les clés 'title', 'role', 'technologies', et 'outcomes'. "
+        "FORMAT EXACT: {\"professional\": [{\"title\": \"titre\", \"role\": \"rôle\", \"technologies\": [\"tech1\"], \"outcomes\": [\"résultat1\"]}], \"personal\": []}"
+    )
+)
+
+task_extract_education = Task(
+    description=(
+        "Voici le contenu du CV :\n\n{cv_content}\n\n"
+        """
+        Extrais le parcours de formation et les certifications. Fais une distinction claire entre les types de formation.
+        Pour chaque élément, fournis :
+        - degree: Le nom du diplôme, du titre (ex: 'Titre RNCP niveau 6') ou de la certification (ex: 'Core Designer Certification').
+        - institution: L'école, l'université ou la plateforme (ex: 'WILD CODE SCHOOL', 'DataIku', 'DataCamp').
+        - start_date: La date de début. Si non trouvée, retourne "Non spécifié".
+        - end_date: La date de fin. Si non trouvée, retourne "Non spécifié".
+
+        RÈGLES STRICTES :
+        1.  Si tu vois une certification comme "DataIku (core designer)", le diplôme est "Core Designer" et l'institution est "DataIku". NE PAS les mélanger.
+        2.  NE PAS extraire une simple compétence (ex: 'Python') comme une formation.
+        """
+    ),
+    agent=education_extractor_agent,
+    input_keys=["cv_content"],
+    expected_output=(
+        "Un tableau JSON VALIDE d'objets 'Formation' avec les clés : 'degree', 'institution', 'start_date', 'end_date'. "
+        "FORMAT EXACT: [{\"degree\": \"diplôme\", \"institution\": \"établissement\", \"start_date\": \"année\", \"end_date\": \"année\"]}"
+    )
+)
+
+task_extract_informations = Task(
+    description=(
+        "Voici le contenu du CV :\n\n{cv_content}\n\n"
+        "Votre tâche est d'extraire les informations de contact du candidat. Ces informations se trouvent généralement au début ou à la fin du CV, souvent sous une section intitulée 'CONTACT'.\n"
+        "Extrayez précisément :\n"
+        "- Le **Nom complet**.\n"
+        "- L'**Adresse e-mail**.\n"
+        "- Le **Numéro de téléphone**.\n"
+        "- La **Localisation** (ville ou région).\n"
+        "toutes les informations devront être normalisées, principalement le nom si il est en majuscule en titre. "
+    ),
+    agent=informations_personnelle_agent,
+    input_keys=["cv_content"],
+    expected_output=(
+        "Un dictionnaire JSON VALIDE 'informations_personnelles' contenant le nom, l'email, le numéro de téléphone et la localisation du candidat. "
+        "FORMAT EXACT: {\"nom\": \"nom\", \"email\": \"email\", \"numero_de_telephone\": \"tel\", \"localisation\": \"lieu\"}"
+    )
+)
+
+task_detect_reconversion = Task(
+    description=(
+        "En te basant sur les données extraites de la tâche `task_extract_experience`, analyse la chronologie des expériences professionnelles. "
+        "Ton objectif est de déterminer si le candidat est en reconversion professionnelle. "
+        "Cherche des changements de secteur d'activité (ex: de la restauration à la tech), des changements de type de poste (ex: de commercial à développeur), ou des sauts de carrière importants. "
+        "Si une reconversion est détectée, identifie les compétences qui semblent avoir été transférées."
+    ),
+    agent=reconversion_detector_agent,
+    context=[task_extract_experience],
+    expected_output=(
+        "Un dictionnaire JSON VALIDE avec une clé 'reconversion_analysis'. "
+        "Ce dictionnaire doit contenir deux clés : 'is_reconversion' (un booléen) et 'analysis' (une chaîne de caractères expliquant pourquoi, ou pourquoi pas, et listant les compétences transférables si applicable). "
+        "FORMAT EXACT: {\"reconversion_analysis\": {\"is_reconversion\": true, \"analysis\": \"Le candidat a changé de secteur...\"}}"
+    )
+)
+
+task_build_profile = Task(
+    description=(
+        "Ta mission est d'agir comme un architecte de données. En utilisant les extractions des tâches précédentes, "
+        "assemble un profil de candidat complet. "
+        "Le résultat final doit être un unique objet JSON, parfaitement valide."
+    ),
+    agent=ProfileBuilderAgent,
+    context=[
+        task_extract_informations,
+        task_extract_skills,
+        task_extract_experience,
+        task_extract_projects,
+        task_extract_education,
+        task_detect_reconversion
+    ],
+    expected_output=(
+        "Retourner un unique objet JSON valide. Cet objet doit avoir une seule clé à la racine : 'candidat'. "
+        "La valeur de cette clé sera un autre objet contenant toutes les informations assemblées. "
+        "Assure-toi que la syntaxe est parfaite, que tous les guillemets sont des guillemets doubles et qu'il n'y a aucune virgule finale. "
+        "Le JSON doit être immédiatement parsable par un programme.\n\n"
+        "FORMAT EXACT:\n"
+        "{\n"
+        "    \"candidat\": {\n"
+        "        \"informations_personnelles\": {\"nom\": \"...\", \"email\": \"...\", ...},\n"
+        "        \"compétences\": {\"hard_skills\": [...], \"soft_skills\": [...]},\n"
+        "        \"expériences\": [{\"Poste\": \"...\", ...}],\n"
+        "        \"projets\": {\"professional\": [...], \"personal\": [...]},\n"
+        "        \"formations\": [{\"degree\": \"...\", ...}],\n"
+        "        \"reconversion\": {\"is_reconversion\": true, \"analysis\": \"...\"}\n"
+        "    }\n"
+        "}"
+    )
+)

src/cv_parsing_agents.py

@@ -0,0 +1,291 @@
+"""
+Module pour le parsing de CV avec CrewAI
+"""
+import os
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Gestion des imports avec fallback
+try:
+    from src.crew.crew_pool import analyse_cv
+    CREW_POOL_AVAILABLE = True
+    logger.info("✅ crew_pool importé avec succès")
+except ImportError as e:
+    logger.error(f"❌ Erreur import crew_pool: {e}")
+    CREW_POOL_AVAILABLE = False
+    analyse_cv = None
+
+try:
+    from src.config import load_pdf
+    CONFIG_AVAILABLE = True
+    logger.info("✅ config importé avec succès")
+except ImportError as e:
+    logger.error(f"❌ Erreur import config: {e}")
+    CONFIG_AVAILABLE = False
+    load_pdf = None
+
+def clean_dict_keys(data):
+    """
+    Nettoie les clés d'un dictionnaire en les convertissant en string.
+    
+    Args:
+        data: Données à nettoyer (dict, list, ou autre)
+        
+    Returns:
+        Données nettoyées avec des clés string
+    """
+    if isinstance(data, dict):
+        return {str(key): clean_dict_keys(value) for key, value in data.items()}
+    elif isinstance(data, list):
+        return [clean_dict_keys(element) for element in data]
+    else:
+        return data
+
+class CvParserAgent:
+    """
+    Agent de parsing de CV utilisant CrewAI.
+    
+    Cette classe traite un fichier PDF de CV et en extrait les informations
+    structurées (compétences, expériences, formations, etc.)
+    """
+    
+    def __init__(self, pdf_path: str):
+        """
+        Initialise l'agent de parsing de CV.
+        
+        Args:
+            pdf_path (str): Chemin vers le fichier PDF à traiter
+            
+        Raises:
+            ValueError: Si le chemin du fichier est invalide
+            ImportError: Si les dépendances nécessaires ne sont pas disponibles
+        """
+        if not pdf_path or not isinstance(pdf_path, str):
+            raise ValueError("Le chemin du fichier PDF doit être une chaîne non vide")
+            
+        self.pdf_path = pdf_path
+        
+        # Vérifier que les dépendances sont disponibles
+        if not CREW_POOL_AVAILABLE:
+            logger.warning("CrewAI crew_pool non disponible - mode dégradé")
+        if not CONFIG_AVAILABLE:
+            logger.warning("Module config non disponible - mode dégradé")
+
+    def process(self) -> dict:
+        """
+        Traite le fichier PDF pour en extraire le contenu sous forme de JSON.
+        
+        Returns:
+            dict: Dictionnaire contenant les données extraites du CV, 
+                  ou données de fallback en cas d'erreur
+        """
+        logger.info(f"Début du traitement du CV : {self.pdf_path}")
+        
+        # Vérifier que le fichier existe
+        if not os.path.exists(self.pdf_path):
+            logger.error(f"Fichier PDF non trouvé: {self.pdf_path}")
+            return self._create_fallback_data()
+        
+        # Vérifier les dépendances
+        if not CREW_POOL_AVAILABLE or not CONFIG_AVAILABLE:
+            logger.error("Dépendances manquantes pour le traitement complet")
+            return self._create_fallback_data()
+        
+        try:
+            # Charger le contenu du PDF
+            cv_text_content = load_pdf(self.pdf_path)
+            if not cv_text_content or not cv_text_content.strip():
+                logger.error("Le PDF semble vide ou illisible")
+                return self._create_fallback_data()
+            
+            logger.info(f"PDF chargé, {len(cv_text_content)} caractères extraits")
+            
+            # Analyser avec CrewAI
+            crew_output = analyse_cv(cv_text_content)
+
+            if not crew_output or not hasattr(crew_output, 'raw') or not crew_output.raw.strip():
+                logger.error("L'analyse par le crew n'a pas retourné de résultat.")
+                return self._create_fallback_data()
+                
+            raw_string = crew_output.raw
+            logger.info(f"Résultat brut du crew: {raw_string[:200]}...")
+            
+            # Nettoyer le JSON si nécessaire
+            json_string_cleaned = self._clean_json_string(raw_string)
+            
+            # Parser le JSON
+            profile_data = json.loads(json_string_cleaned)
+            logger.info("Parsing JSON réussi")
+            
+            return clean_dict_keys(profile_data)
+
+        except json.JSONDecodeError as e:
+            logger.error(f"Erreur de décodage JSON : {e}")
+            if 'crew_output' in locals():
+                logger.error(f"Données brutes reçues : {crew_output.raw}")
+            return self._create_fallback_data()
+            
+        except Exception as e:
+            logger.error(f"Erreur inattendue dans CvParserAgent : {e}", exc_info=True)
+            return self._create_fallback_data()
+
+    def _clean_json_string(self, raw_string: str) -> str:
+        """
+        Nettoie une chaîne JSON brute en supprimant les blocs de code markdown.
+        
+        Args:
+            raw_string (str): Chaîne brute à nettoyer
+            
+        Returns:
+            str: Chaîne JSON nettoyée
+        """
+        json_string_cleaned = raw_string.strip()
+        
+        # Supprimer les blocs de code markdown si présents
+        if '```' in raw_string:
+            try:
+                # Chercher le bloc json
+                if '```json' in raw_string:
+                    json_part = raw_string.split('```json')[1].split('```')[0]
+                    json_string_cleaned = json_part.strip()
+                else:
+                    # Prendre le premier bloc de code
+                    parts = raw_string.split('```')
+                    if len(parts) >= 3:
+                        json_string_cleaned = parts[1].strip()
+            except IndexError:
+                logger.warning("Format de code block détecté mais mal formé")
+        
+        return json_string_cleaned
+
+    def _create_fallback_data(self) -> dict:
+        """
+        Crée des données de CV de fallback en cas d'erreur de traitement.
+        
+        Returns:
+            dict: Structure de données de CV par défaut
+        """
+        logger.info("Création de données de fallback pour le CV")
+        return {
+            "candidat": {
+                "informations_personnelles": {
+                    "nom": "Candidat Test",
+                    "email": "test@example.com",
+                    "numero_de_telephone": "Non spécifié",
+                    "localisation": "Non spécifiée"
+                },
+                "compétences": {
+                    "hard_skills": ["Python", "FastAPI", "Data Analysis"],
+                    "soft_skills": ["Communication", "Travail d'équipe", "Adaptabilité"]
+                },
+                "expériences": [
+                    {
+                        "Poste": "Développeur",
+                        "Entreprise": "Entreprise Test",
+                        "start_date": "2022",
+                        "end_date": "Aujourd'hui",
+                        "responsabilités": ["Développement d'applications", "Maintenance du code"]
+                    }
+                ],
+                "projets": {
+                    "professional": [
+                        {
+                            "title": "Projet Test",
+                            "role": "Développeur principal",
+                            "technologies": ["Python", "FastAPI"],
+                            "outcomes": ["Application fonctionnelle"]
+                        }
+                    ],
+                    "personal": []
+                },
+                "formations": [
+                    {
+                        "degree": "Formation en Informatique",
+                        "institution": "École Test",
+                        "start_date": "2020",
+                        "end_date": "2022"
+                    }
+                ],
+                "reconversion": {
+                    "is_reconversion": False,
+                    "analysis": "Pas de reconversion détectée - données de test"
+                }
+            }
+        }
+
+# Fonction utilitaire pour créer des données de fallback
+def create_fallback_cv_data(pdf_path: str = None) -> dict:
+    """
+    Fonction utilitaire pour créer des données de CV de fallback.
+    
+    Args:
+        pdf_path (str, optional): Chemin du fichier PDF (non utilisé dans le fallback)
+        
+    Returns:
+        dict: Structure de données de CV par défaut
+    """
+    return {
+        "candidat": {
+            "informations_personnelles": {
+                "nom": "Candidat Test",
+                "email": "test@example.com",
+                "numero_de_telephone": "Non spécifié",
+                "localisation": "Non spécifiée"
+            },
+            "compétences": {
+                "hard_skills": ["Python", "FastAPI", "Data Analysis"],
+                "soft_skills": ["Communication", "Travail d'équipe", "Adaptabilité"]
+            },
+            "expériences": [
+                {
+                    "Poste": "Développeur",
+                    "Entreprise": "Entreprise Test",
+                    "start_date": "2022",
+                    "end_date": "Aujourd'hui",
+                    "responsabilités": ["Développement d'applications", "Maintenance du code"]
+                }
+            ],
+            "projets": {
+                "professional": [
+                    {
+                        "title": "Projet Test",
+                        "role": "Développeur principal",
+                        "technologies": ["Python", "FastAPI"],
+                        "outcomes": ["Application fonctionnelle"]
+                    }
+                ],
+                "personal": []
+            },
+            "formations": [
+                {
+                    "degree": "Formation en Informatique",
+                    "institution": "École Test",
+                    "start_date": "2020",
+                    "end_date": "2022"
+                }
+            ],
+            "reconversion": {
+                "is_reconversion": False,
+                "analysis": "Pas de reconversion détectée - données de test"
+            }
+        }
+    }
+
+# Test des imports au chargement du module
+if __name__ == "__main__":
+    logger.info("Test du module cv_parsing_agents")
+    logger.info(f"CREW_POOL_AVAILABLE: {CREW_POOL_AVAILABLE}")
+    logger.info(f"CONFIG_AVAILABLE: {CONFIG_AVAILABLE}")
+    
+    # Test de création d'une instance
+    try:
+        agent = CvParserAgent("/tmp/test.pdf")
+        logger.info("✅ CvParserAgent créé avec succès")
+    except Exception as e:
+        logger.error(f"❌ Erreur création CvParserAgent: {e}")
+    
+    # Test des données de fallback
+    fallback_data = create_fallback_cv_data()
+    logger.info(f"✅ Données de fallback créées: {len(fallback_data)} clés")

src/{core/deep_learning_analyzer.py → deep_learning_analyzer.py}

@@ -1,56 +1,57 @@
-import torch
-from transformers import pipeline
-from sentence_transformers import SentenceTransformer, util
-from typing import List, Dict, Any
-
-class MultiModelInterviewAnalyzer:
-    def __init__(self):
-        self.sentiment_analyzer = pipeline(
-            "text-classification",
-            model="astrosbd/french_emotion_camembert",
-            return_all_scores=True,
-            device=0 if torch.cuda.is_available() else -1,
-        )
-        self.similarity_model = SentenceTransformer('all-MiniLM-L6-v2')
-        self.intent_classifier = pipeline(
-            "zero-shot-classification",
-            model="joeddav/xlm-roberta-large-xnli"
-        )
-
-    def analyze_sentiment(self, messages: List[Dict[str, str]]) -> List[List[Dict[str, Any]]]:
-        user_messages = [msg['content'] for msg in messages if msg['role'] == 'user']
-        if not user_messages:
-            return []
-        return self.sentiment_analyzer(user_messages)
-
-    def compute_semantic_similarity(self, messages: List[Dict[str, str]], job_requirements: str) -> float:
-        user_answers = " ".join([msg['content'] for msg in messages if msg['role'] == 'user'])
-        embedding_answers = self.similarity_model.encode(user_answers, convert_to_tensor=True)
-        embedding_requirements = self.similarity_model.encode(job_requirements, convert_to_tensor=True)
-        cosine_score = util.cos_sim(embedding_answers, embedding_requirements)
-        return cosine_score.item()
-
-    def classify_candidate_intent(self, messages: List[Dict[str, str]]) -> List[Dict[str, Any]]:
-        user_answers = [msg['content'] for msg in messages if msg['role'] == 'user']
-        if not user_answers:
-            return []
-        
-        candidate_labels = [
-            "parle de son expérience technique",
-            "exprime sa motivation",
-            "pose une question",
-            "exprime de l'incertitude ou du stress"
-        ]
-        return self.intent_classifier(user_answers, candidate_labels, multi_label=False)
-
-    def run_full_analysis(self, conversation_history: List[Dict[str, str]], job_requirements: str) -> Dict[str, Any]:
-        sentiment_results = self.analyze_sentiment(conversation_history)
-        similarity_score = self.compute_semantic_similarity(conversation_history, job_requirements)
-        intent_results = self.classify_candidate_intent(conversation_history)
-        
-        return {
-            "overall_similarity_score": round(similarity_score, 2),
-            "sentiment_analysis": sentiment_results,
-            "intent_analysis": intent_results,
-            "raw_transcript": conversation_history 
-        }
+import torch
+from transformers import pipeline
+from sentence_transformers import SentenceTransformer, util
+
+class MultiModelInterviewAnalyzer:
+    def __init__(self):
+        self.sentiment_analyzer = pipeline(
+            "text-classification",
+            model="astrosbd/french_emotion_camembert",
+            return_all_scores=True,
+            device=0 if torch.cuda.is_available() else -1,
+        )
+        self.similarity_model = SentenceTransformer('all-MiniLM-L6-v2')
+        self.intent_classifier = pipeline(
+            "zero-shot-classification",
+            model="joeddav/xlm-roberta-large-xnli"
+            #device=0 if torch.cuda.is_available() else -1,
+        )
+
+    def analyze_sentiment(self, messages):
+        user_messages = [msg['content'] for msg in messages if msg['role'] == 'user']
+        if not user_messages:
+            return []
+        sentiments = self.sentiment_analyzer(user_messages)
+        return sentiments
+
+    def compute_semantic_similarity(self, messages, job_requirements):
+        user_answers = " ".join([msg['content'] for msg in messages if msg['role'] == 'user'])
+        embedding_answers = self.similarity_model.encode(user_answers, convert_to_tensor=True)
+        embedding_requirements = self.similarity_model.encode(job_requirements, convert_to_tensor=True)
+        cosine_score = util.cos_sim(embedding_answers, embedding_requirements)
+        return cosine_score.item()
+
+    def classify_candidate_intent(self, messages):
+        user_answers = [msg['content'] for msg in messages if msg['role'] == 'user']
+        if not user_answers:
+            return []
+        candidate_labels = [
+            "parle de son expérience technique",
+            "exprime sa motivation",
+            "pose une question",
+            "exprime de l’incertitude ou du stress"
+        ]
+        classifications = self.intent_classifier(user_answers, candidate_labels, multi_label=False)
+        return classifications
+
+    def run_full_analysis(self, conversation_history, job_requirements):
+        sentiment_results = self.analyze_sentiment(conversation_history)
+        similarity_score = self.compute_semantic_similarity(conversation_history, job_requirements)
+        intent_results = self.classify_candidate_intent(conversation_history)
+        analysis_output = {
+            "overall_similarity_score": round(similarity_score, 2),
+            "sentiment_analysis": sentiment_results,
+            "intent_analysis": intent_results,
+            "raw_transcript": conversation_history 
+        }
+        return analysis_output

src/{services/interview_service.py → interview_simulator/entretient_version_prod.py}

@@ -4,12 +4,16 @@ import json
 from typing import Dict, List, Any, Annotated
 from typing_extensions import TypedDict
 
-from langchain_core.messages import AIMessage, SystemMessage, HumanMessage
+from langchain_core.messages import AIMessage, SystemMessage, HumanMessage, ToolMessage
+from langchain_groq import ChatGroq
 from langgraph.graph import StateGraph, START, END
 from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode 
 from langchain_openai import ChatOpenAI
 
 from src.config import read_system_prompt, format_cv
+from src.crew.crew_pool import interview_analyser 
+
 
 class State(TypedDict):
     messages: Annotated[list, add_messages]
@@ -24,7 +28,9 @@ class InterviewProcessor:
         self.job_offer = job_offer
         self.cv_data = cv_document['candidat']
         self.conversation_history = conversation_history
+        self.tools = [interview_analyser]
         self.llm = self._get_llm()
+        self.llm_with_tools = self.llm.bind_tools(self.tools)
 
         self.system_prompt_template = self._load_prompt_template()
         self.graph = self._build_graph()
@@ -32,73 +38,59 @@ class InterviewProcessor:
     def _get_llm(self) -> ChatOpenAI:
         openai_api_key = os.getenv("OPENAI_API_KEY")
         return ChatOpenAI(
-            temperature=0.6, 
-            model_name="gpt-4o-mini", 
-            api_key=openai_api_key
-        )
+        temperature=0.6, 
+        model_name="gpt-4o-mini", 
+        api_key=openai_api_key
+    )
 
     def _load_prompt_template(self) -> str:
-        return read_system_prompt('prompts/rag_prompt_old.txt') 
-
-    def _extract_skills_summary(self) -> str:
-        """Extrait un résumé simple des compétences avec niveaux"""
-        competences = self.cv_data.get('analyse_competences', [])
-        if not competences:
-            return "Aucune analyse de compétences disponible."
-        
-        summary = []
-        for comp in competences:
-            skill = comp.get('skill', '')
-            level = comp.get('level', 'débutant')
-            summary.append(f"{skill}: {level}")
-        
-        return "Niveaux de compétences du candidat: " + " | ".join(summary)
-
-    def _extract_reconversion_info(self) -> str:
-        """Extrait les infos de reconversion"""
-        reconversion = self.cv_data.get('reconversion', {})
-        if not reconversion:
-            return ""
-        
-        is_reconversion = reconversion.get('is_reconversion', False)
-        if not is_reconversion:
-            return ""
-        
-        analysis = reconversion.get('analysis', '')
-        return f"CANDIDAT EN RECONVERSION: {analysis}"
+        return read_system_prompt('prompts/rag_prompt_old.txt')
 
     def _chatbot_node(self, state: State) -> dict:
+        if state["messages"] and isinstance(state["messages"][-1], ToolMessage):
+            tool_message = state["messages"][-1]
+            return {"messages": [AIMessage(content=tool_message.content)]}
         messages = state["messages"]
         formatted_cv_str = format_cv(self.cv_data)
-        
-        # Extractions simples
-        skills_summary = self._extract_skills_summary()
-        reconversion_info = self._extract_reconversion_info()
 
-        # Formatage du prompt système avec les nouvelles données
+        mission = self.job_offer.get('mission', 'Non spécifiée')
+        profil_recherche = self.job_offer.get('profil_recherche', 'Non spécifié')
+        competences = self.job_offer.get('competences', 'Non spécifiées')
+        pole = self.job_offer.get('pole', 'Non spécifié')
         system_prompt = self.system_prompt_template.format(
             entreprise=self.job_offer.get('entreprise', 'notre entreprise'),
             poste=self.job_offer.get('poste', 'ce poste'),
-            mission=self.job_offer.get('mission', 'Non spécifiée'),
-            profil_recherche=self.job_offer.get('profil_recherche', 'Non spécifié'),
-            competences=self.job_offer.get('competences', 'Non spécifiées'),
-            pole=self.job_offer.get('pole', 'Non spécifié'),
-            cv=formatted_cv_str,
-            skills_analysis=skills_summary,
-            reconversion_analysis=reconversion_info
+            mission=mission,
+            profil_recherche=profil_recherche,
+            competences=competences,
+            pole=pole,
+            cv=formatted_cv_str
         )
-        
         llm_messages = [SystemMessage(content=system_prompt)] + messages
-        response = self.llm.invoke(llm_messages)
+        response = self.llm_with_tools.invoke(llm_messages)
         return {"messages": [response]}
 
+    def _route_after_chatbot(self, state: State) -> str:
+        last_message = state["messages"][-1]
+        if last_message.tool_calls:
+            return "call_tool"
+        return END
+
     def _build_graph(self) -> any:
         graph_builder = StateGraph(State)
         
         graph_builder.add_node("chatbot", self._chatbot_node)
-        graph_builder.add_edge(START, "chatbot")
-        graph_builder.add_edge("chatbot", END)
-        
+        graph_builder.add_node("call_tool", ToolNode(self.tools))        
+        graph_builder.add_edge(START, "chatbot")        
+        graph_builder.add_conditional_edges(
+            "chatbot",
+            self._route_after_chatbot,
+            {
+                "call_tool": "call_tool", 
+                END: END                  
+            }
+        )
+        graph_builder.add_edge("call_tool", "chatbot")
         return graph_builder.compile()
 
     def run(self, messages: List[Dict[str, Any]]) -> Dict[str, Any]:

src/models.py

@@ -1,37 +0,0 @@
-import logging
-from typing import Dict, Any, Optional
-
-logger = logging.getLogger(__name__)
-
-def load_all_models() -> Dict[str, Any]:
-    models = {
-        "status": False,
-        "deep_learning_analyzer": None,
-        "rag_handler": None,
-        "llm": None
-    }
-    
-    try:
-        from src.core.deep_learning_analyzer import MultiModelInterviewAnalyzer
-        models["deep_learning_analyzer"] = MultiModelInterviewAnalyzer()
-        logger.info("✅ Deep Learning Analyzer chargé")
-    except Exception as e:
-        logger.error(f"❌ Erreur chargement Deep Learning Analyzer: {e}")
-    
-    try:
-        from src.core.rag_handler import get_rag_handler
-        models["rag_handler"] = get_rag_handler()
-        logger.info("✅ RAG Handler chargé")
-    except Exception as e:
-        logger.error(f"❌ Erreur chargement RAG Handler: {e}")
-    
-    try:
-        from src.config import crew_openai
-        models["llm"] = crew_openai()
-        logger.info("✅ LLM chargé")
-    except Exception as e:
-        logger.error(f"❌ Erreur chargement LLM: {e}")
-    
-    models["status"] = all(v is not None for k, v in models.items() if k != "status")
-    
-    return models

src/rag_handler.py

@@ -0,0 +1,202 @@
+import os
+import logging
+from typing import Optional
+from langchain_community.document_loaders import DirectoryLoader, TextLoader
+from langchain_community.vectorstores import FAISS
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+logger = logging.getLogger(__name__)
+
+# Variables globales pour l'initialisation différée
+_embeddings_model = None
+_rag_handler_instance = None
+
+# Utiliser /tmp qui est toujours writable dans les conteneurs
+VECTOR_STORE_PATH = "/tmp/vector_store" 
+
+def get_embeddings_model():
+    """Obtient le modèle d'embeddings avec initialisation différée."""
+    global _embeddings_model
+    if _embeddings_model is None:
+        try:
+            from langchain_huggingface import HuggingFaceEmbeddings
+            logger.info("Initialisation du modèle d'embeddings...")
+            _embeddings_model = HuggingFaceEmbeddings(
+                model_name='sentence-transformers/all-MiniLM-L6-v2',
+                model_kwargs={'device': 'cpu'},
+                encode_kwargs={'normalize_embeddings': True}
+            )
+            logger.info("✅ Modèle d'embeddings initialisé avec succès")
+        except Exception as e:
+            logger.error(f"❌ Erreur lors de l'initialisation du modèle d'embeddings: {e}")
+            _embeddings_model = None
+    return _embeddings_model
+
+class RAGHandler:
+    def __init__(self, knowledge_base_path: str = "/app/knowledge_base", lazy_init: bool = True):
+        """
+        Initialise le RAG Handler.
+        
+        Args:
+            knowledge_base_path (str): Le chemin vers le dossier contenant les documents de connaissances (.md).
+            lazy_init (bool): Si True, initialise le vector store seulement lors de la première utilisation.
+        """
+        self.knowledge_base_path = knowledge_base_path
+        self.embeddings = None
+        self.vector_store = None
+        self._initialized = False
+        
+        # S'assurer que le répertoire /tmp/vector_store existe
+        os.makedirs(VECTOR_STORE_PATH, exist_ok=True)
+        
+        if not lazy_init:
+            self._initialize()
+
+    def _initialize(self):
+        """Initialise le RAG Handler de manière différée."""
+        if self._initialized:
+            return
+        
+        try:
+            logger.info("Initialisation du RAG Handler...")
+            self.embeddings = get_embeddings_model()
+            
+            if self.embeddings is None:
+                logger.error("Impossible d'initialiser les embeddings")
+                return
+            
+            self.vector_store = self._load_or_create_vector_store(self.knowledge_base_path)
+            self._initialized = True
+            logger.info("✅ RAG Handler initialisé avec succès")
+            
+        except Exception as e:
+            logger.error(f"❌ Erreur lors de l'initialisation du RAG Handler: {e}")
+            self._initialized = False
+
+    def _load_documents(self, path: str) -> list:
+        """Charge les documents depuis un chemin de répertoire spécifié."""
+        try:
+            if not os.path.exists(path):
+                logger.warning(f"Répertoire {path} non trouvé")
+                return []
+                
+            loader = DirectoryLoader(
+                path,
+                glob="**/*.md", 
+                loader_cls=TextLoader,
+                loader_kwargs={"encoding": "utf-8"}
+            )
+            logger.info(f"Chargement des documents depuis : {path}")
+            documents = loader.load()
+            logger.info(f"✅ {len(documents)} documents chargés")
+            return documents
+        except Exception as e:
+            logger.error(f"❌ Erreur lors du chargement des documents: {e}")
+            return []
+
+    def _create_vector_store(self, knowledge_base_path: str) -> Optional[FAISS]:
+        """Crée et sauvegarde la base de données vectorielle à partir des documents."""
+        try:
+            documents = self._load_documents(knowledge_base_path)
+            if not documents:
+                logger.warning("Aucun document trouvé - création d'un vector store vide")
+                # Créer un document fictif pour initialiser le vector store
+                from langchain.schema import Document
+                dummy_doc = Document(
+                    page_content="Document de test pour initialiser le vector store",
+                    metadata={"source": "dummy"}
+                )
+                documents = [dummy_doc]
+            
+            logger.info(f"{len(documents)} documents chargés. Création des vecteurs...")
+            text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+            texts = text_splitter.split_documents(documents)
+            
+            vector_store = FAISS.from_documents(texts, self.embeddings)
+            
+            # Sauvegarder dans /tmp
+            try:
+                vector_store.save_local(VECTOR_STORE_PATH)
+                logger.info(f"✅ Vector store cr��é et sauvegardé dans : {VECTOR_STORE_PATH}")
+            except Exception as save_error:
+                logger.warning(f"⚠️ Impossible de sauvegarder le vector store: {save_error}")
+                # Continuer sans sauvegarde - le vector store reste en mémoire
+            
+            return vector_store
+            
+        except Exception as e:
+            logger.error(f"❌ Erreur lors de la création du vector store: {e}")
+            return None
+
+    def _load_or_create_vector_store(self, knowledge_base_path: str) -> Optional[FAISS]:
+        """Charge le vector store s'il existe, sinon le crée."""
+        try:
+            index_path = os.path.join(VECTOR_STORE_PATH, "index.faiss")
+            if os.path.exists(index_path):
+                logger.info(f"Chargement du vector store existant depuis : {VECTOR_STORE_PATH}")
+                return FAISS.load_local(
+                    VECTOR_STORE_PATH, 
+                    embeddings=self.embeddings, 
+                    allow_dangerous_deserialization=True 
+                )
+            else:
+                logger.info("Aucun vector store trouvé. Création d'un nouveau...")
+                return self._create_vector_store(knowledge_base_path)
+        except Exception as e:
+            logger.error(f"❌ Erreur lors du chargement/création du vector store: {e}")
+            # En cas d'échec total, retourner None plutôt que planter
+            return None
+
+    def get_relevant_feedback(self, query: str, k: int = 1) -> list[str]:
+        """Recherche les k conseils les plus pertinents pour une requête."""
+        # Initialisation différée si nécessaire
+        if not self._initialized:
+            self._initialize()
+        
+        if not self.vector_store:
+            logger.warning("Vector store non disponible - retour de conseils génériques")
+            return [
+                "Préparez vos réponses aux questions comportementales",
+                "Montrez votre motivation pour le poste",
+                "Donnez des exemples concrets de vos réalisations"
+            ]
+        
+        try:
+            results = self.vector_store.similarity_search(query, k=k)
+            feedback = [doc.page_content for doc in results if doc.page_content.strip()]
+            
+            # Fallback si pas de résultats pertinents
+            if not feedback:
+                return ["Conseil général: Préparez-vous bien pour les entretiens futurs."]
+                
+            return feedback
+        except Exception as e:
+            logger.error(f"❌ Erreur lors de la recherche: {e}")
+            return ["Conseil général: Travaillez sur vos compétences de communication."]
+
+# Fonction pour obtenir une instance partagée
+def get_rag_handler() -> Optional[RAGHandler]:
+    """Obtient une instance partagée du RAG Handler."""
+    global _rag_handler_instance
+    if _rag_handler_instance is None:
+        try:
+            _rag_handler_instance = RAGHandler(lazy_init=True)
+        except Exception as e:
+            logger.error(f"❌ Erreur lors de la création du RAG Handler: {e}")
+            _rag_handler_instance = None
+    return _rag_handler_instance
+
+if __name__ == '__main__':
+    print("Test du RAG Handler avec /tmp vector store...")
+    handler = RAGHandler(knowledge_base_path="/app/knowledge_base", lazy_init=False)
+    
+    test_query = "gestion du stress"
+    feedback = handler.get_relevant_feedback(test_query, k=2)
+    
+    print(f"\nTest de recherche pour : '{test_query}'")
+    if feedback:
+        print("Feedback trouvé :")
+        for f in feedback:
+            print(f"- {f[:150]}...")
+    else:
+        print("Aucun feedback trouvé.")

src/scoring_engine.py

@@ -0,0 +1,102 @@
+import json
+from datetime import datetime
+
+# Pondérations basées sur la fiche projet
+CONTEXT_WEIGHTS = {
+    "formations": 0.3,
+    "projets": 0.6,
+    "expériences": 0.8,
+    "multiple": 1.0
+}
+
+# Facteurs pour la formule de scoring
+ALPHA = 0.5  # Poids du contexte
+BETA = 0.3   # Poids de la fréquence
+GAMMA = 0.2  # Poids de la profondeur (durée)
+
+class ContextualScoringEngine:
+    def __init__(self, cv_data: dict):
+        self.cv_data = cv_data.get("candidat", {})
+        self.full_text = self._get_full_text_from_cv()
+
+    def _get_full_text_from_cv(self) -> str:
+        """Concatène tout le contenu textuel du CV pour le comptage de fréquence."""
+        return json.dumps(self.cv_data, ensure_ascii=False).lower()
+
+    def _parse_date(self, date_str: str) -> datetime:
+        """Parse une date, en gérant les cas spéciaux comme 'Aujourd'hui'."""
+        if not date_str or date_str.lower() == "non spécifié":
+            return None
+        if date_str.lower() == "aujourd'hui":
+            return datetime.now()
+        try:
+            return datetime.strptime(date_str, "%Y")
+        except ValueError:
+            return None
+
+    def _calculate_duration_in_years(self, start_date_str: str, end_date_str: str) -> float:
+        """Calcule la durée d'une expérience en années."""
+        start_date = self._parse_date(start_date_str)
+        end_date = self._parse_date(end_date_str)
+        if start_date and end_date:
+            return abs((end_date - start_date).days / 365.25)
+        return 0.5 
+
+    def calculate_scores(self) -> dict:
+        """Calcule les scores pondérés pour toutes les hard skills."""
+        skills = self.cv_data.get("compétences", {}).get("hard_skills", [])
+        if not skills:
+            return {}
+
+        scored_skills = []
+        for skill in skills:
+            skill_lower = skill.lower()
+            contexts = []
+            if skill_lower in json.dumps(self.cv_data.get("formations", []), ensure_ascii=False).lower():
+                contexts.append(CONTEXT_WEIGHTS["formations"])
+            if skill_lower in json.dumps(self.cv_data.get("projets", []), ensure_ascii=False).lower():
+                contexts.append(CONTEXT_WEIGHTS["projets"])
+            if skill_lower in json.dumps(self.cv_data.get("expériences", []), ensure_ascii=False).lower():
+                contexts.append(CONTEXT_WEIGHTS["expériences"])
+            
+            if len(contexts) > 1:
+                context_score = CONTEXT_WEIGHTS["multiple"]
+            elif contexts:
+                context_score = contexts[0]
+            else:
+                context_score = 0.1 
+
+            # 2. Fréquence de mention
+            frequency_score = self.full_text.count(skill_lower)
+
+            # 3. Profondeur d'utilisation (durée max en années)
+            max_duration = 0
+            for exp in self.cv_data.get("expériences", []):
+                if skill_lower in json.dumps(exp, ensure_ascii=False).lower():
+                    duration = self._calculate_duration_in_years(exp.get("start_date"), exp.get("end_date"))
+                    if duration > max_duration:
+                        max_duration = duration
+            depth_score = max_duration
+
+            # Normalisation simple (peut être affinée)
+            normalized_frequency = 1 - (1 / (1 + frequency_score))
+            normalized_depth = 1 - (1 / (1 + depth_score))
+
+            # Calcul du score final
+            final_score = (ALPHA * context_score) + \
+                          (BETA * normalized_frequency) + \
+                          (GAMMA * normalized_depth)
+            
+            scored_skills.append({
+                "skill": skill,
+                "score": round(final_score, 2),
+                "details": {
+                    "context_score": context_score,
+                    "frequency": frequency_score,
+                    "max_duration_years": round(depth_score, 1)
+                }
+            })
+        
+        # Trier par score décroissant
+        scored_skills.sort(key=lambda x: x["score"], reverse=True)
+        return {"analyse_competences": scored_skills}

src/services/analysis_service.py

@@ -1,97 +0,0 @@
-import json
-import logging
-from typing import Dict, List, Any
-from crewai import Agent, Task, Crew, Process
-
-logger = logging.getLogger(__name__)
-
-class AnalysisService:
-    def __init__(self, models: Dict[str, Any]):
-        self.models = models
-        self.analyzer = models.get("deep_learning_analyzer")
-        self.rag_handler = models.get("rag_handler")
-        self.llm = models.get("llm")
-        self._create_report_agent()
-
-    def _create_report_agent(self):
-        self.report_agent = Agent(
-            role='Rédacteur de Rapports Synthétiques',
-            goal='Générer un feedback pertinent à partir du déroulement de l\'entretien',
-            backstory=(
-                "Spécialisé dans le recrutement et les ressources humaines, capable d'évaluer les candidats "
-                "sur la communication et la pertinence des réponses en fonction des questions posées, rédige "
-                "en un rapport clair, un feedback détaillé sur le candidat."
-            ),
-            allow_delegation=False,
-            verbose=False,
-            llm=self.llm
-        )
-
-    def run_analysis(self, conversation_history: List[Dict[str, Any]], job_description: str) -> Dict[str, Any]:
-        if not self.analyzer:
-            return {"error": "Analyzer non disponible"}
-
-        structured_analysis = self.analyzer.run_full_analysis(conversation_history, job_description)
-        
-        rag_feedback = []
-        if self.rag_handler:
-            rag_feedback = self._get_contextual_feedback(structured_analysis)
-        
-        report = self._generate_final_report(structured_analysis, rag_feedback)
-        
-        return report
-
-    def _get_contextual_feedback(self, structured_analysis: Dict[str, Any]) -> List[str]:
-        rag_feedback = []
-        
-        if structured_analysis.get("intent_analysis"):
-            for intent in structured_analysis["intent_analysis"]:
-                query = f"Conseils pour un candidat qui cherche à {intent['labels'][0]}"
-                rag_feedback.extend(self.rag_handler.get_relevant_feedback(query))
-        
-        if structured_analysis.get("sentiment_analysis"):
-            for sentiment_group in structured_analysis["sentiment_analysis"]:
-                for sentiment in sentiment_group:
-                    if sentiment['label'] == 'stress' and sentiment['score'].item() > 0.6:
-                        rag_feedback.extend(
-                            self.rag_handler.get_relevant_feedback("gestion du stress en entretien")
-                        )
-        
-        return list(set(rag_feedback))
-
-    def _generate_final_report(
-        self, 
-        structured_analysis: Dict[str, Any], 
-        rag_feedback: List[str]
-    ) -> Dict[str, Any]:
-        
-        task = Task(
-            description=(
-                f"Tu es un rédacteur expert en RH. Ta mission est de rédiger un rapport d'évaluation final. "
-                f"Tu dois utiliser deux sources d'information principales : "
-                f"1. Les données d'analyse structurées de l'entretien : '{json.dumps(structured_analysis, indent=2)}'. "
-                f"2. Une liste de conseils et de feedback pertinents issus de notre base de connaissances : '{chr(10).join(rag_feedback)}'. "
-                f"Ta tâche est de synthétiser ces informations en un rapport cohérent et actionnable."
-            ),
-            expected_output=(
-                "Un rapport final exceptionnel basé sur l'analyse fournie. Le rapport doit être structuré comme suit: "
-                "1. **Résumé et Score d'Adéquation** : Synthétise le score de similarité sémantique et donne un aperçu global. "
-                "2. **Analyse Comportementale** : Interprète les résultats de l'analyse de sentiment et d'intention pour décrire le comportement du candidat. "
-                "3. **Adéquation Sémantique avec le Poste** : Explique ce que signifie le score de similarité. "
-                "4. **Points Forts & Axes d'Amélioration Personnalisés** : Utilise les données d'analyse pour identifier les points à améliorer. "
-                "Ensuite, intègre de manière fluide et naturelle les conseils pertinents pour proposer des pistes d'amélioration concrètes et personnalisées. "
-                "5. **Recommandation Finale**."
-            ),
-            agent=self.report_agent
-        )
-
-        crew = Crew(
-            agents=[self.report_agent],
-            tasks=[task],
-            process=Process.sequential,
-            verbose=False,
-            telemetry=False
-        )
-
-        result = crew.kickoff()
-        return {"analysis_report": result.raw if hasattr(result, 'raw') else str(result)}

src/services/graph_service.py

@@ -1,193 +0,0 @@
-import os
-import logging
-import json
-from typing import TypedDict, Annotated, Sequence, Dict, Any, List
-
-from langchain_openai import ChatOpenAI
-from langchain_core.runnables import Runnable
-from langchain_core.messages import BaseMessage, AIMessage, HumanMessage
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langgraph.graph import StateGraph, END
-from langgraph.prebuilt import ToolNode
-
-from tools.analysis_tools import trigger_interview_analysis
-
-class AgentState(TypedDict):
-    messages: Annotated[Sequence[BaseMessage], lambda x, y: x + y]
-    user_id: str
-    job_offer_id: str
-    job_description: str
-
-class GraphInterviewProcessor:
-    """
-    Cette classe encapsule la logique d'un entretien en utilisant LangGraph.
-    Elle prépare toutes les données nécessaires à l'initialisation.
-    """
-    def __init__(self, payload: Dict[str, Any]):
-        logging.info("Initialisation de 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 dans le payload.")
-
-        self.system_prompt_template = self._load_prompt_template('prompts/rag_prompt_old.txt')
-        self.formatted_cv_str = self._format_cv_for_prompt()
-        self.skills_summary = self._extract_skills_summary()
-        self.reconversion_info = self._extract_reconversion_info()
-        
-        self.agent_runnable = self._create_agent_runnable()
-        self.graph = self._build_graph()
-        logging.info("GraphInterviewProcessor initialisé avec succès.")
-
-    def _load_prompt_template(self, file_path: str) -> str:
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                return f.read()
-        except FileNotFoundError:
-            logging.error(f"Fichier prompt introuvable: {file_path}")
-            return "Vous êtes un assistant RH."
-
-    def _format_cv_for_prompt(self) -> str:
-        return json.dumps(self.cv_data, indent=2, ensure_ascii=False)
-
-    def _extract_skills_summary(self) -> str:
-        competences = self.cv_data.get('analyse_competences', [])
-        if not competences: return "Aucune analyse de compétences disponible."
-        summary = [f"{comp.get('skill', '')}: {comp.get('level', 'débutant')}" for comp in competences]
-        return "Niveaux de compétences du candidat: " + " | ".join(summary)
-
-    def _extract_reconversion_info(self) -> str:
-        reconversion = self.cv_data.get('reconversion', {})
-        if reconversion.get('is_reconversion'):
-            return f"CANDIDAT EN RECONVERSION: {reconversion.get('analysis', '')}"
-        return "Le candidat n'est pas identifié comme étant en reconversion."
-
-    def _create_agent_runnable(self) -> Runnable:
-        """Crée une chaîne (runnable) qui agit comme notre agent."""
-        prompt = ChatPromptTemplate.from_messages([
-            ("system", "{system_prompt_content}"),
-            MessagesPlaceholder(variable_name="messages"),
-        ])
-        llm = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-4o-mini", temperature=0.7)
-        tools = [trigger_interview_analysis]
-        llm_with_tools = llm.bind_tools(tools)
-        return prompt | llm_with_tools
-
-    def _agent_node(self, state: AgentState):
-        """Prépare le prompt et appelle le runnable de l'agent."""
-        job_description_str = json.dumps(self.job_offer, ensure_ascii=False)
-        
-        system_prompt_content = self.system_prompt_template.format(
-            user_id=state['user_id'],
-            job_offer_id=state['job_offer_id'],
-            entreprise=self.job_offer.get('entreprise', 'notre entreprise'),
-            poste=self.job_offer.get('poste', 'ce poste'),
-            mission=self.job_offer.get('mission', 'Non spécifiée'),
-            profil_recherche=self.job_offer.get('profil_recherche', 'Non spécifié'),
-            competences=self.job_offer.get('competences', 'Non spécifiées'),
-            pole=self.job_offer.get('pole', 'Non spécifié'),
-            cv=self.formatted_cv_str,
-            skills_analysis=self.skills_summary,
-            reconversion_analysis=self.reconversion_info,
-            job_description=job_description_str
-        )
-        
-        response = self.agent_runnable.invoke({
-            "system_prompt_content": system_prompt_content,
-            "messages": state["messages"]
-        })
-
-        return {"messages": [response]}
-
-    def _router(self, state: AgentState) -> str:
-        """Route le flux du graphe en fonction de la dernière réponse de l'agent."""
-        last_message = state["messages"][-1]
-        if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
-            if any(tool_call.get('name') == 'trigger_interview_analysis' for tool_call in last_message.tool_calls):
-                return "call_final_tool"
-            return "call_tool"
-        return "end_turn"
-
-    def _final_analysis_node(self, state: AgentState):
-        """
-        Appelle l'outil d'analyse finale. Construit les arguments manuellement
-        à partir de l'état du graphe pour garantir la fiabilité.
-        """
-        conversation_history = []
-        for msg in state["messages"]:
-            if isinstance(msg, HumanMessage):
-                role = "user"
-            elif isinstance(msg, AIMessage):
-                role = "assistant"
-            else:
-                continue
-            conversation_history.append({"role": role, "content": msg.content})
-
-        tool_input = {
-            "user_id": state['user_id'],
-            "job_offer_id": state['job_offer_id'],
-            "job_description": state['job_description'],
-            "conversation_history": conversation_history
-        }
-        
-        trigger_interview_analysis.invoke(tool_input)
-        return {}
-
-    def _build_graph(self) -> any:
-        """Construit et compile le graphe d'états."""
-        tool_node = ToolNode([trigger_interview_analysis])
-        
-        graph = StateGraph(AgentState)
-        graph.add_node("agent", self._agent_node)
-        graph.add_node("tools", tool_node)
-        graph.add_node("final_tool_node", self._final_analysis_node) 
-        
-        graph.set_entry_point("agent")
-        
-        graph.add_conditional_edges(
-            "agent",
-            self._router,
-            {
-                "call_tool": "tools",
-                "call_final_tool": "final_tool_node",
-                "end_turn": END
-            }
-        )
-        
-        graph.add_edge("tools", "agent")
-        graph.add_edge("final_tool_node", END)
-        
-        return graph.compile()
-
-    def invoke(self, messages: List[Dict[str, Any]]):
-        """Point d'entrée pour lancer une conversation dans le graphe."""
-        langchain_messages = [HumanMessage(content=m["content"]) if m["role"] == "user" else AIMessage(content=m["content"]) for m in messages]
-        
-        if not langchain_messages:
-            logging.info("Historique de conversation vide. Ajout d'un message de démarrage interne.")
-            langchain_messages.append(HumanMessage(content="Bonjour, je suis prêt à commencer l'entretien."))
-            
-        initial_state = {
-            "user_id": self.user_id,
-            "job_offer_id": self.job_offer_id,
-            "messages": langchain_messages,
-            "job_description": json.dumps(self.job_offer, ensure_ascii=False),
-        }
-        
-        final_state = self.graph.invoke(initial_state)
-        
-        if not final_state or not final_state.get('messages'):
-            logging.error("L'état final est vide ou ne contient pas de messages.")
-            return {"response": "Erreur: Impossible de générer une réponse.", "status": "finished"}
-        last_message = final_state['messages'][-1]
-        status = "finished" if hasattr(last_message, 'tool_calls') and last_message.tool_calls else "interviewing"
-        response_content = last_message.content
-        
-        return {
-            "response": response_content,
-            "status": status
-        }

tools/analysis_tools.py

@@ -1,56 +0,0 @@
-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.v1 import BaseModel, Field
-from typing import List, Dict, Any
-from src.models import load_all_models
-from pymongo import MongoClient
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class InterviewAnalysisArgs(BaseModel):
-    """Arguments for the trigger_interview_analysis tool."""
-    user_id: str = Field(..., description="The unique identifier for the user, provided in the system prompt.")
-    job_offer_id: str = Field(..., description="The unique identifier for the job offer, provided in the system prompt.")
-    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.")
-
-@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]]):
-    """
-    Call this tool to end the interview and launch the final analysis.
-    You MUST provide all arguments: user_id, job_offer_id, job_description, and the complete conversation_history.
-    """
-    try:
-        logger.info(f"Outil 'trigger_interview_analysis' appelé pour user_id: {user_id} et job_offer_id: {job_offer_id}")
-        if '@' in user_id or ' ' in job_offer_id:
-             logger.error(f"Appel de l'outil avec des données invalides. User ID: {user_id}, Job Offer ID: {job_offer_id}")
-             return "Erreur: Appel de l'outil avec des paramètres invalides. L'analyse n'a pas pu être lancée."
-        mongo_client = MongoClient(os.getenv("MONGO_URI"))
-        db = mongo_client[os.getenv("MONGO_DB_NAME")]
-        collection = db[os.getenv("MONGO_FEEDBACK")]
-        
-        models = load_all_models()
-        analysis_service = AnalysisService(models=models)
-        feedback_data = analysis_service.run_analysis(
-            conversation_history=conversation_history,
-            job_description=job_description
-        )
-        mongo_document = {
-            "user_id": user_id,
-            "job_offer_id": job_offer_id,
-            "feedback_data": feedback_data,
-            "updated_at": datetime.utcnow()
-        }
-        result = collection.insert_one(mongo_document)
-        logger.info(f"Analyse pour l'utilisateur {user_id} terminée et sauvegardée dans MongoDB avec l'ID: {result.inserted_id}")
-        
-        return "L'analyse a été déclenchée et terminée avec succès."
-
-    except Exception as e:
-        logger.error(f"Erreur dans l'outil d'analyse : {e}", exc_info=True)
-        return "Une erreur est survenue lors du lancement de l'analyse."