Upload 39 files

docker-compose.yml

@@ -0,0 +1,47 @@
+version: '3.8'
+
+services:
+
+  model-api:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: projet_fil_rouge_api-model-api-1
+    ports:
+      - "9500:8000"
+    env_file:
+      - .env
+    restart: unless-stopped
+    environment:
+      - HF_HOME=/app/cache 
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    volumes:
+      - ./.cache/huggingface:/app/cache
+
+  worker:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: celery -A tasks.worker_celery:celery_app worker --loglevel=info
+    restart: unless-stopped
+    depends_on:
+      - model-api
+      - redis
+    env_file:
+      - .env
+    environment:
+      - HF_HOME=/app/cache
+      - CELERY_BROKER_URL=redis://redis:6379/0
+      - CELERY_RESULT_BACKEND=redis://redis:6379/0
+    volumes:
+      - ./.cache/huggingface:/app/cache
+
+  redis:
+    image: "redis:alpine"
+    ports:
+      - "6379:6379"
+    restart: unless-stopped
+
+volumes:
+  huggingface_cache:

knowledge_base/soft_skills_feedback.md

@@ -0,0 +1,87 @@
+# Guide pour le Feedback sur les Soft Skills
+
+Ce guide fournit des observations courantes et des conseils constructifs pour aider les candidats à améliorer leurs soft skills lors des entretiens d'embauche.
+
+## Communication
+
+**Observation** : Le candidat a du mal à structurer ses réponses ou semble décousu.
+
+**Conseil à fournir** : "Pour mieux mettre en valeur votre expérience, essayez de structurer vos réponses avec la méthode STAR (Situation, Tâche, Action, Résultat). Par exemple, lorsque vous parlez d'un projet, commencez par décrire le contexte, puis votre rôle, les actions que vous avez menées, et enfin les résultats que vous avez obtenus. Cela rendra votre discours plus clair et percutant."
+
+**Observation** : Le candidat utilise un langage trop technique ou du jargon.
+
+**Conseil à fournir** : "Votre expertise technique est évidente. Pour vous assurer que tous vos interlocuteurs comprennent bien l'impact de votre travail, pensez à vulgariser certains concepts. Expliquer un projet complexe en des termes simples est une compétence très appréciée. Entraînez-vous à expliquer votre travail à quelqu'un qui n'est pas du même domaine."
+
+**Observation** : Le candidat ne pose pas de questions ou ne montre pas de curiosité.
+
+**Conseil à fournir** : "Un entretien est aussi une opportunité pour vous de poser des questions sur le poste, l'équipe ou la culture d'entreprise. Cela démontre votre intérêt et votre proactivité. Préparez quelques questions en amont pour la fin de l'entretien."
+
+## Esprit d'équipe
+
+**Observation** : Le candidat utilise beaucoup le "je" et mentionne peu ses collaborateurs.
+
+**Conseil à fournir** : "N'hésitez pas à mentionner comment vous avez collaboré avec les autres membres de votre équipe. Parler des succès collectifs et de votre rôle au sein du groupe montre que vous savez travailler en équipe, une qualité essentielle dans la plupart des entreprises. Mettez en avant les synergies et les contributions mutuelles."
+
+**Observation** : Le candidat ne parle pas de situations de conflit ou de désaccord en équipe.
+
+**Conseil à fournir** : "Les désaccords font partie de la vie d'équipe. Expliquer comment vous avez géré une situation de conflit ou de désaccord avec un collègue, et comment vous avez contribué à trouver une solution, peut démontrer votre maturité et vos compétences en résolution de problèmes interpersonnels."
+
+## Proactivité et Prise d'initiative
+
+**Observation** : Le candidat décrit ses tâches de manière passive, sans mentionner de contributions personnelles.
+
+**Conseil à fournir** : "Pensez à des moments où vous avez pris une initiative, même petite. Avez-vous suggéré une amélioration ? Avez-vous identifié un problème avant qu'il ne devienne critique ? Mettre en avant ces situations démontre votre proactivité et votre engagement. Montrez que vous êtes force de proposition."
+
+**Observation** : Le candidat attend d'être sollicité pour agir.
+
+**Conseil à fournir** : "Les recruteurs apprécient les profils qui ne se contentent pas d'exécuter. Décrivez des situations où vous avez anticipé un besoin, proposé une solution avant qu'on ne vous le demande, ou pris des responsabilités supplémentaires. Cela illustre votre autonomie et votre sens des responsabilités."
+
+## Gestion du Stress
+
+**Observation** : Le candidat semble visiblement stressé, ce qui affecte ses réponses.
+
+**Conseil à fournir** : "Il est tout à fait normal de ressentir du stress en entretien. Pour vous aider, n'hésitez pas à prendre une seconde pour respirer avant de répondre. Si une question vous surprend, vous pouvez dire 'C'est une excellente question, laissez-moi un instant pour y réfléchir'. Cela montre que vous prenez le temps de construire une réponse pertinente et que vous gérez la pression."
+
+**Observation** : Le candidat perd ses moyens face à une question inattendue ou difficile.
+
+**Conseil à fournir** : "Face à une question déstabilisante, il est préférable de demander des précisions ou de reformuler la question pour s'assurer de bien la comprendre. Vous pouvez aussi demander un court instant pour organiser vos idées. Cela est perçu positivement et montre votre capacité à gérer l'incertitude."
+
+## Adaptabilité
+
+**Observation** : Le candidat a du mal à parler de changements ou de situations imprévues.
+
+**Conseil à fournir** : "Le monde du travail évolue rapidement. Mettre en avant des situations où vous avez dû vous adapter à de nouvelles technologies, de nouvelles méthodes de travail, ou des changements d'équipe, démontre votre flexibilité. Expliquez comment vous avez géré ces transitions et ce que vous en avez appris."
+
+**Observation** : Le candidat semble rigide dans ses approches ou ses idées.
+
+**Conseil à fournir** : "Montrez que vous êtes ouvert aux nouvelles idées et aux retours. Décrivez une situation où vous avez dû changer d'avis ou modifier votre approche suite à de nouvelles informations ou un feedback. Cela prouve votre capacité à évoluer et à apprendre."
+
+## Pensée Critique / Résolution de Problèmes
+
+**Observation** : Le candidat décrit des problèmes sans détailler sa démarche de résolution.
+
+**Conseil à fournir** : "Lorsque vous parlez d'un problème rencontré, ne vous contentez pas de décrire le problème et la solution. Expliquez votre processus de réflexion : comment avez-vous analysé la situation ? Quelles options avez-vous envisagées ? Pourquoi avez-vous choisi cette solution spécifique ? Quels ont été les résultats ? Cela met en lumière votre pensée critique."
+
+**Observation** : Le candidat ne semble pas analyser les causes profondes des problèmes.
+
+**Conseil à fournir** : "Les recruteurs recherchent des personnes capables d'aller au-delà des symptômes. Lorsque vous décrivez un défi, essayez d'identifier la cause racine du problème et comment votre solution y a remédié durablement. Cela montre une approche plus stratégique."
+
+## Leadership
+
+**Observation** : Le candidat parle de son rôle dans un projet sans mentionner comment il a influencé ou guidé les autres.
+
+**Conseil à fournir** : "Le leadership ne se limite pas à un titre. Pensez à des moments où vous avez inspiré vos collègues, résolu des blocages pour l'équipe, ou pris la responsabilité d'un livrable important. Même sans être manager, vous pouvez démontrer des qualités de leader en montrant comment vous avez contribué à faire avancer le groupe."
+
+**Observation** : Le candidat ne mentionne pas de situations où il a dû prendre des décisions difficiles.
+
+**Conseil à fournir** : "Les leaders sont souvent confrontés à des choix complexes. Décrivez une situation où vous avez dû prendre une décision difficile, expliquez le contexte, les options, votre raisonnement et l'impact de cette décision. Cela met en évidence votre capacité à assumer des responsabilités."
+
+## Gestion du Temps / Organisation
+
+**Observation** : Le candidat semble désorganisé dans ses réponses ou ne mentionne pas de méthodes de travail.
+
+**Conseil à fournir** : "Parlez de la manière dont vous organisez votre travail, gérez vos priorités et respectez les délais. Mentionnez des outils ou des méthodes (ex: to-do lists, gestion de projet agile) que vous utilisez. Cela rassure sur votre capacité à être efficace et autonome."
+
+**Observation** : Le candidat a du mal à gérer plusieurs tâches ou projets simultanément.
+
+**Conseil à fournir** : "Décrivez une situation où vous avez dû jongler avec plusieurs responsabilités. Expliquez comment vous avez priorisé, délégué si possible, et maintenu la qualité de votre travail. Cela démontre votre capacité à gérer la charge de travail et à rester performant sous pression."

main.py

@@ -0,0 +1,161 @@
+import tempfile
+from fastapi import FastAPI, UploadFile, File, HTTPException, Body
+from fastapi.concurrency import run_in_threadpool
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any
+from datetime import datetime
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import uvicorn
+import os
+import logging
+from celery.result import AsyncResult
+from tasks.worker_celery import run_interview_analysis_task
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+from src.cv_parsing_agents import CvParserAgent
+from src.interview_simulator.entretient_version_prod import InterviewProcessor
+from src.scoring_engine import ContextualScoringEngine
+from src.rag_handler import RAGHandler
+
+app = FastAPI(
+    title="API d'IA pour la RH",
+    description="Une API pour le parsing de CV et la simulation d'entretiens.",
+    version="1.2.0"
+)
+
+# Initialisation des services au démarrage
+try:
+    logger.info("Initialisation du RAG Handler...")
+    rag_handler = RAGHandler()
+    if rag_handler.vector_store:
+        logger.info(f"Vector store chargé avec {rag_handler.vector_store.index.ntotal} vecteurs.")
+    else:
+        logger.warning("Le RAG Handler n'a pas pu être initialisé (pas de documents ?). Le feedback contextuel sera désactivé.")
+except Exception as e:
+    logger.error(f"Erreur critique lors de l'initialisation du RAG Handler: {e}", exc_info=True)
+    rag_handler = None
+
+# Configuration MongoDB
+MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:27017/")
+client = MongoClient(MONGO_URI)
+db = client.hr_ai_system
+feedback_collection = db.interview_feedbacks
+
+class InterviewRequest(BaseModel):
+    user_id: str = Field(..., example="google_user_12345")
+    job_offer_id: str = Field(..., example="job_offer_abcde")
+    cv_document: Dict[str, Any] = Field(..., example={"candidat": {"nom": "John Doe", "compétences": {"hard_skills": ["Python", "FastAPI"]}}})
+    job_offer: Dict[str, Any] = Field(..., example={"poste": "Développeur Python", "description": "Recherche développeur expérimenté..."})
+    messages: List[Dict[str, Any]]
+    conversation_history: List[Dict[str, Any]]
+
+class HealthCheck(BaseModel):
+    status: str = Field(default="ok", example="ok")
+
+
+@app.get("/", tags=["Status"], summary="Vérification de l'état de l'API")
+def read_root() -> HealthCheck:
+    """Vérifie que l'API est en cours d'exécution."""
+    return HealthCheck(status="ok")
+
+# --- Endpoint du parser de CV ---
+@app.post("/parse-cv/", tags=["CV Parsing"], summary="Analyser un CV au format PDF avec scoring contextuel")
+async def parse_cv_endpoint(file: UploadFile = File(...)):
+    if file.content_type != "application/pdf":
+        raise HTTPException(status_code=400, detail="Le fichier doit être au format PDF.")
+    tmp_path = None  
+    try:
+        contents = await file.read()
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+            tmp.write(contents)
+            tmp.flush()
+            tmp_path = tmp.name
+        
+        logger.info(f"Début du parsing du CV temporaire : {tmp_path}")
+        cv_agent = CvParserAgent(pdf_path=tmp_path)
+        parsed_data = await run_in_threadpool(cv_agent.process)
+        if not parsed_data:
+            raise HTTPException(status_code=500, detail="Échec du parsing du CV.")
+        logger.info("Parsing du CV réussi. Lancement du scoring contextuel.")
+        scoring_engine = ContextualScoringEngine(parsed_data)
+        scored_skills_data = await run_in_threadpool(scoring_engine.calculate_scores)
+        if parsed_data.get("candidat"):
+            parsed_data["candidat"].update(scored_skills_data)
+        else:
+            parsed_data.update(scored_skills_data)
+
+        logger.info("Scoring terminé. Retour de la réponse complète.")
+        return parsed_data
+
+    except Exception as e:
+        logger.error(f"Erreur lors du parsing ou du scoring du CV : {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Erreur interne du serveur : {e}")
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            try:
+                os.remove(tmp_path)
+                logger.info(f"Fichier temporaire supprimé : {tmp_path}")
+            except Exception as cleanup_error:
+                logger.warning(f"Erreur lors de la suppression du fichier temporaire : {cleanup_error}")
+
+# --- Endpoint de simulation d'entretien ---
+@app.post("/simulate-interview/", tags=["Simulation d'Entretien"], summary="Gérer une conversation d'entretien")
+async def simulate_interview_endpoint(request: InterviewRequest):
+    try:
+        processor = InterviewProcessor(
+            cv_document=request.cv_document,
+            job_offer=request.job_offer,
+            conversation_history=request.conversation_history
+        )
+        ai_response_object = await run_in_threadpool(processor.run, messages=request.messages)
+        
+        # On retourne juste la réponse de l'assistant pour le chat
+        return {"response": ai_response_object["messages"][-1].content}
+
+    except Exception as e:
+        logger.error(f"Erreur interne dans /simulate-interview/: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Erreur interne du serveur : {e}")
+
+
+# --- Endpoints pour l'analyse asynchrone ---
+class AnalysisRequest(BaseModel):
+    conversation_history: List[Dict[str, Any]]
+    job_description_text: str
+
+@app.post("/trigger-analysis/", tags=["Analyse Asynchrone"], status_code=202)
+def trigger_analysis(request: AnalysisRequest):
+    """
+    Déclenche l'analyse de l'entretien en tâche de fond.
+    Retourne immédiatement un ID de tâche.
+    """
+    task = run_interview_analysis_task.delay(
+        request.conversation_history, 
+        [request.job_description_text]
+    )
+    return {"task_id": task.id}
+
+
+@app.get("/analysis-status/{task_id}", tags=["Analyse Asynchrone"])
+def get_analysis_status(task_id: str):
+    """
+    Vérifie le statut de la tâche d'analyse.
+    Si terminée, retourne le résultat.
+    """
+    task_result = AsyncResult(task_id)
+    if task_result.ready():
+        if task_result.successful():
+            return {
+                "status": "SUCCESS",
+                "result": task_result.get()
+            }
+        else:
+            return {"status": "FAILURE", "error": str(task_result.info)}
+    else:
+        return {"status": "PENDING"}
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+## la bonne version de l'API est celle-ci, avec les imports et la structure de base.

prompts/rag_prompt.txt

@@ -0,0 +1,39 @@
+Tu es un assistant RH expert qui aide à l'analyse d'offres d'emploi et à la préparation d'entretiens.
+Ton rôle est de te comporter comme dans un entretien pour un poste.
+
+Tu as accès aux informations suivantes sur le poste actuel :
+    entreprise : {entreprise}
+    poste : {poste}
+    description : {description}
+
+Les informations sur le candidat sont :
+    cv : {cv}
+
+
+Tu as accès au CV d'un candidat appelle-le toujours par son nom et utilise les informations de son CV {cv} pour lui poser des questions
+ou avoir des précisions si nécessaire.
+Identifie clairement experience professionnelle et projet, et ne confond pas les 2.
+Essaye d'evaluer les compétences et skills d'un candidat en fonction de ses projets, si par exemple le candidat a simplement travaillé sur un dashboard
+powerBi ne considére pas cela comme une experience solide.
+À partir des informations de {description}, tu devras élaborer une série de questions pour le candidat.
+Pose exactement les questions une par une.
+Attends la réponse du candidat avant de poser la question suivante.
+
+Commence l'entretien par te présenter avec une formule de politesse.
+Tu devras te présenter avec un nom choisi aléatoirement, présenter l'entreprise et introduire la mission.
+Introduis les besoins de l'entreprise en analysant les informations contenues dans {poste}.
+Évite d'introduire les questions en parlant de 'questions' maintient toujours une conversation le plus naturelle possible.
+Après ta présentation demande toujours dans un premier temps au candidat de se présenter et de présenter son parcours.
+
+Tu dois toujours te mettre dans la situation d'un recruteur et adapter ton langage selon si c'est une femme ou un homme.
+Introduis toujours les informations de {description} comme si tu représentais l'entreprise et tu étais déjà au courant de ces infos.
+N'oublie pas de varier la structure de tes phrases et utilise des expressions comme 'D'accord', 'Je vois', 'C'est intéressant' pour montrer que tu écoutes activement.
+Adopte un ton décontracté et évite le jargon RH trop formel.
+Au lieu de dire 'Pouvez-vous me parler de...', essaye plutôt 'Racontez-moi un peu...' ou 'J'aimerais en savoir plus sur...
+Tu devras poser les questions et communiquer de la manière la plus humaine possible.
+Tu devras adapter l'entretien au profil du candidat.
+
+Quand tu estimes que l'entretien est terminé et que tu as assez d'informations, utilise l'outil `interview_analyser` pour conclure et lancer l'analyse du feedback.
+Termine toujours l'entretien par une phrase de politesse, positive.
+Ne fais pas d'analyse, elle est faite par une équipe d'agents, contente-toi seulement d'occuper ton rôle de recruteur.
+**À la fin de l'entretien, après ta dernière phrase de politesse, conclus toujours par : nous allons maintenant passer a l'analyse **

prompts/rag_prompt_old.txt

@@ -0,0 +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 (à 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

@@ -0,0 +1,25 @@
+fastapi==0.111.1
+uvicorn[standard]==0.30.1
+pydantic==2.8.2
+
+langchain-core==0.2.26
+langchain-community==0.2.5
+langchain-openai==0.1.20
+langchain_groq
+langchain-huggingface
+langgraph==0.1.9
+crewai
+crewai-tools
+sentence_transformers
+torch
+transformers
+sentencepiece
+accelerate
+celery
+redis
+pypdf==4.3.1
+python-dotenv==1.0.1
+pymongo
+
+requests==2.32.3
+faiss-cpu==1.8.0

src/config.py

@@ -0,0 +1,74 @@
+import os
+from dotenv import load_dotenv
+load_dotenv()
+from langchain_groq import ChatGroq
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_openai import ChatOpenAI
+from typing import Dict, List, Any, Tuple, Optional, Type
+from crewai import LLM
+#########################################################################################################
+# formatage du json
+def format_cv(document):
+    def format_section(title, data, indent=0):
+        prefix = "  " * indent
+        lines = [f"{title}:"]
+        if isinstance(data, dict):
+            for k, v in data.items():
+                if isinstance(v, (dict, list)):
+                    lines.append(f"{prefix}- {k.capitalize()}:")
+                    lines.extend(format_section("", v, indent + 1))
+                else:
+                    lines.append(f"{prefix}- {k.capitalize()}: {v}")
+        elif isinstance(data, list):
+            for i, item in enumerate(data):
+                lines.append(f"{prefix}- Élément {i + 1}:")
+                lines.extend(format_section("", item, indent + 1))
+        else:
+            lines.append(f"{prefix}- {data}")
+        return lines
+    sections = []
+    for section_name, content in document.items():
+        title = section_name.replace("_", " ").capitalize()
+        sections.extend(format_section(title, content))
+        sections.append("") 
+    return "\n".join(sections)
+
+
+def read_system_prompt(file_path):
+    with open(file_path, 'r', encoding='utf-8') as file:
+        return file.read()
+
+def load_pdf(pdf_path):
+    loader = PyPDFLoader(pdf_path)
+    pages = loader.load_and_split()
+    cv_text = ""
+    for page in pages:
+        cv_text += page.page_content + "\n\n"
+    return cv_text    
+
+#########################################################################################################        
+# modéles 
+
+"""GEMINI_API_KEY = os.getenv("GOOGLE_API_KEY")
+model_google = "gemini/gemma-3-27b-it"
+def chat_gemini():
+    llm = ChatGoogleGenerativeAI("gemini/gemma-3-27b-it")"""
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+model_openai = "gpt-4o"  
+
+def crew_openai():
+    llm = ChatOpenAI(
+        model="gpt-4o-mini",
+        temperature=0.1,
+        api_key=OPENAI_API_KEY
+    )
+    return llm
+
+def chat_openai():
+    llm = ChatOpenAI(
+        model="gpt-4o",
+        temperature=0.6,
+        api_key=OPENAI_API_KEY
+    )
+    return llm

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,119 @@
+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
+
+
+'''
+class EmptyInput(BaseModel):
+    pass
+
+class InterviewAnalysisTool(BaseTool):
+    """
+    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.
+    """
+    name: str = "interview_analyser"
+    description: 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."
+    )
+    args_schema: type[BaseModel] = EmptyInput
+    job_offer: Dict[str, Any]
+    conversation_history: List[Dict[str, Any]]
+
+    def _run(self) -> str:
+        """Exécute l'analyse de l'entretien."""
+        interview_crew = Crew(
+            agents=[report_generator_agent],
+            tasks=[generate_report_task],
+            process=Process.sequential,
+            verbose=False,
+            telemetry=False
+        )
+        analyzer = MultiModelInterviewAnalyzer()
+        structured_analysis = analyzer.run_full_analysis(self.conversation_history, self.job_offer)
+
+        final_report = interview_crew.kickoff(inputs={
+            'structured_analysis_data': json.dumps(structured_analysis, indent=2)
+        })
+        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,50 @@
+import os
+import json
+
+from src.crew.crew_pool import analyse_cv
+from src.config import load_pdf
+
+def clean_dict_keys(data):
+    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:
+    def __init__(self, pdf_path: str):
+        self.pdf_path = pdf_path
+
+    def process(self) -> dict:
+        """
+        Traite le fichier PDF pour en extraire le contenu sous forme de JSON.
+        Ne se connecte à aucune base de données.
+        
+        Retourne :
+            Un dictionnaire contenant les données extraites du CV, ou None en cas d'erreur.
+        """
+        print(f"Début du traitement du CV : {self.pdf_path}")
+        
+        try:
+            cv_text_content = load_pdf(self.pdf_path)
+            crew_output = analyse_cv(cv_text_content)
+
+            if not crew_output or not hasattr(crew_output, 'raw') or not crew_output.raw.strip():
+                print("Erreur : L'analyse par le crew n'a pas retourné de résultat.")
+                return None
+            raw_string = crew_output.raw
+            json_string_cleaned = raw_string
+            if '```' in raw_string:
+                json_part = raw_string.split('```json')[1].split('```')[0]
+                json_string_cleaned = json_part.strip()
+            profile_data = json.loads(json_string_cleaned)
+            return clean_dict_keys(profile_data)
+
+        except json.JSONDecodeError as e:
+            print(f"Erreur de décodage JSON : {e}")
+            print(f"Données brutes reçues : {crew_output.raw}")
+            return None
+        except Exception as e:
+            print(f"Une erreur inattendue est survenue dans CvParserAgent : {e}")
+            return None

src/deep_learning_analyzer.py

@@ -0,0 +1,57 @@
+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/interview_simulator/entretient_version_prod.py

@@ -0,0 +1,98 @@
+import os
+import sys
+import json
+from typing import Dict, List, Any, Annotated
+from typing_extensions import TypedDict
+
+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]
+
+class InterviewProcessor:
+    def __init__(self, cv_document: Dict[str, Any], job_offer: Dict[str, Any], conversation_history: List[Dict[str, Any]]):
+        if not cv_document or 'candidat' not in cv_document:
+            raise ValueError("Document CV invalide fourni.")
+        if not job_offer:
+            raise ValueError("Données de l'offre d'emploi non fournies.")
+
+        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()
+
+    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
+    )
+
+    def _load_prompt_template(self) -> str:
+        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)
+
+        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=mission,
+            profil_recherche=profil_recherche,
+            competences=competences,
+            pole=pole,
+            cv=formatted_cv_str
+        )
+        llm_messages = [SystemMessage(content=system_prompt)] + 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_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]:
+        initial_state = self.conversation_history + messages
+        return self.graph.invoke({"messages": initial_state})

src/rag_handler.py

@@ -0,0 +1,85 @@
+import os
+from langchain_community.document_loaders import DirectoryLoader, TextLoader
+from langchain_community.vectorstores import FAISS
+from langchain_huggingface import HuggingFaceEmbeddings 
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+embeddings_model = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
+VECTOR_STORE_PATH = "/app/vector_store" 
+
+class RAGHandler:
+    def __init__(self, knowledge_base_path: str = "/app/knowledge_base"):
+        """
+        Initialise le RAG Handler.
+        
+        Args:
+            knowledge_base_path (str): Le chemin vers le dossier contenant les documents de connaissances (.md).
+        """
+        self.embeddings = embeddings_model
+        self.vector_store = self._load_or_create_vector_store(knowledge_base_path)
+
+    def _load_documents(self, path: str) -> list:
+        """Charge les documents depuis un chemin de répertoire spécifié."""
+        loader = DirectoryLoader(
+            path,
+            glob="**/*.md", 
+            loader_cls=TextLoader,
+            loader_kwargs={"encoding": "utf-8"}
+        )
+        print(f"Chargement des documents depuis : {path}")
+        return loader.load()
+
+    def _create_vector_store(self, knowledge_base_path: str) -> FAISS | None:
+        """Crée et sauvegarde la base de données vectorielle à partir des documents."""
+        documents = self._load_documents(knowledge_base_path)
+        if not documents:
+            print("Aucun document trouvé pour créer le vector store.")
+            return None
+        
+        print(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)
+        os.makedirs(VECTOR_STORE_PATH, exist_ok=True)
+        vector_store.save_local(VECTOR_STORE_PATH)
+        print(f"Vector store créé et sauvegardé dans : {VECTOR_STORE_PATH}")
+        return vector_store
+
+    def _load_or_create_vector_store(self, knowledge_base_path: str) -> FAISS | None:
+        """Charge le vector store s'il existe, sinon le crée."""
+        if os.path.exists(os.path.join(VECTOR_STORE_PATH, "index.faiss")):
+            print(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:
+            print("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]:
+        """Recherche les k conseils les plus pertinents pour une requête."""
+        if not self.vector_store:
+            return []
+        results = self.vector_store.similarity_search(query, k=k)
+        return [doc.page_content for doc in results]
+
+if __name__ == '__main__':
+    print("Initialisation du RAG Handler en mode test...")
+    handler = RAGHandler(knowledge_base_path="/app/knowledge_base") 
+    if handler.vector_store and hasattr(handler.vector_store, 'index'):
+        print(f"Vector store chargé avec {handler.vector_store.index.ntotal} vecteurs.")
+        
+        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 pertinent trouvé :")
+            for f in feedback:
+                print(f"- {f[:150]}...") # Affiche un aperçu
+        else:
+            print("Aucun feedback pertinent trouvé pour cette requête.")
+    else:
+        print("Le RAG Handler n'a pas pu être initialisé ou le vector store est vide.")

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}

tasks/worker_celery.py

@@ -0,0 +1,72 @@
+import os
+import json
+from celery import Celery
+from crewai import Crew, Process
+from src.deep_learning_analyzer import MultiModelInterviewAnalyzer
+from src.rag_handler import RAGHandler
+from src.crew.agents import report_generator_agent
+from src.crew.tasks import generate_report_task
+
+celery_app = Celery(
+    'worker_celery', # Nom de l'application Celery
+    broker=os.environ.get("CELERY_BROKER_URL", "redis://redis:6379/0"),
+    backend=os.environ.get("CELERY_RESULT_BACKEND", "redis://redis:6379/0"),
+    include=['tasks.worker_celery'] # Indique à Celery où trouver les tâches
+)
+
+celery_app.conf.update(
+    task_serializer='json',
+    result_serializer='json',
+    accept_content=['json'],
+    timezone='Europe/Paris',
+    enable_utc=True,
+)
+
+@celery_app.task(name="tasks.run_interview_analysis")
+def run_interview_analysis_task(conversation_history: list, job_description_text: list):
+    """
+    Tâche Celery qui exécute l'analyse complète de l'entretien en arrière-plan.
+    
+    Args:
+        conversation_history (list): L'historique complet de la conversation de l'entretien.
+        job_description_text (list): La description du poste sous forme de liste de textes.
+
+    Returns:
+        str: Le rapport final généré par le crew d'agents, au format string (potentiellement JSON).
+    """
+    print(f"Début de l'analyse pour un entretien de {len(conversation_history)} messages.")
+    print("Étape 1/3: Exécution de l'analyse par Deep Learning...")
+    analyzer = MultiModelInterviewAnalyzer()
+    structured_analysis = analyzer.run_full_analysis(conversation_history, job_description_text)
+    print("Analyse DL terminée.")
+    print("Étape 2/3: Enrichissement avec le RAG...")
+    rag_handler = RAGHandler()
+    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(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'] > 0.6:
+                    rag_feedback.extend(rag_handler.get_relevant_feedback("gestion du stress en entretien"))
+    unique_feedback = list(set(rag_feedback))
+    print("Enrichissement RAG terminé.")
+    print("Étape 3/3: Lancement du CrewAI pour la génération du rapport...")
+    interview_crew = Crew(
+        agents=[report_generator_agent],
+        tasks=[generate_report_task],
+        process=Process.sequential,
+        verbose=False, # Mettre à True pour un débuggage détaillé du crew
+        telemetry=False
+    )
+    final_report = interview_crew.kickoff(inputs={
+        'structured_analysis_data': json.dumps(structured_analysis, indent=2, ensure_ascii=False),
+        'rag_contextual_feedback': "\n- ".join(unique_feedback)
+    })
+    
+    print("Rapport final généré. Tâche terminée.")
+    return final_report