update

src/config/agents.yaml

@@ -147,24 +147,19 @@ cv_quality_checker:
 
 project_analyzer:
   role: >
-    Analyste de Projets Techniques & Conseiller en Mise en Avant
+    Analyste de Projets Techniques & Evaluateur de Compétences
   goal: >
-    Évaluer chaque projet et expérience du CV, fournir une critique objective et complète,
-    et recommander quels projets mettre en avant pour le poste visé.
+    Évaluer systématiquement les projets du CV selon 7 critères précis, avec une approche purement factuelle.
   backstory: >
-    Tu es un directeur technique (CTO) qui évalue les projets des candidats.
-    Pour chaque projet tu analyses :
-    1. La cohérence avec le poste visé ET avec le référentiel métier correspondant
-    2. La qualité de description (résultats mesurables, métriques techniques spécifiques)
-    3. La complexité technique (trivial vs ambitieux, architecture, choix techniques)
-    4. L'impact démontré (métriques, utilisateurs, déploiement, performance)
-    5. Les technologies utilisées (actuelles et recherchées pour le poste visé ?)
-    Tu fournis une RECOMMANDATION DE MISE EN AVANT : quels projets le candidat devrait
-    présenter en priorité pour le poste visé, et comment améliorer leur description.
-    Pour les profils en reconversion, tu identifies les compétences transférables
-    démontrées dans les expériences non-tech (gestion, optimisation, leadership, communication).
-    Tu analyses aussi les EXPÉRIENCES PROFESSIONNELLES pour identifier les compétences
-    transférables et les relier au poste visé.
-    Tu donnes des conseils CONCRETS et ACTIONNABLES pour chaque projet.
+    Tu es un directeur technique (CTO) exigeant qui déteste le bullshit et le name-dropping.
+    Tu evaluates chaque projet en examinant :
+    1. Pertinence & Alignement
+    2. Complexité Technique & Architecture
+    3. Stack & Maîtrise
+    4. Innovation & Originalité
+    5. Impact & Résultats Mesurables
+    6. Ownership & Exécution
+    7. Maturité Production & Qualité
+    Tu produis un avis CLAIR et CRITIQUE : tu es factuel d'abord (preuve du CV), tu donnes du positif spécifique, tu donnes de la critique constructive et honnête, tu évites le fanboying, et tu termines par un verdict tranché.
   verbose: false
 

src/config/app_config.py

@@ -18,6 +18,17 @@ def load_pdf(pdf_path: str) -> str:
     return pymupdf4llm.to_markdown(pdf_path)
 
 
+def get_pdf_page_count(pdf_path: str) -> int:
+    """Retourne le nombre de pages du PDF."""
+    try:
+        doc = fitz.open(pdf_path)
+        count = doc.page_count
+        doc.close()
+        return count
+    except Exception:
+        return 1
+
+
 def load_pdf_first_page_text(pdf_path: str) -> str:
     """Extrait le texte brut de la première page en ordre de lecture (haut → bas, gauche → droite).
 
@@ -48,9 +59,8 @@ GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 def get_big_llm():
     """GPT-4o pour les tâches complexes — max_tokens élevé pour éviter la troncature JSON."""
     return ChatOpenAI(
-        model="gpt-4o",
+        model="gpt-5.2",
         temperature=0.0,
-        max_tokens=16384,
         api_key=OPENAI_API_KEY
     )
 
@@ -58,18 +68,8 @@ def get_big_llm():
 def get_small_llm():
     """GPT-4o-mini pour l'extraction rapide."""
     return ChatOpenAI(
-        model="gpt-4o-mini",
+        model="gpt-4o",
         temperature=0.0,
         max_tokens=1500,
         api_key=OPENAI_API_KEY
-    )
-
-
-def get_fast_llm():
-    """Groq llama-3.1-8b - Le plus rapide."""
-    return ChatGroq(
-        model="groq/llama-3.1-8b-instant",
-        temperature=0.0,
-        max_tokens=1500,
-        groq_api_key=GROQ_API_KEY
-    )
+    )

src/config/tasks.yaml

@@ -4,12 +4,6 @@ split_cv_task:
   description: >
     Découpe le CV en sections JSON. Copie le texte brut sans reformuler ni résumer.
 
-    TEXTE PRINCIPAL DU CV (Markdown) :
-    "{cv_content}"
-
-    TEXTE BRUT PREMIÈRE PAGE (extraction directe, utilise-le si le texte principal manque le header) :
-    "{cv_raw_start}"
-
     RÈGLES STRICTES :
     1. "header" : Les premières lignes du CV — contient le NOM du candidat, son TITRE/POSTE, ses coordonnées (email, téléphone, LinkedIn, ville). Cherche en priorité dans le TEXTE BRUT PREMIÈRE PAGE car le Markdown peut mal ordonner le header.
     2. "experiences" : Uniquement l'historique professionnel (Entreprise, Poste, Dates, missions).
@@ -17,6 +11,12 @@ split_cv_task:
     4. "skills" : Listes de compétences, langages, outils.
     5. "education" : Diplômes et formations.
     6. "languages" : Langues mentionnées avec leur niveau (Français, Anglais, etc.).
+
+    TEXTE PRINCIPAL DU CV (Markdown) :
+    "{cv_content}"
+
+    TEXTE BRUT PREMIÈRE PAGE (extraction directe, utilise-le si le texte principal manque le header) :
+    "{cv_raw_start}"
   expected_output: >
     Un objet JSON valide strictement structuré ainsi :
     {{
@@ -32,18 +32,22 @@ split_cv_task:
 
 skills_task:
   description: >
-    Analyse les sections suivantes pour lister les compétences avec leur contexte d'utilisation.
-    Expériences : {experiences}
-    Projets : {projects}
-    academique : {education}
-    Skills Explicit : {skills}
-    
     RÈGLES DE CLASSIFICATION :
     1. 'hard_skills' : Outils, langages, technos (ex: Python, SQL, Excel, React, FastAPI, LangChain).
        IMPORTANT: Inclure TOUTES les technologies mentionnées dans les projets, expériences et académique.
     2. 'soft_skills' : Qualités humaines (ex: Leadership, Communication, Rigueur).
     3. NE PAS INVENTER. Si ce n'est pas écrit, ne l'ajoute pas.
-    4. Pour chaque skill, indique si elle est présente dans une expérience, un projet, academique, sans contexte, si elle est presente dans plusieurs section indique le .
+    4. EXHAUSTIVITÉ ABSOLUE : Traque RIGOUREUSEMENT chaque logiciel, langage, bibliothèque ou concept technique (ex: BeautifulSoup4, Scraping, Pandas, etc.). Ne laisse RIEN passer.
+    5. 'skills_with_context' : Tu DOIS obligatoirement analyser la LISTE COMPLÈTE des 'hard_skills' extraites.
+       RÈGLE ABSOLUE : Pour CHAQUE compétence, tu dois EFFECTUER UNE RECHERCHE TEXTUELLE RIGOUREUSE (comme un CTRL+F) dans le texte brut des Expériences, des Projets et de l'Éducation.
+       De nombreuses compétences présentes dans les 'Expériences' sont souvent manquées. Prends le temps de lire chaque phrase des expériences !
+       Si la compétence est trouvée, précise son contexte (ex: "expérience", "projet", "académique", "expérience, projet").
+       Si et SEULEMENT SI tu as lu attentivement tous les autres textes et qu'elle n'est VRAIMENT mentionnée nulle part ailleurs que dans la section Compétences, alors attribue-lui le contexte "sans contexte". Ne mets JAMAIS "sans contexte" par erreur si la compétence se trouve dans l'expérience.
+    Analyse les sections suivantes pour lister les compétences avec leur contexte d'utilisation :
+    Expériences : {experiences}
+    Projets : {projects}
+    Education : {education}
+    Skills Explicites : {skills}
   expected_output: >
     JSON : {{
       "hard_skills": ["Python", "SQL", "FastAPI"],
@@ -56,8 +60,7 @@ skills_task:
 
 experience_task:
   description: >
-    Tu es un extracteur de données strict. Analyse ce texte d'expérience :
-    "{experiences}"
+    Tu es un extracteur de données strict.
     
     Pour CHAQUE poste identifié :
     1. Titre du poste
@@ -66,13 +69,14 @@ experience_task:
     4. Description (Liste des tâches/responsabilités)
     
     RÈGLE : Ne confonds PAS les projets scolaires avec des expériences pro. Les stages et alternances SONT des expériences.
+
+    Analyse ce texte d'expérience :
+    "{experiences}"
   expected_output: >
     Liste JSON : [{{"Poste": "...", "Entreprise": "...", "start_date": "...", "end_date": "...", "responsabilités": ["task 1", "task 2"]}}]
 
 project_task:
   description: >
-    Analyse ce texte de projets : "{projects}"
-    
     RÈGLES STRICTES DE STRUCTURE :
     Chaque projet DOIT avoir exactement ces clés :
     - "title" : Titre du projet
@@ -85,6 +89,10 @@ project_task:
     - "personal" : Projets perso, Github, Hackathons, Écoles.
     
     Si une liste est vide, renvoie [].
+
+    Analyse ce texte de projets : "{projects}"
+    
+    Si une liste est vide, renvoie [].
   expected_output: >
     JSON : {{
       "professional": [
@@ -102,26 +110,30 @@ education_task:
 
 reconversion_task:
   description: >
-    Analyse les expériences : "{experiences}"
-    Et "{education}"
     Le candidat est-il en reconversion ? (Changement majeur de domaine récent).
-    indique aussi le contexte (de quelle domaine ou poste vient t'il et quelle est sa réortientation)
-    pour le contexte de reconversion tu dois prendre en compte les experience et les education.
+    Indique aussi le contexte (de quel domaine ou poste vient-il et quelle est sa réorientation).
+    RÈGLE ABSOLUE : Tu DOIS extraire la DATE de début de cette reconversion.
+    Cette date correspond au mois et à l'année de début de la formation de reconversion OU du premier emploi dans le nouveau domaine.
+    Pour le contexte de reconversion et la date, base-toi sur les expériences et l'éducation.
+
+    Analyse les expériences : "{experiences}"
+    Et l'éducation : "{education}"
   expected_output: >
-    JSON : {{"reconversion_analysis": {{"is_reconversion": true/false, "context": "..."}}
+    JSON : {{"reconversion_analysis": {{"is_reconversion": true/false, "context": "...", "date_reconversion": "YYYY-MM ou null"}}}}
 
 etudiant_task:
   description: >
-    Analyse la section education : "{education}"
-    Nous sommes le {current_date}.
-    Le candidat est-il ACTUELLEMENT étuditant ? 
+    Le candidat est-il ACTUELLEMENT étudiant ? 
     CRITÈRES :
     1. Regarde les dates de fin des formations.
     2. Identifie la date de fin de la formation la plus récente.
-    3. Si cette date est FUTURE par rapport à {current_date} ou si c'est écrit "En cours" / "Présent", alors is_etudiant = true.
+    3. Si cette date est FUTURE par rapport à la date actuelle ou si c'est écrit "En cours" / "Présent", alors is_etudiant = true.
     4. Récupère explicitement cette date sous le champ 'latest_education_end_date' (format YYYY-MM-DD ou MM/YYYY ou "Present").
-    5. indique aussi le niveau d'études (ex: bac+2, bac+5) du diplome le plus proche de {current_date}.
+    5. indique aussi le niveau d'études (ex: bac+2, bac+5) du diplome le plus proche de la date actuelle.
     6. indique la spécialité exemple: ingenieur IA, data analyste, devellopeur frontend, etc.
+
+    Nous sommes le {current_date}.
+    Analyse la section education : "{education}"
   expected_output: >
     JSON : {{"etudiant_analysis": {{"is_etudiant": true/false, "niveau_etudes": "bac+5", "specialite": "data analyste", "latest_education_end_date": "YYYY-MM-DD"}}}}
 
@@ -129,15 +141,15 @@ language_task:
   description: >
     Identifie toutes les langues parlées par le candidat.
 
-    SECTION LANGUES (extraite) : "{languages}"
-
-    DÉBUT DU CV (pour détecter la langue de rédaction) : "{cv_raw_start}"
-
     RÈGLES :
     1. Extrais toutes les langues et niveaux présents dans la SECTION LANGUES.
     2. Détecte la langue dans laquelle le CV est rédigé à partir du DÉBUT DU CV.
     3. Si la langue du CV n'est PAS dans la SECTION LANGUES, ajoute-la avec le niveau "Natif" ou "Langue maternelle".
     4. Ne jamais omettre la langue du CV.
+
+    SECTION LANGUES (extraite) : "{languages}"
+
+    DÉBUT DU CV (pour détecter la langue de rédaction) : "{cv_raw_start}"
   expected_output: >
     JSON : {{"langues": [{{"langue": "Français", "niveau": "Natif"}}, {{"langue": "Anglais", "niveau": "B2"}}]}}
 
@@ -145,17 +157,17 @@ identity_task:
   description: >
     Extrais le prénom du candidat.
 
-    HEADER DU CV (nom, titre, contact) : "{header}"
-
-    TEXTE BRUT DÉBUT DU CV : "{cv_raw_start}"
-
-    NOM DU FICHIER (indice très fiable, souvent au format NOM_PRENOM_...) : "{file_name}"
-
     RÈGLES :
     1. Cherche le prénom dans le HEADER, puis dans le TEXTE BRUT DÉBUT DU CV.
     2. Le NOM DU FICHIER est un indice fort : "ANISSA_KACEM_..." → prénom = "Anissa".
     3. Ne jamais inventer. Formate avec majuscule initiale.
     4. Si impossible à trouver, retourne null.
+
+    HEADER DU CV (nom, titre, contact) : "{header}"
+
+    TEXTE BRUT DÉBUT DU CV : "{cv_raw_start}"
+
+    NOM DU FICHIER (indice très fiable, souvent au format NOM_PRENOM_...) : "{file_name}"
   expected_output: >
     JSON : {{"first_name": "..."}}
 
@@ -163,15 +175,15 @@ poste_visé_task:
   description: >
     Extrais le titre de poste visé tel qu'il est écrit dans l'en-tête du CV.
 
-    HEADER DU CV (extrait par le splitter) : "{header}"
-
-    TEXTE BRUT DÉBUT DU CV (fallback si header vide) : "{cv_raw_start}"
-
     RÈGLES :
     1. Le titre de poste se trouve juste après le nom du candidat (ex: "Business Analyst", "Data Engineer").
     2. Copie le titre EXACTEMENT tel qu'il est écrit, sans reformuler.
     3. Si le header est vide, cherche dans le TEXTE BRUT DÉBUT DU CV.
     4. Ne jamais inventer un titre.
+
+    HEADER DU CV (extrait par le splitter) : "{header}"
+
+    TEXTE BRUT DÉBUT DU CV (fallback si header vide) : "{cv_raw_start}"
   expected_output: >
     JSON : {{
       "poste_vise": "Le titre EXACT tel qu'écrit sur le CV",
@@ -184,35 +196,15 @@ metier_matching_task:
   description: >
     Compare le profil du candidat avec le référentiel de métiers pour recommander les 3 postes les plus adaptés.
 
-    POSTE VISÉ PAR LE CANDIDAT : "{poste_vise}"
-
-    COMPÉTENCES DU CANDIDAT :
-    Hard Skills : {hard_skills}
-    Soft Skills : {soft_skills}
-
-    DOMAINES DE COMPÉTENCES IDENTIFIÉS : {skill_domains}
-
-    MÉTHODOLOGIES DU CANDIDAT : {methodologies}
-
-    EXPÉRIENCES : {experiences_summary}
-
-    PROJETS : {projects_summary}
-
-    RECONVERSION : {reconversion_data}
-
-    RÉFÉRENTIEL DE MÉTIERS :
-    {metiers_reference}
-
     RÈGLES D'ANALYSE :
-    IMPORTANT : Tu dois évaluer CHAQUE métier présent dans le RÉFÉRENTIEL DE MÉTIERS ci-dessus,
+    IMPORTANT : Tu dois évaluer CHAQUE métier présent dans le RÉFÉRENTIEL DE MÉTIERS,
     sans en omettre aucun. Le top 3 final doit être basé sur l'évaluation exhaustive de tous
     les métiers listés. Ne jamais présélectionner ou ignorer des métiers a priori.
 
     1. Pour CHAQUE métier du référentiel, calcule un score de matching (0-100) basé sur :
-       - Couverture des compétences techniques requises (35%)
-       - Couverture des outils/technologies (25%)
+       - Couverture des compétences techniques requises (40%)
+       - Couverture des outils/technologies (30%)
        - Adéquation des expériences et projets (20%)
-       - Maîtrise des méthodologies de travail : Agile, Scrum, DevOps, CI/CD, TDD, Design Thinking (10%)
        - Cohérence avec le niveau d'études et l'expérience requise (10%)
     2. Utilise le mapping de domaines pour comprendre les liens implicites (ex: Metabase → BI,
        LangChain → LLM Engineering, Power BI → BI Analyst, Scikit-learn → Data Science).
@@ -221,9 +213,26 @@ metier_matching_task:
        communication internationale → travail en équipe multiculturelle).
     4. Recommande les 3 métiers avec le MEILLEUR score parmi l'ensemble du référentiel évalué.
     5. PONDÉRATION TEMPORELLE (CRITIQUE) : Accorde un poids double (x2) aux technologies et compétences issues des expériences et projets les plus récents, ainsi qu'à la formation en cours. Le profil actuel d'un candidat est défini par ce qu'il fait aujourd'hui, pas par son historique lointain.
-    6. Pour chaque métier recommandé, liste les compétences matchées, manquantes, et les méthodologies.
+    6. Pour chaque métier recommandé, liste les compétences matchées et manquantes.
     7. Si le poste visé par le candidat ne fait pas partie du top 3, explique pourquoi.
     8. Fournis une analyse détaillée de l'adéquation du poste visé avec le profil.
+
+    RÉFÉRENTIEL DE MÉTIERS :
+    {metiers_reference}
+
+    EN-TÊTE DU CV (pour le poste visé) : "{header}"
+
+    SECTION COMPÉTENCES :
+    {skills}
+
+    SECTION EXPÉRIENCES :
+    {experiences}
+
+    SECTION PROJETS :
+    {projects}
+
+    SECTION FORMATION (utile pour détecter les reconversions):
+    {education}
   expected_output: >
     JSON : {{
       "postes_recommandes": [
@@ -240,7 +249,6 @@ metier_matching_task:
           }},
           "competences_matchees": ["SQL", "Python", "Power BI"],
           "competences_manquantes": ["Looker", "dbt"],
-          "methodologies_matchees": ["Agile", "Scrum"],
           "justification": "Le profil couvre 85% des compétences requises..."
         }}
       ],
@@ -253,22 +261,14 @@ cv_quality_task:
     Évalue la qualité globale du CV en appliquant les critères de bonnes pratiques CV tech 2025,
     adaptés au niveau de séniorité du candidat.
 
-    CV COMPLET (texte Markdown) : "{cv_full_text}"
-
-    TEXTE BRUT DU CV (première page, pour détecter les URLs et liens) : "{cv_raw_start}"
-
-    COMPÉTENCES EXTRAITES AVEC CONTEXTE : {skills_with_context}
-    EXPÉRIENCES : {experiences_summary}
-    PROJETS : {projects_summary}
-    NIVEAU DE SÉNIORITÉ : "{niveau_seniorite}"
-    RECONVERSION : {reconversion_data}
-
     CRITÈRES D'ÉVALUATION (score sur 100 pour chaque) :
 
     1. COMPATIBILITÉ ATS (20 points) :
-       - Structure claire avec sections standards ?
-       - Pas de mise en page complexe qui bloquerait un ATS ?
-       - Mots-clés techniques bien présents ?
+       - ÉVALUATION STRICTE ET CRITIQUE : Ne donne jamais un score parfait sans preuve.
+       - Les noms des sections principales sont-ils standards (Expériences, Formations, Projets, Compétences) ou atypiques ? Si atypiques, pénalise. (RÈGLE ABSOLUE : N'évalue PAS et ne pénalise JAMAIS les sections d'introduction courtes comme "Profil", "À propos", "Résumé" ou "Profil atypique". Ignore-les totalement pour ce critère).
+       - Les mots-clés techniques sont-ils contextuels ou simplement entassés de manière artificielle ?
+       - Indique EXPLICITEMENT ce qui ne va pas (ex: "Nom de section 'Mon Parcours' au lieu de 'Expériences'", "Mots-clés empilés sans lien avec les expériences").
+       - Fournis des points d'amélioration spécifiques et factuels.
 
     2. QUANTIFICATION DES RÉSULTATS (25 points) :
        - Les expériences mentionnent-elles des MÉTRIQUES TECHNIQUES SPÉCIFIQUES ?
@@ -281,11 +281,13 @@ cv_quality_task:
          en fonction de ses expériences et projets RÉELS (pas des conseils génériques).
 
     3. STRUCTURE ET LISIBILITÉ (15 points) :
-       - Le CV tient-il en 1-2 pages ?
-       - Les sections sont-elles bien séparées et la chronologie claire ?
-       - STRUCTURATION DES COMPÉTENCES : Les compétences sont-elles regroupées par catégories
-         logiques (Langages, Frameworks, BDD, DevOps/Cloud, Méthodologies) ou en liste plate ?
-         Une structuration par catégories est fortement recommandée pour les filtres ATS.
+       - ANALYSE CRITIQUE BASÉE SUR LE TEXTE : Ne suppose pas que le CV est beau. Évalue la structure à partir du texte extrait.
+       - RÈGLE ABSOLUE SUR LA FORME : N'évalue JAMAIS la présence ou l'absence de listes à puces/tirets. Le parsing supprime souvent la mise en forme, ne fais donc aucune remarque sur des "blocs de texte illisibles".
+       - L'ordre chronologique inverse est-il respecté dans les expériences et formations ? Si non, pénalise sévèrement.
+       - RÈGLE LONGUEUR : Utilise la donnée `NOMBRE DE PAGES`. Un profil < 7 ans d'expérience devrait tenir sur 1 page. Pénalise si > 2 pages.
+       - RÈGLE POSTE VISÉ (CRITIQUE) : Si `POSTE VISÉ` est "Non identifié", c'est une ERREUR MAJEURE. Baisse drastiquement la note de structure et signale-le comme un RED FLAG (le recruteur doit identifier le but du CV en 3 secondes).
+       - STRUCTURATION DES COMPÉTENCES : Les compétences sont-elles regroupées par catégories logiques (Langages, Frameworks, BDD, DevOps/Cloud) ou en liste plate ? Une structuration par catégories est fortement recommandée pour les filtres ATS.
+       - Fournis des conseils d'amélioration FACTUELS sur la structure.
 
     4. PRÉSENTATION DES PROJETS (20 points) :
        - Chaque projet a-t-il un titre, des technos, et des résultats ?
@@ -294,10 +296,9 @@ cv_quality_task:
 
     5. PREUVES DE COMPÉTENCES (20 points) :
        - RÈGLE CRITIQUE : Une compétence est considérée "sans preuve" UNIQUEMENT si elle
-         apparaît EXCLUSIVEMENT dans la section Skills/Compétences sans aucune mention dans
-         les expériences OU les projets. Utilise "skills_with_context" : si le contexte est
-         "projet", "expérience", "académique" ou "projet+expérience", la compétence EST prouvée —
-         ne la signale pas. Ne signale que les skills dont le contexte est "sans contexte".
+         apparaît EXCLUSIVEMENT dans la section Compétences sans aucune mention dans
+         les expériences OU les projets. Tu dois vérifier par toi-même (par analyse textuelle)
+         si les compétences listées apparaissent ailleurs. Ne signale que les skills qui n'ont "aucun contexte".
        - DÉTECTION DES LIENS : Cherche les URLs dans le CV Markdown ET dans le texte brut.
          Les liens peuvent apparaître sous forme de Markdown [texte](url), de texte brut
          (github.com/..., linkedin.com/...) ou dans le header. Signale les liens PRÉSENTS,
@@ -305,7 +306,7 @@ cv_quality_task:
        - Pour les RECONVERSIONS : les compétences transférables (management, optimisation,
          communication, gestion budgétaire) sont-elles mises en valeur et reliées au nouveau domaine ?
 
-    ADAPTATION AU NIVEAU DE SÉNIORITÉ "{niveau_seniorite}" :
+    ADAPTATION AU NIVEAU DE SÉNIORITÉ :
     - Si JUNIOR : valorise les projets personnels, formations, stages bien décrits.
     - Si CONFIRMÉ : exige des résultats mesurables, progression, responsabilités.
     - Si SENIOR/STAFF : vérifie la présence de choix architecturaux et compromis
@@ -313,11 +314,21 @@ cv_quality_task:
       gestion de la scalabilité, impact organisationnel au-delà du code.
 
     RED FLAGS À DÉTECTER :
-    - Skills listées UNIQUEMENT dans la section skills sans aucune mention dans expériences/projets
+    - DÉTECTION STRICTE DES COMPÉTENCES SANS PREUVE : Tu DOIS t'appuyer uniquement sur ton évaluation de "preuves_competences". S'il y a des compétences listées dans "skills_sans_preuve", ajoute un red flag. Sinon, n'ajoute pas de red flag pour ce sujet.
     - Trous inexpliqués dans le parcours
     - Jargon excessif ou buzzwords sans substance
     - Incohérence entre compétences listées et projets/expériences
     - Section compétences en liste plate non catégorisée
+
+    DONNÉES À ÉVALUER :
+    EN-TÊTE DU CV (pour le poste visé et niveau de séniorité) : "{header}"
+    NOMBRE DE PAGES : {page_count}
+    CV COMPLET (texte Markdown) : "{cv_full_text}"
+    TEXTE BRUT DU CV (première page, pour détecter les URLs et liens) : "{cv_raw_start}"
+    SECTION COMPÉTENCES : "{skills}"
+    SECTION EXPÉRIENCES : "{experiences}"
+    SECTION PROJETS : "{projects}"
+    SECTION FORMATIONS : "{education}"
   expected_output: >
     JSON : {{
       "score_global": 72,
@@ -334,49 +345,47 @@ cv_quality_task:
 
 project_analysis_task:
   description: >
-    Évalue CHAQUE projet du CV et détermine leur pertinence pour le poste visé.
-
-    POSTE VISÉ : "{poste_vise}"
-
-    RÉFÉRENTIEL DU MÉTIER VISÉ (compétences et outils attendus) :
-    {metier_reference_detail}
-
-    PROJETS PROFESSIONNELS : {professional_projects}
-    PROJETS PERSONNELS : {personal_projects}
-
-    RECONVERSION : {reconversion_data}
-
-    Pour CHAQUE projet, fournis :
-    1. score_coherence (0-100) : cohérence avec le poste visé et le référentiel métier
-    2. rang : classement par ORDRE DE PERTINENCE pour le poste (1 = le plus pertinent pour ce poste)
-    3. raison : explication CONCISE de pourquoi ce projet doit être mis en avant (ou pas) pour ce poste visé
-    4. points_forts : atouts concrets (technologies démontrées, impact, qualité)
-    5. points_amelioration : ce qui manque pour convaincre (métriques, résultats, détails techniques)
-    6. conseils_description : conseils CONCRETS pour améliorer la description
-       (métriques à ajouter, aspects techniques à détailler, résultats à valoriser)
-
-    RÈGLES STRICTES :
-    - N'analyse QUE les projets listés dans PROJETS PROFESSIONNELS et PROJETS PERSONNELS.
-    - N'invente AUCUN projet à partir des expériences. Les expériences sont un contexte uniquement.
-    - Si PROJETS PROFESSIONNELS et PROJETS PERSONNELS sont vides, retourne "analyse_projets": [].
-    - Le nombre d'entrées dans "analyse_projets" doit correspondre EXACTEMENT au nombre de projets fournis.
-    - Retourne les projets TRIÉS par rang (rang 1 en premier).
+    Évalue CHAQUE projet du CV et détermine la qualité technique et l'impact.
+
+    Pour CHAQUE projet, tu dois scorer sur 10 avec une justification courte et factuelle (preuve tirée du CV) sur les 7 critères suivants :
+    1. Pertinence & Alignement : Correspondance avec le poste visé (multi-agents, RAG, recrutement tech, pipelines, GenAI).
+    2. Complexité Technique & Architecture : Niveau réel d'intégration (7 agents orchestrés ? pipeline complet ingestion→monitoring ? custom vs simple CrewAI/LangChain ?).
+    3. Stack & Maîtrise : Modernité, cohérence, diversité raisonnable vs "tech soup".
+    4. Innovation & Originalité : Valeur ajoutée réelle vs "j'ai collé des libs à la mode" (Ex : scoring multi-dimensionnel + détection fraude = fort ; simple wrapper RAG = faible).
+    5. Impact & Résultats Mesurables : Chiffres concrets (+40 %, 2000 offres, 30 % moins d'étapes...) et crédibilité de la mesure.
+    6. Ownership & Exécution : End-to-end (idea → business plan → dev → déploiement → monitoring). Méthodologies affichées (Design Thinking, Scrum...).
+    7. Maturité Production & Qualité : Monitoring, coût/latence, tests, sécurité, RGPD, scaling, users réels vs démo/prototype.
+
+    Méthode pour un avis CLAIR et CRITIQUE :
+    - Être factuel d'abord (preuve du CV).
+    - Donner du positif spécifique.
+    - Donner de la critique constructive et honnête (jamais méchant, toujours utile).
+    - Éviter le fanboying et le "tout est génial".
+    - Terminer par un verdict tranché.
+
+    DONNÉES DU CANDIDAT :
+    EN-TÊTE DU CV (pour déduire le poste visé) : "{header}"
+    PROJETS MENTIONNÉS (texte brut) : {projects}
   expected_output: >
     JSON : {{
       "analyse_projets": [
         {{
-          "titre": "Dashboard RH",
-          "rang": 1,
-          "raison": "Projet BI directement aligné avec les outils et missions du poste visé",
-          "score_coherence": 90,
-          "points_forts": ["SQL et Power BI maîtrisés et démontrés", "Impact mesurable sur les décisions RH"],
-          "points_amelioration": ["Ajouter le volume de données traité", "Mentionner le temps de chargement"],
-          "conseils_description": ["Préciser le volume de données traité (ex: 500k lignes)", "Ajouter une métrique de performance"]
+          "titre": "Nom exact du projet",
+          "resume": "Description ultra-concise + type (Side Project / SaaS / MVP)",
+          "evaluation": {{
+            "pertinence": {{"score": 8, "justification": "..."}},
+            "complexite": {{"score": 7, "justification": "..."}},
+            "stack": {{"score": 9, "justification": "..."}},
+            "innovation": {{"score": 6, "justification": "..."}},
+            "impact": {{"score": 5, "justification": "Aucun chiffre concret"}},
+            "ownership": {{"score": 8, "justification": "..."}},
+            "maturite": {{"score": 4, "justification": "Pas de mention de monitoring ou de tests"}}
+          }},
+          "points_forts": ["...", "..."],
+          "points_vigilance": ["Risque d'over-claim sur...", "Manque de visibilité sur tests"],
+          "note_globale": 67,
+          "verdict_recruteur": "Très bon projet qui démontre une vraie maîtrise agentique... Idéal pour un rôle IA intermédiaire, à creuser en entretien."
         }}
-      ],
-      "coherence_globale": {{
-        "score": 85,
-        "commentaire": "Ensemble de projets cohérent avec le poste visé"
-      }}
+      ]
     }}
 

src/parser_flow/CV_agent_flow.py

@@ -24,16 +24,6 @@ logger = logging.getLogger(__name__)
 
 #_____________________________________________________________________________________
 
-# Configuration du logger pour capturer la verbosité dans un fichier
-verbose_logger = logging.getLogger("crewai_verbose")
-verbose_logger.setLevel(logging.INFO)
-
-# Création du fichier de log (écrase le précédent à chaque run avec 'w')
-file_handler = logging.FileHandler("agents_trace.log", mode='w', encoding='utf-8')
-formatter = logging.Formatter('%(asctime)s - %(message)s')
-file_handler.setFormatter(formatter)
-verbose_logger.addHandler(file_handler)
-
 class CVAgentOrchestrator:
     """Orchestrateur multi-agents pour le parsing et l'analyse de CV."""
 
@@ -43,13 +33,8 @@ class CVAgentOrchestrator:
         self.agents_config = self._load_yaml("agents.yaml")
         self.tasks_config = self._load_yaml("tasks.yaml")
         self.metiers_data = self._load_metiers()
-        self.skill_domain_map = self._load_skill_domain_map()
         self._create_agents()
 
-    # ──────────────────────────────────────────────
-    # Chargement des configurations
-    # ──────────────────────────────────────────────
-
     def _load_yaml(self, filename: str) -> Dict:
         base_path = os.path.dirname(os.path.dirname(__file__))
         config_path = os.path.join(base_path, "config", filename)
@@ -57,29 +42,12 @@ class CVAgentOrchestrator:
             return yaml.safe_load(f)
 
     def _load_metiers(self) -> List[Dict]:
-        """Charge le référentiel de métiers (sans les embeddings pour économiser la mémoire)."""
+        """Charge le référentiel de métiers (avec embeddings)."""
         base_path = os.path.dirname(os.path.dirname(__file__))
         metiers_path = os.path.join(base_path, "data", "metiers.json")
         with open(metiers_path, "r", encoding="utf-8") as f:
             data = json.load(f)
-        metiers = []
-        for m in data.get("metiers", []):
-            clean = {k: v for k, v in m.items() if k != "embedding"}
-            metiers.append(clean)
-        return metiers
-
-    def _load_skill_domain_map(self) -> Dict[str, List[str]]:
-        """Charge le mapping compétences -> domaines."""
-        base_path = os.path.dirname(os.path.dirname(__file__))
-        map_path = os.path.join(base_path, "config", "skill_domain_map.json")
-        with open(map_path, "r", encoding="utf-8") as f:
-            return json.load(f)
-
-    # ──────────────────────────────────────────────
-    # Création des agents
-    # ──────────────────────────────────────────────
-
-
+        return data.get("metiers", [])
 
     def _create_agents(self):
         def make_agent(name, llm_override=None):
@@ -90,12 +58,9 @@ class CVAgentOrchestrator:
                 verbose=True,
                 max_iter=1,
                 respect_context_window=True,
-                # logs callbackagent
-                step_callback=lambda step: verbose_logger.info(f"Agent {name} Step: {step}"),
             )
 
-        # Phase 2 : Agents d'extraction (existants)
-        self.cv_splitter = make_agent("cv_splitter", llm_override=self.big_llm)
+        self.cv_splitter = make_agent("cv_splitter")
         self.skills_extractor = make_agent("skills_extractor")
         self.experience_extractor = make_agent("experience_extractor")
         self.project_extractor = make_agent("project_extractor")
@@ -105,11 +70,10 @@ class CVAgentOrchestrator:
         self.etudiant_detector = make_agent("etudiant_detector")
         self.identity_extractor = make_agent("identity_extractor")
 
-        # Phase 3 : Agents d'analyse et recommandation (nouveaux)
-        self.header_analyzer = make_agent("header_analyzer", llm_override=self.big_llm)
-        self.metier_matcher = make_agent("metier_matcher", llm_override=self.big_llm)
-        self.cv_quality_checker = make_agent("cv_quality_checker")
-        self.project_analyzer = make_agent("project_analyzer")
+        self.header_analyzer = make_agent("header_analyzer")
+        self.metier_matcher = make_agent("metier_matcher")
+        self.cv_quality_checker = make_agent("cv_quality_checker", llm_override=self.big_llm)
+        self.project_analyzer = make_agent("project_analyzer", llm_override=self.big_llm)
 
     # ──────────────────────────────────────────────
     # PHASE 1 : Découpage du CV en sections
@@ -138,25 +102,41 @@ class CVAgentOrchestrator:
         return parsed
 
     # ──────────────────────────────────────────────
-    # PHASE 2 : Extraction parallèle (8 agents)
+    # PHASE 2 : Extraction et Analyse Parallèles
     # ──────────────────────────────────────────────
 
-    async def extract_all_sections(
-        self, sections: Dict[str, str], cv_raw_start: str = "", file_name: str = ""
+    async def run_all_agents(
+        self, sections: Dict[str, str], cv_raw_start: str = "", cv_full_text: str = "", file_name: str = "", page_count: int = 1
     ) -> Dict[str, Any]:
-        """Exécute les 8 tâches d'extraction en parallèle."""
+        """Exécute toutes les tâches d'extraction et d'analyse en parallèle."""
+        
+        raw_header = sections.get("header", "")
+        raw_experiences = sections.get("experiences", "")
+        raw_projects = sections.get("projects", "")
+        raw_skills = sections.get("skills", "")
+        raw_education = sections.get("education", "")
+        raw_languages = sections.get("languages", "")
+        safe_cv_raw = cv_raw_start[:2000].replace("{", "{{").replace("}", "}}")
+        safe_header = raw_header.replace("{", "{{").replace("}", "}}")
+
+        from src.services.metier_pre_filter import get_top_k_metiers
+        top_metiers = get_top_k_metiers(
+            metiers_data=self.metiers_data,
+            experiences_summary=raw_experiences[:2000],
+            projects_summary=raw_projects[:2000],
+            hard_skills=raw_skills[:2000],
+            soft_skills="",
+            k=3
+        )
+        metiers_reference = self._prepare_metiers_for_prompt(top_metiers)
 
         def create_task_async(task_key, agent, **kwargs):
             t_config = self.tasks_config[task_key].copy()
             t_description = t_config["description"]
-            
-            # Éviter les erreurs de formattage si des clés manquent ou sont mal échappées (ex: accolades dans le texte du CV)
             try:
-                # Utiliser format_map pour plus de flexibilité si besoin, mais format() est standard
                 t_config["description"] = t_description.format(**kwargs)
             except KeyError as e:
                 logger.warning(f"KeyError formatting task '{task_key}': {e}. Falling back to manual replace.")
-                # Fallback manuel sécurisé pour les clés présentes
                 desc = t_description
                 for k, v in kwargs.items():
                     placeholder = "{" + k + "}"
@@ -171,69 +151,40 @@ class CVAgentOrchestrator:
             return (task_key, c.kickoff_async())
 
         tasks_def = [
-            (
-                "skills_task",
-                self.skills_extractor,
-                {
-                    "experiences": sections.get("experiences", ""),
-                    "projects": sections.get("projects", ""),
-                    "skills": sections.get("skills", ""),
-                    "education": sections.get("education", ""),
-                },
-            ),
-            (
-                "experience_task",
-                self.experience_extractor,
-                {"experiences": sections.get("experiences", "")},
-            ),
-            (
-                "project_task",
-                self.project_extractor,
-                {"projects": sections.get("projects", "")},
-            ),
-            (
-                "education_task",
-                self.education_extractor,
-                {"education": sections.get("education", "")},
-            ),
-            (
-                "reconversion_task",
-                self.reconversion_detector,
-                {
-                    "experiences": sections.get("experiences", ""),
-                    "education": sections.get("education", ""),
-                },
-            ),
-            (
-                "language_task",
-                self.language_extractor,
-                {
-                    "languages": sections.get("languages", ""),
-                    "cv_raw_start": cv_raw_start[:500],
-                },
-            ),
-            (
-                "etudiant_task",
-                self.etudiant_detector,
-                {
-                    "education": sections.get("education", ""),
-                    "current_date": datetime.now().strftime("%Y-%m-%d"),
-                },
-            ),
-            (
-                "identity_task",
-                self.identity_extractor,
-                {
-                    "header": sections.get("header", ""),
-                    "cv_raw_start": cv_raw_start[:1500],
-                    "file_name": file_name,
-                },
-            ),
+            ("skills_task", self.skills_extractor, {"experiences": raw_experiences, "projects": raw_projects, "skills": raw_skills, "education": raw_education}),
+            ("experience_task", self.experience_extractor, {"experiences": raw_experiences}),
+            ("project_task", self.project_extractor, {"projects": raw_projects}),
+            ("education_task", self.education_extractor, {"education": raw_education}),
+            ("reconversion_task", self.reconversion_detector, {"experiences": raw_experiences, "education": raw_education}),
+            ("language_task", self.language_extractor, {"languages": raw_languages, "cv_raw_start": cv_raw_start[:500]}),
+            ("etudiant_task", self.etudiant_detector, {"education": raw_education, "current_date": datetime.now().strftime("%Y-%m-%d")}),
+            ("identity_task", self.identity_extractor, {"header": raw_header, "cv_raw_start": cv_raw_start[:1500], "file_name": file_name}),
+            ("poste_visé_task", self.header_analyzer, {"header": safe_header, "cv_raw_start": safe_cv_raw}),
+            ("cv_quality_task", self.cv_quality_checker, {
+                "header": safe_header,
+                "page_count": page_count,
+                "cv_full_text": cv_full_text[:6000],
+                "cv_raw_start": safe_cv_raw,
+                "skills": raw_skills[:2000],
+                "experiences": raw_experiences[:3000],
+                "projects": raw_projects[:2000],
+                "education": raw_education[:2000],
+            }),
+            ("metier_matching_task", self.metier_matcher, {
+                "header": safe_header,
+                "skills": raw_skills[:2000],
+                "experiences": raw_experiences[:3000],
+                "projects": raw_projects[:2000],
+                "education": raw_education[:2000],
+                "metiers_reference": metiers_reference,
+            }),
+            ("project_analysis_task", self.project_analyzer, {
+                "header": safe_header,
+                "projects": raw_projects[:3000],
+            }),
         ]
 
-        task_coroutines = [
-            create_task_async(key, agent, **kwargs) for key, agent, kwargs in tasks_def
-        ]
+        task_coroutines = [create_task_async(key, agent, **kwargs) for key, agent, kwargs in tasks_def]
         keys = [t[0] for t in task_coroutines]
         coroutines = [t[1] for t in task_coroutines]
         results_list = await asyncio.gather(*coroutines, return_exceptions=True)
@@ -245,530 +196,147 @@ class CVAgentOrchestrator:
             else:
                 results_map[key] = result
 
-        return self._aggregate_extraction_results(results_map)
-
-    # ──────────────────────────────────────────────
-    # PHASE 3a : Analyse d'en-tête (indépendante, tourne en // avec Phase 2)
-    # ──────────────────────────────────────────────
-
-    async def run_header_analysis(
-        self,
-        sections: Dict[str, str],
-        cv_raw_start: str = "",
-        cv_full_text: str = "",
-    ) -> Dict:
-        """Extrait le poste visé depuis l'en-tête du CV.
-
-        Ne dépend que de Phase 1 (sections) → peut tourner en PARALLÈLE avec Phase 2.
-        """
-        header_section = sections.get("header", "")
-        raw_for_header = cv_raw_start[:2000] if cv_raw_start else cv_full_text[:2000]
-        safe_cv_raw = raw_for_header.replace("{", "{{").replace("}", "}}")
-        safe_header = header_section.replace("{", "{{").replace("}", "}}")
-
-        header_data: Dict = {
-            "poste_vise": "Non identifié",
-            "niveau_seniorite": "non précisé",
-            "confiance": 0,
-        }
-
-        try:
-            t_config = self.tasks_config["poste_visé_task"].copy()
-            t_config["description"] = t_config["description"].format(
-                cv_raw_start=safe_cv_raw,
-                header=safe_header,
-            )
-            task = Task(config=t_config, agent=self.header_analyzer)
-            crew = Crew(agents=[self.header_analyzer], tasks=[task], verbose=False)
-            header_result = await crew.kickoff_async()
-
-            if header_result:
-                header_data = self._parse_json_output(
-                    header_result,
-                    {"poste_vise": "Non identifié", "niveau_seniorite": "non précisé", "confiance": 0},
-                )
-                logger.info(
-                    f"Header analyzer : poste_vise='{header_data.get('poste_vise')}', "
-                    f"confiance={header_data.get('confiance')}"
-                )
-        except Exception as e:
-            logger.error(f"Header analyzer failed: {e}", exc_info=True)
-
-        # Fallback programmatique si le LLM n'a pas trouvé le poste
-        if header_data.get("poste_vise", "Non identifié") == "Non identifié":
-            logger.warning("Header analyzer 'Non identifié' → fallback programmatique...")
-            fallback = self._fallback_extract_poste_vise(cv_full_text, header_section)
-            if fallback:
-                header_data["poste_vise"] = fallback
-                header_data["source_detection"] = "fallback_programmatique"
-                header_data["confiance"] = 70
-                logger.info(f"Fallback found poste_vise: '{fallback}'")
-
-        return header_data
-
-    # ───────────────────────────��──────────────────
-    # PHASE 3b : Analyse & Recommandation (3 agents parallèles)
-    # ──────────────────────────────────────────────
-
-    async def analyze_and_recommend(
-        self,
-        cv_full_text: str,
-        sections: Dict[str, str],
-        extraction: Dict[str, Any],
-        cv_raw_start: str = "",
-        header_data: Dict = None,
-    ) -> Dict[str, Any]:
-        """Exécute les 3 tâches d'analyse en parallèle.
-
-        header_data est pré-calculé par run_header_analysis (en // avec Phase 2).
-        """
-        if header_data is None:
-            logger.warning("analyze_and_recommend sans header_data — valeurs par défaut utilisées.")
-            header_data = {"poste_vise": "Non identifié", "niveau_seniorite": "non précisé", "confiance": 0}
-
-        candidat = extraction.get("candidat", {})
-        competences = candidat.get("compétences", {})
-        hard_skills = competences.get("hard_skills", [])
-        soft_skills = competences.get("soft_skills", [])
-        skills_with_context = competences.get("skills_with_context", [])
-        reconversion = candidat.get("reconversion", {})
-
-        skill_domains = self._map_skills_to_domains(hard_skills)
-        methodologies = self._extract_methodologies(hard_skills, skill_domains)
-
-        experiences_summary = json.dumps(
-            candidat.get("expériences", []), ensure_ascii=False
-        )[:3000]
-        projets = candidat.get("projets", {})
-        professional_projects = json.dumps(
-            projets.get("professional", []), ensure_ascii=False
-        )[:2000]
-        personal_projects = json.dumps(
-            projets.get("personal", []), ensure_ascii=False
-        )[:2000]
-        projects_summary = f"Pro: {professional_projects}\nPerso: {personal_projects}"
-        reconversion_data = json.dumps(reconversion, ensure_ascii=False) if reconversion else "{}"
-
-        metiers_reference = self._prepare_metiers_for_prompt()
-
-        poste_vise = header_data.get("poste_vise", "Non identifié")
-        niveau_seniorite = header_data.get("niveau_seniorite", "non précisé")
-        metier_reference_detail = self._get_metier_reference_for_poste(poste_vise)
-
-        raw_for_header = cv_raw_start[:2000] if cv_raw_start else cv_full_text[:2000]
-        safe_cv_raw = raw_for_header.replace("{", "{{").replace("}", "}}")
-
-        def create_task_async(task_key, agent, **kwargs):
-            t_config = self.tasks_config[task_key].copy()
-            t_config["description"] = t_config["description"].format(**kwargs)
-            task = Task(config=t_config, agent=agent)
-            c = Crew(agents=[agent], tasks=[task], verbose=False)
-            return (task_key, c.kickoff_async())
-
-        # 3 agents en parallèle (quality + metier matching + project analysis)
-        parallel_tasks = [
-            (
-                "cv_quality_task",
-                self.cv_quality_checker,
-                {
-                    "cv_full_text": cv_full_text[:6000],
-                    "cv_raw_start": safe_cv_raw,
-                    "skills_with_context": json.dumps(skills_with_context, ensure_ascii=False)[:2000],
-                    "experiences_summary": experiences_summary,
-                    "projects_summary": projects_summary[:2000],
-                    "niveau_seniorite": niveau_seniorite,
-                    "reconversion_data": reconversion_data,
-                },
-            ),
-            (
-                "metier_matching_task",
-                self.metier_matcher,
-                {
-                    "poste_vise": poste_vise,
-                    "hard_skills": json.dumps(hard_skills, ensure_ascii=False),
-                    "soft_skills": json.dumps(soft_skills, ensure_ascii=False),
-                    "skill_domains": json.dumps(skill_domains, ensure_ascii=False),
-                    "methodologies": json.dumps(methodologies, ensure_ascii=False),
-                    "experiences_summary": experiences_summary,
-                    "projects_summary": projects_summary[:2000],
-                    "reconversion_data": reconversion_data,
-                    "metiers_reference": metiers_reference,
-                },
-            ),
-            (
-                "project_analysis_task",
-                self.project_analyzer,
-                {
-                    "poste_vise": poste_vise,
-                    "metier_reference_detail": metier_reference_detail,
-                    "professional_projects": professional_projects,
-                    "personal_projects": personal_projects,
-                    "reconversion_data": reconversion_data,
-                },
-            ),
-        ]
-
-        task_coroutines = [
-            create_task_async(key, agent, **kwargs) for key, agent, kwargs in parallel_tasks
-        ]
-        keys = [t[0] for t in task_coroutines]
-        coroutines = [t[1] for t in task_coroutines]
-        results_list = await asyncio.gather(*coroutines, return_exceptions=True)
-
-        analysis_results = {}
-        for key, result in zip(keys, results_list):
-            if isinstance(result, Exception):
-                logger.error(f"Analysis task '{key}' failed: {result}")
-            else:
-                analysis_results[key] = result
-
-        recommendations = self._aggregate_recommendations(analysis_results, header_data)
-
-        # ── Filtre dur : ne garder que les projets issus de la section projets ──
-        extracted_titles: set[str] = set()
-        for p in projets.get("professional", []):
-            if isinstance(p, dict) and p.get("title"):
-                extracted_titles.add(p["title"].strip().lower())
-        for p in projets.get("personal", []):
-            if isinstance(p, dict) and p.get("title"):
-                extracted_titles.add(p["title"].strip().lower())
-
-        if extracted_titles:
-            def _is_extracted_project(titre: str) -> bool:
-                t = titre.strip().lower()
-                if t in extracted_titles:
-                    return True
-                return any(t in ref or ref in t for ref in extracted_titles)
-
-            recommendations["analyse_projets"] = [
-                p for p in recommendations.get("analyse_projets", [])
-                if isinstance(p, dict) and _is_extracted_project(p.get("titre", ""))
-            ]
-            logger.info(
-                f"Filtre projets : {len(recommendations['analyse_projets'])} projets conservés "
-                f"sur {len(extracted_titles)} extraits."
-            )
-
-        return recommendations
-
-    # ──────────────────────────────────────────────
-    # Mapping compétences -> domaines
-    # ──────────────────────────────────────────────
-
-    def _map_skills_to_domains(self, hard_skills: List[str]) -> Dict[str, List[str]]:
-        """Mappe les compétences du candidat à leurs domaines métier."""
-        result = {}
-        for skill in hard_skills:
-            skill_lower = skill.lower().strip()
-            for domain, domain_skills in self.skill_domain_map.items():
-                if skill_lower in domain_skills:
-                    if domain not in result:
-                        result[domain] = []
-                    result[domain].append(skill)
-                    break
-        return result
-
-    def _prepare_metiers_for_prompt(self) -> str:
-        """Prépare le référentiel métiers COMPLET (30 métiers) pour le prompt."""
-        lines = []
-        for m in self.metiers_data:
-            mid = m.get("id", "?")
-            nom = m.get("nom", "?")
-            cat = m.get("categorie", "?")
-            comp = m.get("competences_techniques", [])
-            outils = m.get("outils_technologies", [])
-            soft = m.get("competences_soft", [])
-            niveau = m.get("niveau_etude", "?")
-            exp = m.get("experience_requise", "?")
-            lines.append(
-                f"[{mid}] {nom} ({cat})\n"
-                f"  Compétences techniques: {', '.join(comp)}\n"
-                f"  Outils: {', '.join(outils)}\n"
-                f"  Soft skills: {', '.join(soft[:3])}\n"
-                f"  Niveau: {niveau} | Expérience: {exp}"
-            )
-        return "\n\n".join(lines)
-
-    def _get_metier_reference_for_poste(self, poste_vise: str) -> str:
-        """Trouve les métiers les plus proches du poste visé pour contextualiser l'analyse de projets."""
-        if not poste_vise or poste_vise == "Non identifié":
-            return "Aucun métier de référence spécifique. Analyser les projets selon leur qualité intrinsèque."
-
-        poste_lower = poste_vise.lower()
-        scored = []
-
-        for m in self.metiers_data:
-            nom_lower = m.get("nom", "").lower()
-            id_lower = m.get("id", "").lower()
-            desc_lower = m.get("description", "").lower()
-            score = 0
-
-            keywords = [w for w in poste_lower.replace("/", " ").replace("-", " ").split() if len(w) > 2]
-            for kw in keywords:
-                if kw in nom_lower:
-                    score += 3
-                if kw in id_lower:
-                    score += 2
-                if kw in desc_lower:
-                    score += 1
-
-            nom_keywords = [w for w in nom_lower.replace("/", " ").replace("-", " ").split() if len(w) > 2]
-            for kw in nom_keywords:
-                if kw in poste_lower:
-                    score += 3
-
-            if score > 0:
-                scored.append((score, m))
-
-        scored.sort(key=lambda x: -x[0])
-
-        if not scored:
-            return "Poste visé non trouvé dans le référentiel. Analyser les projets selon leur qualité intrinsèque."
-
-        lines = ["Métier(s) de référence les plus proches du poste visé :"]
-        for _, m in scored[:3]:
-            mid = m.get("id")
-            nom = m.get("nom")
-            comp = m.get("competences_techniques", [])
-            outils = m.get("outils_technologies", [])
-            missions = m.get("missions_principales", [])
-            lines.append(
-                f"\n[{mid}] {nom}\n"
-                f"  Compétences attendues: {', '.join(comp)}\n"
-                f"  Outils attendus: {', '.join(outils)}\n"
-                f"  Missions principales: {'; '.join(missions[:3])}"
-            )
-        return "\n".join(lines)
-
-    def _extract_methodologies(self, hard_skills: List[str], skill_domains: Dict[str, List[str]]) -> List[str]:
-        """Extrait les méthodologies de travail du candidat."""
-        methodology_keywords = {
-            "agile", "scrum", "kanban", "devops", "ci/cd", "cicd", "tdd", "bdd",
-            "design thinking", "lean", "safe", "xp", "pair programming",
-            "code review", "sprint", "product owner", "scrum master",
-            "rgpd", "rgaa",
-        }
-
-        methodologies = []
-        for skill in hard_skills:
-            if skill.lower().strip() in methodology_keywords:
-                methodologies.append(skill)
-
-        if "gestion_projet" in skill_domains:
-            for skill in skill_domains["gestion_projet"]:
-                if skill not in methodologies:
-                    methodologies.append(skill)
-
-        if "devops" in skill_domains:
-            for skill in skill_domains["devops"]:
-                s = skill.lower()
-                if any(kw in s for kw in ["ci", "cd", "github actions", "gitlab ci"]):
-                    if skill not in methodologies:
-                        methodologies.append(skill)
-
-        return methodologies
-
-    # ──────────────────────────────────────────────
-    # Agrégation des résultats d'extraction (Phase 2)
-    # ──────────────────────────────────────────────
-
-    def _aggregate_extraction_results(self, results_map: Dict[str, Any]) -> Dict[str, Any]:
-        """Agrège les résultats d'extraction (identique au module existant)."""
+        return self._build_final_json(results_map)
 
+    def _build_final_json(self, results_map: Dict[str, Any]) -> Dict[str, Any]:
+        """Agrège les résultats de toutes les tâches en un JSON final."""
+        
         def get_parsed(key, default=None):
             if key not in results_map:
                 return default
             return self._parse_json_output(results_map[key], default)
 
+        # Extraction
         competences = get_parsed("skills_task", {"hard_skills": [], "soft_skills": []})
         experiences = get_parsed("experience_task", [])
         projets = get_parsed("project_task", {"professional": [], "personal": []})
         formations = get_parsed("education_task", [])
-        reconversion = get_parsed("reconversion_task", {}).get(
-            "reconversion_analysis", {}
-        )
+        reconversion = get_parsed("reconversion_task", {}).get("reconversion_analysis", {})
         etudiant_data = get_parsed("etudiant_task", {}).get("etudiant_analysis", {})
+        
         latest_end_date = etudiant_data.get("latest_education_end_date")
         if latest_end_date:
-            is_student_by_date = self._is_still_student(latest_end_date)
-            etudiant_data["is_etudiant"] = is_student_by_date
+            etudiant_data["is_etudiant"] = self._is_ongoing_date(latest_end_date)
+
+        is_en_poste = False
+        if isinstance(experiences, list):
+            for exp in experiences:
+                end_date = exp.get("end_date")
+                if isinstance(exp, dict) and end_date:
+                    if self._is_ongoing_date(end_date):
+                        is_en_poste = True
+                        break
 
         langues_raw = get_parsed("language_task", {})
+        identity = get_parsed("identity_task", {})
 
+        # Nettoyage des doublons dans hard_skills (case-insensitive)
         if isinstance(competences, dict):
             raw_skills = competences.get("hard_skills", [])
             seen = set()
             unique_skills = []
             for skill in raw_skills:
-                key = (
-                    str(skill).lower()
-                    if not isinstance(skill, str)
-                    else skill.lower()
-                )
+                key = str(skill).lower() if not isinstance(skill, str) else skill.lower()
                 if key not in seen:
                     seen.add(key)
                     unique_skills.append(skill)
             competences["hard_skills"] = unique_skills
 
-        identity = get_parsed("identity_task", {})
-
-        return {
-            "candidat": {
-                "first_name": (
-                    identity.get("first_name")
-                    if isinstance(identity, dict)
-                    else None
-                ),
-                "compétences": competences,
-                "expériences": experiences,
-                "reconversion": reconversion,
-                "projets": projets,
-                "formations": formations,
-                "etudiant": etudiant_data,
-                "langues": (
-                    langues_raw.get("langues", [])
-                    if isinstance(langues_raw, dict)
-                    else []
-                ),
-            }
+        candidat = {
+            "first_name": identity.get("first_name") if isinstance(identity, dict) else None,
+            "langues": langues_raw.get("langues", []) if isinstance(langues_raw, dict) else [],
+            "compétences": competences,
+            "expériences": experiences,
+            "reconversion": reconversion,
+            "projets": projets,
+            "formations": formations,
+            "etudiant": etudiant_data,
+            "is_en_poste": is_en_poste,
         }
 
-    # ──────────────────────────────────────────────
-    # Agrégation des recommandations (Phase 3)
-    # ──────────────────────────────────────────────
-
-    def _aggregate_recommendations(
-        self,
-        analysis_results: Dict[str, Any],
-        header_data: Dict,
-    ) -> Dict[str, Any]:
-        """Agrège les résultats d'analyse en un objet recommandations structuré."""
-
-        def get_parsed(key, default=None):
-            if key not in analysis_results:
-                return default
-            return self._parse_json_output(analysis_results[key], default)
-
+        # Analyse
+        header_data = get_parsed("poste_visé_task", {"poste_vise": "Non identifié", "confiance": 0})
         metier_data = get_parsed("metier_matching_task", {"postes_recommandes": []})
-        quality_data = get_parsed(
-            "cv_quality_task",
-            {"score_global": 0, "red_flags": [], "conseils_prioritaires": []},
-        )
+        quality_data = get_parsed("cv_quality_task", {"score_global": 0, "red_flags": [], "conseils_prioritaires": []})
         project_data = get_parsed("project_analysis_task", {"analyse_projets": []})
 
-        # Conseils d'amélioration : uniquement les conseils qualité CV
         conseils = []
         if isinstance(quality_data, dict):
             conseils.extend(quality_data.get("conseils_prioritaires", []))
 
-        return {
+        # Filtre de sécurité : ne garder dans l'analyse de projets que ceux issus de l'extraction
+        extracted_titles: set[str] = set()
+        for p in (projets.get("professional", []) if isinstance(projets, dict) else []):
+            if isinstance(p, dict) and p.get("title"):
+                extracted_titles.add(p["title"].strip().lower())
+        for p in (projets.get("personal", []) if isinstance(projets, dict) else []):
+            if isinstance(p, dict) and p.get("title"):
+                extracted_titles.add(p["title"].strip().lower())
+
+        analyse_projets = project_data.get("analyse_projets", []) if isinstance(project_data, dict) else []
+        if extracted_titles and isinstance(analyse_projets, list):
+            def _is_extracted_project(titre: str) -> bool:
+                t = titre.strip().lower()
+                return t in extracted_titles or any(t in ref or ref in t for ref in extracted_titles)
+
+            analyse_projets = [p for p in analyse_projets if isinstance(p, dict) and _is_extracted_project(p.get("titre", ""))]
+
+        recommandations = {
             "header_analysis": header_data,
-            "postes_recommandes": (
-                metier_data.get("postes_recommandes", [])
-                if isinstance(metier_data, dict)
-                else []
-            ),
-            "analyse_poste_vise": (
-                metier_data.get("analyse_poste_vise", "")
-                if isinstance(metier_data, dict)
-                else ""
-            ),
+            "postes_recommandes": metier_data.get("postes_recommandes", []) if isinstance(metier_data, dict) else [],
+            "analyse_poste_vise": metier_data.get("analyse_poste_vise", "") if isinstance(metier_data, dict) else "",
             "qualite_cv": quality_data,
-            "analyse_projets": (
-                project_data.get("analyse_projets", [])
-                if isinstance(project_data, dict)
-                else []
-            ),
-            "coherence_globale_projets": (
-                project_data.get("coherence_globale", {})
-                if isinstance(project_data, dict)
-                else {}
-            ),
+            "analyse_projets": analyse_projets,
+            "coherence_globale_projets": project_data.get("coherence_globale", {}) if isinstance(project_data, dict) else {},
             "conseils_amelioration": conseils,
         }
 
-    # ──────────────────────────────────────────────
-    # Utilitaires
-    # ──────────────────────────────────────────────
-
-    def _fallback_extract_poste_vise(
-        self, cv_full_text: str, header_section: str
-    ) -> str:
-        """Extraction programmatique du poste visé en fallback.
-
-        Cherche la ligne de titre dans l'en-tête du CV en filtrant les lignes
-        qui ne sont clairement PAS un titre de poste (email, téléphone, liens,
-        titres de section, compétences techniques).
-        """
-        import re
-
-        # Patterns qui NE sont PAS un titre de poste
-        skip_patterns = [
-            r"^#{1,6}\s",                          # Titres markdown
-            r"@",                                   # Email
-            r"^\+?\d[\d\s\-\.]{7,}",              # Téléphone
-            r"^http|^www\.|linkedin|github",        # URLs/liens
-            r"^\*{1,3}[A-Z]",                      # Bold section headers
-            r"^(CONTACT|LIENS|STACK|LANGUES|CENTRES|EXPERIENCE|FORMATION|PROJET|COMPÉTENCES|EDUCATION)",  # Section headings
-            r"^(Python|SQL|JavaScript|React|FastAPI|Docker|AWS|Git|CI)",  # Skills
-            r"^(Ile-de-France|Paris|Lyon|Marseille|France)",  # Locations
-            r"^\d{2}\s?\d{2}\s?\d{2}",            # Phone numbers
-            r"^(Français|Anglais|Portugais|Espagnol)",  # Languages
-            r"^(Langages|Frameworks|Analytics|DevOps|Méthodologies|IA &|BI :)",  # Skill categories
-            r"^(Blockchain|Jeux de rôle|Randonnée)",  # Interests
-            r"^\s*$",                               # Empty lines
-            r"^[\*\-\|]",                           # List items and table separators
-        ]
-
-        # Mots-clés qui INDIQUENT un titre de poste
-        title_indicators = [
-            "développeur", "developer", "ingénieur", "engineer", "chef de projet",
-            "data analyst", "data scientist", "data engineer", "consultant",
-            "architecte", "manager", "lead", "senior", "junior", "fullstack",
-            "full-stack", "full stack", "backend", "frontend", "devops",
-            "product", "project", "spécialiste", "expert", "analyste",
-            "mlops", "ai", "ia", "machine learning", "nlp", "deep learning",
-        ]
+        return {
+            "candidat": candidat,
+            "recommandations": recommandations
+        }
 
-        def _has_title_indicator(text_lower: str) -> bool:
-            for indicator in title_indicators:
-                if len(indicator) <= 3:
-                    if re.search(r"\b" + re.escape(indicator) + r"\b", text_lower):
-                        return True
-                else:
-                    if indicator in text_lower:
-                        return True
-            return False
+    def _prepare_metiers_for_prompt(self, metiers: List[Dict] = None) -> str:
+        """Prépare le référentiel métiers restreint pour le prompt."""
+        if metiers is None:
+            metiers = self.metiers_data
+            
+        flat_list = []
+        def _flatten(job_list):
+            for job in job_list:
+                if "metiers" in job:
+                    _flatten(job["metiers"])
+                elif "id" in job:
+                    flat_list.append(job)
+        _flatten(metiers)
+        
+        lines = []
+        for m in flat_list:
+            mid = m.get("id", "?")
+            nom = m.get("nom", "?")
+            cat = m.get("categorie", "?")
+            comp = m.get("competences_techniques", [])
+            outils = m.get("outils_technologies", [])
+            soft = m.get("competences_soft", [])
+            niveau = m.get("niveau_etude", "?")
+            exp = m.get("experience_requise", "?")
+            lines.append(
+                f"[{mid}] {nom} ({cat})\n"
+                f"  Compétences techniques: {', '.join(comp)}\n"
+                f"  Outils: {', '.join(outils)}\n"
+                f"  Soft skills: {', '.join(soft[:3])}\n"
+                f"  Niveau: {niveau} | Expérience: {exp}"
+            )
+        return "\n\n".join(lines)
 
-        def _is_likely_title(line: str) -> bool:
-            stripped = line.strip().strip("#*_ ")
-            if len(line.split()) > 10:
-                return False
-            for pattern in skip_patterns:
-                if re.match(pattern, stripped, re.IGNORECASE):
-                    return False
-            return _has_title_indicator(stripped.lower())
-
-        # Chercher dans toutes les sources, par ordre de priorité
-        sources = [
-            ("header", header_section),
-            ("cv_text", cv_full_text[:3000]),
-        ]
 
-        for source_name, text in sources:
-            if not text:
-                continue
-            lines = text.split("\n")
-            for line in lines:
-                if _is_likely_title(line):
-                    clean = line.strip().strip("#*_ ")
-                    logger.info(f"Fallback: found title in {source_name}: '{clean}'")
-                    return clean
 
-        return ""
+    # ──────────────────────────────────────────────
+    # Utilitaires
+    # ──────────────────────────────────────────────
 
-    def _is_still_student(self, date_str: str) -> bool:
-        """Détermine si le candidat est encore étudiant à partir de la date de fin d'études."""
+    def _is_ongoing_date(self, date_str: str) -> bool:
+        """Détermine si une date (fin d'étude ou fin d'expérience) est dans le futur ou en cours."""
         if not date_str:
             return False
         date_str = str(date_str).lower().strip()

src/scripts/embed_metiers.py

@@ -0,0 +1,59 @@
+import json
+import os
+import sys
+
+# Add src's parent directory to path so we can run this directly if needed
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+from langchain_openai import OpenAIEmbeddings
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def get_job_text(job):
+    """
+    Formats job info using the "Miroir" strategy.
+    """
+    missions = ", ".join(job.get("missions_principales", []))
+    tech = ", ".join(job.get("competences_techniques", []))
+    outils = ", ".join(job.get("outils_technologies", []))
+    soft = ", ".join(job.get("competences_soft", []))
+    
+    text = f"MISSIONS: {missions}\n"
+    text += f"TECH_ET_OUTILS: {tech}, {outils}\n"
+    text += f"SOFT_SKILLS: {soft}"
+    return text
+
+def embed_metiers_file():
+    base_path = os.path.dirname(os.path.dirname(__file__))
+    metiers_path = os.path.join(base_path, "data", "metiers.json")
+    
+    print(f"Loading {metiers_path}...")
+    with open(metiers_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+        
+    embeddings_model = OpenAIEmbeddings(model="text-embedding-3-small")
+    
+    count = 0
+    def process_jobs(job_list):
+        nonlocal count
+        for job in job_list:
+            if "metiers" in job:
+                process_jobs(job["metiers"])
+            elif "id" in job:
+                print(f"Embedding {job.get('id')}...")
+                text = get_job_text(job)
+                emb = embeddings_model.embed_query(text)
+                job["embedding"] = emb
+                count += 1
+
+    process_jobs(data.get("metiers", []))
+    
+    print(f"Writing {count} embeddings to {metiers_path}...")
+    with open(metiers_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+        
+    print("Done!")
+
+if __name__ == "__main__":
+    embed_metiers_file()

src/services/cv_service.py

@@ -1,20 +1,16 @@
 """
 Service de parsing et analyse de CV enrichi.
-Pipeline optimisé :
-  Phase 1  : Découpage en sections
-  Phase 2  : Extraction parallèle (8 agents) — en // avec Phase 3a
-  Phase 3a : Analyse d'en-tête (header_analyzer) — en // avec Phase 2
-  Phase 3b : Analyse & Recommandation (3 agents parallèles)
+Pipeline ultra-optimisé :
+  Phase 1 : Découpage en sections (cv_splitter)
+  Phase 2 : Extraction et Analyse en STRICT PARALLÈLE (11 agents)
 
-Flux : Phase 1 → asyncio.gather(Phase 2, Phase 3a) → Phase 3b
-Gain estimé : ~5-8 secondes vs pipeline séquentiel précédent.
+Gain estimé : Temps de traitement grandement réduit.
 """
 
-import asyncio
 import logging
 from typing import Dict, Any
 
-from src.config.app_config import load_pdf, load_pdf_first_page_text
+from src.config.app_config import load_pdf, load_pdf_first_page_text, get_pdf_page_count
 from src.parser_flow.CV_agent_flow import CVAgentOrchestrator
 
 logger = logging.getLogger(__name__)
@@ -22,65 +18,28 @@ logger = logging.getLogger(__name__)
 
 async def parse_cv(pdf_path: str, file_name: str = "") -> Dict[str, Any]:
     """
-    Parse un CV avec extraction + analyse complète.
+    Parse un CV avec extraction + analyse complète en 2 phases.
 
     Retourne un JSON en 2 parties :
-    - candidat : données parsées du CV (identité, compétences, expériences, projets…)
-    - recommandations : analyse critique, matching métiers, qualité CV, header_analysis (poste_vise)
+    - candidat : données parsées du CV (identité, compétences, expériences, projets...)
+    - recommandations : analyse critique (7 critères JSON), matching métiers, qualité CV
     """
     orchestrator = CVAgentOrchestrator()
-
-    # Double extraction PDF :
-    # - cv_text    : Markdown (bon pour la structure des sections)
-    # - cv_raw_start : texte brut ordonné par position (fiable pour le header/nom/titre)
     cv_text = load_pdf(pdf_path)
     cv_raw_start = load_pdf_first_page_text(pdf_path)
+    page_count = get_pdf_page_count(pdf_path)
 
-    # ── Phase 1 : Découpage du CV en sections (séquentielle, nécessaire pour la suite) ──
     logger.info("Phase 1 : Découpage du CV en sections...")
     sections = await orchestrator.split_cv_sections(cv_text, cv_raw_start=cv_raw_start)
 
-    # ── Phase 2 + Phase 3a en PARALLÈLE ──────────────────────────────────────────────────
-    # Phase 2  : 8 agents d'extraction (skills, expériences, projets, etc.)
-    # Phase 3a : header_analyzer (poste visé) — ne dépend que de sections + cv_raw_start
-    logger.info("Phase 2 + Phase 3a : Extraction et analyse d'en-tête en parallèle...")
-    extraction, header_data = await asyncio.gather(
-        orchestrator.extract_all_sections(
-            sections, cv_raw_start=cv_raw_start, file_name=file_name
-        ),
-        orchestrator.run_header_analysis(
-            sections, cv_raw_start=cv_raw_start, cv_full_text=cv_text
-        ),
-    )
-
-    # ── Phase 3b : 3 agents d'analyse en parallèle ───────────────────────────────────────
-    logger.info("Phase 3b : Analyse et recommandation...")
-    recommendations = await orchestrator.analyze_and_recommend(
-        cv_full_text=cv_text,
-        sections=sections,
-        extraction=extraction,
+    logger.info("Phase 2 : Extraction et Analyse en strict parallèle...")
+    result = await orchestrator.run_all_agents(
+        sections,
         cv_raw_start=cv_raw_start,
-        header_data=header_data,
+        cv_full_text=cv_text,
+        file_name=file_name,
+        page_count=page_count
     )
 
-    candidat_raw = extraction.get("candidat", {})
-
-    # Assemblage ordonné : identité → langues → compétences → parcours
-    candidat = {
-        "first_name":   candidat_raw.get("first_name"),
-        "langues":      candidat_raw.get("langues", []),
-        "compétences":  candidat_raw.get("compétences", {}),
-        "expériences":  candidat_raw.get("expériences", []),
-        "projets":      candidat_raw.get("projets", {}),
-        "formations":   candidat_raw.get("formations", []),
-        "etudiant":     candidat_raw.get("etudiant", {}),
-        "reconversion": candidat_raw.get("reconversion", {}),
-    }
-
-    result = {
-        "candidat": candidat,
-        "recommandations": recommendations,
-    }
-
     logger.info("Parsing et analyse terminés.")
     return result

src/services/metier_pre_filter.py

@@ -0,0 +1,72 @@
+import math
+import logging
+from typing import Dict, List
+from langchain_openai import OpenAIEmbeddings
+
+logger = logging.getLogger(__name__)
+
+def compute_cosine_similarity(vec1: List[float], vec2: List[float]) -> float:
+    """Computes cosine similarity between two vectors without relying on numpy."""
+    numerator = sum(a * b for a, b in zip(vec1, vec2))
+    norm1 = math.sqrt(sum(a * a for a in vec1))
+    norm2 = math.sqrt(sum(b * b for b in vec2))
+    if norm1 == 0 or norm2 == 0:
+        return 0.0
+    return numerator / (norm1 * norm2)
+
+def get_top_k_metiers(
+    metiers_data: List[Dict],
+    experiences_summary: str,
+    projects_summary: str,
+    hard_skills: str,
+    soft_skills: str,
+    k: int = 3
+) -> List[Dict]:
+    """
+    Filters the job profiles (métiers) by cosine similarity to the candidate's profile.
+    Returns the top K job profiles.
+    """
+    # flatten list to extract nested metiers from the JSON dataset
+    flat_list = []
+    def _flatten(job_list):
+        for job in job_list:
+            if "metiers" in job:
+                _flatten(job["metiers"])
+            elif "id" in job:
+                flat_list.append(job)
+    
+    _flatten(metiers_data)
+
+    try:
+        if not flat_list:
+            return []
+            
+        embeddings_model = OpenAIEmbeddings(model="text-embedding-3-small")
+        
+        # Stratégie Miroir
+        text = f"EXPERIENCES_ET_ACTIONS: {experiences_summary}\n"
+        text += f"PROJETS_ET_OUTCOMES: {projects_summary}\n"
+        text += f"COMPETENCES_TECH_ET_SOFT: {hard_skills}, {soft_skills}"
+        
+        candidat_emb = embeddings_model.embed_query(text)
+        
+        scored_metiers = []
+        for job in flat_list:
+            # En cas de manque d'embedding, on met un score de 0
+            if "embedding" in job and job["embedding"]:
+                sim = compute_cosine_similarity(candidat_emb, job["embedding"])
+            else:
+                sim = 0.0
+            scored_metiers.append((sim, job))
+                    
+        # Sort by similarity in descending order
+        scored_metiers.sort(key=lambda x: x[0], reverse=True)
+        top_k = [item[1] for item in scored_metiers[:k]]
+        
+        logger.info(f"Top {k} métiers sélectionnés par embedding: {[m.get('id') for m in top_k]}")
+        return top_k
+        
+    except Exception as e:
+        logger.error(f"Erreur lors du pré-filtrage des métiers: {e}", exc_info=True)
+        # En cas d'erreur de clé d'API ou autre, on renvoie une liste par défaut (fallback)
+        return flat_list[:k]

test_api.py

@@ -0,0 +1,29 @@
+import asyncio
+import json
+import traceback
+from src.services.cv_service import parse_cv
+
+async def main():
+    pdf_path = "c:\\Users\\quent\\Documents\\Projets\\devellopement_AIRH - Copie\\CV - Quentin Loumeau - 2026.pdf"
+    print(f"Testing CV Parser with file: {pdf_path}")
+    
+    try:
+        # Define minimum metier data for the metier_matching_task
+        metiers_reference = {
+            "chef_projet_data_ia": {
+                "nom": "Chef de Projet Data / IA",
+                "competences": ["Python", "SQL", "Gestion de projet", "IA", "Machine Learning"]
+            }
+        }
+        
+        result = await parse_cv(pdf_path, "Chef de Projet Data / IA")
+        print("Success! Output saved to test_result.json")
+        with open("test_result.json", "w", encoding="utf-8") as f:
+            json.dump(result, f, indent=2, ensure_ascii=False)
+            
+    except Exception as e:
+        print(f"Error occurred: {e}")
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(main())

test_result.json

@@ -0,0 +1,581 @@
+{
+  "candidat": {
+    "first_name": "Quentin",
+    "langues": [
+      {
+        "langue": "Français",
+        "niveau": "Natif"
+      },
+      {
+        "langue": "Anglais",
+        "niveau": "Courant (C1)"
+      },
+      {
+        "langue": "Portugais",
+        "niveau": "Courant"
+      }
+    ],
+    "compétences": {
+      "hard_skills": [
+        "Python",
+        "SQL",
+        "Excel",
+        "React.js",
+        "FastAPI",
+        "LangChain",
+        "LangGraph",
+        "Scikit-learn",
+        "RAG",
+        "Pandas",
+        "PySpark",
+        "DBT",
+        "Dataiku",
+        "PostgreSQL",
+        "MongoDB",
+        "MinIO",
+        "Pinecone",
+        "Metabase",
+        "PowerBI",
+        "Mage.ai",
+        "AWS",
+        "Docker",
+        "Git",
+        "CI/CD",
+        "Selenium",
+        "BeautifulSoup4",
+        "N8n",
+        "Langflow",
+        "Gumloop"
+      ],
+      "soft_skills": [
+        "Leadership",
+        "Communication",
+        "Adaptation",
+        "Rigueur"
+      ],
+      "skills_with_context": [
+        {
+          "skill": "Python",
+          "context": "projet, académique"
+        },
+        {
+          "skill": "SQL",
+          "context": "académique"
+        },
+        {
+          "skill": "Excel",
+          "context": "sans contexte"
+        },
+        {
+          "skill": "React.js",
+          "context": "projet"
+        },
+        {
+          "skill": "FastAPI",
+          "context": "projet"
+        },
+        {
+          "skill": "LangChain",
+          "context": "projet"
+        },
+        {
+          "skill": "LangGraph",
+          "context": "projet"
+        },
+        {
+          "skill": "Scikit-learn",
+          "context": "académique"
+        },
+        {
+          "skill": "RAG",
+          "context": "expérience, projet"
+        },
+        {
+          "skill": "Pandas",
+          "context": "académique"
+        },
+        {
+          "skill": "PySpark",
+          "context": "certification"
+        },
+        {
+          "skill": "DBT",
+          "context": "certification"
+        },
+        {
+          "skill": "Dataiku",
+          "context": "expérience"
+        },
+        {
+          "skill": "PostgreSQL",
+          "context": "projet"
+        },
+        {
+          "skill": "MongoDB",
+          "context": "projet"
+        },
+        {
+          "skill": "MinIO",
+          "context": "projet"
+        },
+        {
+          "skill": "Pinecone",
+          "context": "projet"
+        },
+        {
+          "skill": "Metabase",
+          "context": "projet"
+        },
+        {
+          "skill": "PowerBI",
+          "context": "expérience, académique"
+        },
+        {
+          "skill": "Mage.ai",
+          "context": "projet"
+        },
+        {
+          "skill": "AWS",
+          "context": "sans contexte"
+        },
+        {
+          "skill": "Docker",
+          "context": "sans contexte"
+        },
+        {
+          "skill": "Git",
+          "context": "sans contexte"
+        },
+        {
+          "skill": "CI/CD",
+          "context": "sans contexte"
+        },
+        {
+          "skill": "Selenium",
+          "context": "projet"
+        },
+        {
+          "skill": "BeautifulSoup4",
+          "context": "sans contexte"
+        },
+        {
+          "skill": "N8n",
+          "context": "sans contexte"
+        },
+        {
+          "skill": "Langflow",
+          "context": "sans contexte"
+        },
+        {
+          "skill": "Gumloop",
+          "context": "sans contexte"
+        }
+      ]
+    },
+    "expériences": [
+      {
+        "Poste": "Alternant Data Analyste / Chef de Projet IA",
+        "Entreprise": "Enedis - Direction Audit Contrôle Interne Risques (DACIR)",
+        "start_date": "Déc. 2024",
+        "end_date": "Déc. 2025",
+        "responsabilités": [
+          "Développement de 5 tableaux de bords PowerBI à destination des 150 collaborateurs du contrôle interne",
+          "Paramétrage d'une solution RAG en test pour le Risk manager, ingestion de 40 documents techniques, travail du prompt et du flow agentique, évaluation du MRR",
+          "Refactorisation et optimisation de 10 flows dataiku de traitement des données d’analyses, réduction de 30% des étapes de traitement et création de documentation des process",
+          "Cadrage des besoins d'analyse de fraude et d'anomalies sur 6 projets majeurs, en animant des réunions avec une dizaine de collaborateurs",
+          "Animation d’ateliers de montée en compétence data mining auprès de 150 auditeurs"
+        ]
+      },
+      {
+        "Poste": "Pâtissier - Manager & Responsable Production",
+        "Entreprise": "Parcours international (UK, Suède, Australie)",
+        "start_date": "2009",
+        "end_date": "2023",
+        "responsabilités": [
+          "14 ans d’expérience : gestion d’équipes (jusqu’à 8 pers.), planification de production, relation client",
+          "Optimisation des processus de production, réduisant les pertes matières de ~20%",
+          "3 pays, 3 cultures : adaptation, communication en anglais au quotidien",
+          "Analyse des ventes et gestion budgétaire : suivi des marges, adaptation de la production en fonction des ventes"
+        ]
+      }
+    ],
+    "reconversion": {
+      "is_reconversion": true,
+      "context": "Le candidat a effectué une reconversion professionnelle en passant du domaine de la pâtisserie, où il a travaillé comme Manager & Responsable Production pendant 14 ans, à un domaine technologique en tant que Data Analyste et Chef de Projet IA. Il a suivi une formation en Data Analyst de février 2024 à juillet 2024, puis a poursuivi avec une formation Chef de Projet IA de novembre 2024 à décembre 2025.",
+      "date_reconversion": "2024-02"
+    },
+    "projets": {
+      "professional": [],
+      "personal": [
+        {
+          "title": "AIRH - Plateforme SaaS de recrutement augmenté (système multi-agents)",
+          "technologies": [
+            "React.js",
+            "FastAPI",
+            "CrewAI",
+            "LangGraph",
+            "PostgreSQL",
+            "MongoDB",
+            "MinIO",
+            "Metabase",
+            "Mage.ai"
+          ],
+          "outcomes": [
+            "Architecture d'un système multi-agents orchestrant l'analyse automatisée de CV et la simulation d'entretien dynamique",
+            "Moteur de scoring multi-dimensionnel avec détection de fraude automatisée",
+            "Pipeline de données complet orchestré avec Mage.ai",
+            "Pilotage de A à Z : Design Thinking, business plan, développement full-stack, déploiement"
+          ],
+          "domaine metier": "recrutement/RH"
+        },
+        {
+          "title": "FounderOS - Dashboard tout-en-un pour fondateurs de startups",
+          "technologies": [
+            "Next.js",
+            "TypeScript",
+            "Tailwind",
+            "API Gemini"
+          ],
+          "outcomes": [
+            "Outil complet : Lean Canvas, CRM Lite, veille stratégique, gestion financière, pipeline de contenu",
+            "Module d'intelligence concurrentielle avec scoring automatisé"
+          ],
+          "domaine metier": "entrepreneuriat/startups"
+        },
+        {
+          "title": "Data Jobs - Moteur de recommandation d'emploi RAG",
+          "technologies": [
+            "Python",
+            "LangChain",
+            "Pinecone",
+            "Selenium",
+            "API Groq"
+          ],
+          "outcomes": [
+            "Scraping et vectorisation de +2 000 offres d'emploi tech",
+            "Pertinence des recommandations améliorée de +40% via Prompt Engineering iteratif",
+            "Pilotage des sprints en tant que Scrum Master"
+          ],
+          "domaine metier": "recrutement/RH"
+        }
+      ]
+    },
+    "formations": [
+      {
+        "degree": "Chef de Projet IA - RNCP Niveau 7 (Bac+5)",
+        "institution": "Wild Code School",
+        "start_date": "Nov. 2024",
+        "end_date": "Déc. 2025"
+      },
+      {
+        "degree": "Data Analyst - RNCP Niveau 6 (Bac+3)",
+        "institution": "Wild Code School",
+        "start_date": "Fév. 2024",
+        "end_date": "Juil. 2024"
+      }
+    ],
+    "etudiant": {
+      "is_etudiant": false,
+      "niveau_etudes": "bac+5",
+      "specialite": "Chef de Projet IA",
+      "latest_education_end_date": "2025-12-31"
+    },
+    "is_en_poste": false
+  },
+  "recommandations": {
+    "header_analysis": {
+      "poste_vise": "Chef de Projet Data / IA - Spécialiste Systèmes Multi-Agents & Recrutement Tech",
+      "confiance": 90
+    },
+    "postes_recommandes": [
+      {
+        "metier_id": "data_analyst",
+        "nom": "Data Analyst",
+        "categorie": "Noyau data & analytique",
+        "score_matching": 88,
+        "detail_scores": {
+          "competences_techniques": 85,
+          "outils_technologies": 90,
+          "experiences_projets": 85,
+          "methodologies": 80
+        },
+        "competences_matchees": [
+          "SQL",
+          "Python",
+          "Power BI",
+          "Metabase"
+        ],
+        "competences_manquantes": [
+          "Looker",
+          "Qlik"
+        ],
+        "justification": "Le profil couvre 88% des compétences requises grâce à une solide maîtrise de SQL et Python, ainsi qu'une expérience significative avec Power BI et Metabase. Les méthodologies Agile et Scrum sont bien intégrées, ce qui est crucial pour ce rôle."
+      },
+      {
+        "metier_id": "data_engineer",
+        "nom": "Data Engineer",
+        "categorie": "Ingénierie data & IA",
+        "score_matching": 82,
+        "detail_scores": {
+          "competences_techniques": 80,
+          "outils_technologies": 85,
+          "experiences_projets": 80,
+          "methodologies": 75
+        },
+        "competences_matchees": [
+          "Python",
+          "SQL",
+          "PySpark",
+          "DBT",
+          "AWS",
+          "Docker"
+        ],
+        "competences_manquantes": [
+          "Apache Kafka",
+          "Flink"
+        ],
+        "justification": "Le candidat possède une bonne maîtrise des outils de transformation et de cloud, ainsi qu'une expérience en DevOps, ce qui est essentiel pour un Data Engineer. Cependant, l'expérience avec des outils de streaming comme Kafka est limitée."
+      },
+      {
+        "metier_id": "data_scientist",
+        "nom": "Data Scientist",
+        "categorie": "Noyau data & analytique",
+        "score_matching": 80,
+        "detail_scores": {
+          "competences_techniques": 75,
+          "outils_technologies": 80,
+          "experiences_projets": 85,
+          "methodologies": 70
+        },
+        "competences_matchees": [
+          "Python",
+          "Scikit-learn",
+          "LangChain",
+          "RAG"
+        ],
+        "competences_manquantes": [
+          "Deep learning",
+          "Spark"
+        ],
+        "justification": "Le profil est bien aligné avec les compétences en machine learning et en IA, notamment avec l'utilisation de LangChain et Scikit-learn. Cependant, une expérience plus approfondie en deep learning et Spark serait bénéfique."
+      }
+    ],
+    "analyse_poste_vise": "Le poste de Data Analyst est bien aligné avec le profil du candidat, qui possède une forte expérience en SQL, Python, et Power BI, ainsi qu'une bonne compréhension des méthodologies Agile et Scrum. Les compétences manquantes comme Looker et Qlik peuvent être acquises rapidement grâce à l'expérience existante avec d'autres outils BI.",
+    "qualite_cv": {
+      "score_global": 76,
+      "compatibilite_ats": {
+        "score": 83,
+        "details": "Sections principales standard et bien nommées : « EXPERIENCE PROFESSIONNELLE », « PROJETS CLES », « FORMATION », « STACK TECHNIQUE », « LANGUES ». Bon point ATS. Les mots-clés techniques sont majoritairement contextualisés via les projets (AIRH/FounderOS/Data Jobs) et l’alternance (PowerBI, Dataiku, RAG). Points perfectibles : 1) « STACK TECHNIQUE » est OK mais certains ATS attendent « COMPETENCES » (mineur). 2) Présence de sous-intitulés atypiques « de base », « Transformation », « BI » qui peuvent être moins bien parsés selon ATS (mieux en listes/catégories simples). 3) Des outils très nombreux (Langflow, Gumloop, N8n, Langfuse…) peuvent être perçus comme empilement si non reliés à une expérience/projet précis (à relier explicitement). 4) Les liens sont présents mais libellés (LinkedIn / AIRH / FounderOS) sans URL en clair dans le texte brut : certains ATS ne cliquent pas/extraient mal les ancres (préférer afficher l’URL en toutes lettres)."
+      },
+      "quantification_resultats": {
+        "score": 62,
+        "details": "Bon niveau pour un profil en reconversion/early-confirmé Data : plusieurs chiffres concrets existent (5 dashboards, 150 collaborateurs, 40 documents, 10 flows Dataiku, -30% d’étapes, 6 projets, +2000 offres, +40% pertinence, 7 agents, équipe jusqu’à 8, -20% pertes matière). En revanche, il manque des métriques techniques ‘2025’ attendues côté Data/IA/Produit : latence/temps de réponse, volumétrie (Go, lignes, requêtes/jour), coûts, performance des pipelines, qualité modèle (précision, recall), temps de déploiement, monitoring, couverture de tests, SLA. Sur Enedis et AIRH, les résultats restent partiellement orientés ‘activité’ plutôt que ‘impact’ (gain de temps, adoption, fiabilité, incidents évités).",
+        "metriques_suggerees": [
+          "Enedis/PowerBI : temps moyen de chargement des dashboards (ex. -40% vs avant), nombre de vues mensuelles, taux d’adoption (% des 150 utilisateurs actifs), réduction du temps de production de reporting (heures/sem).",
+          "Enedis/RAG : taux de réponses utiles (ex. % évalué), précision@k / recall@k, taux d’hallucination, temps moyen de réponse (ms/s), coût par requête (€, tokens), nombre de requêtes/semaine en test.",
+          "Enedis/Dataiku : volume de données traité par flow (Go/jour, nb de tables), durée d’exécution avant/après (ex. 45 min → 28 min), taux d’échec des jobs (incidents/mois), dette technique réduite (nb de recettes/variables standardisées).",
+          "AIRH : temps de parsing CV (ms), throughput (CV/min), coût d’inférence par entretien simulé, latence end-to-end multi-agents, taux de succès des runs (sans erreurs), nombre de candidats/recruteurs beta testeurs.",
+          "AIRH : métriques qualité scoring (corrélation avec décisions humaines, calibration, taux de faux positifs ‘fraude’), couverture de tests backend (%), temps de déploiement (CI/CD) et fréquence de release.",
+          "Data Jobs : NDCG@k / MRR (si déjà mesuré), taux de clic ou satisfaction utilisateur, temps de vectorisation (2k offres en X min), coût Pinecone (€/mois) et optimisation (index, dimension, batch).",
+          "FounderOS : performances web (LCP, TTFB), taille bundle, temps de build/deploy, nombre d’utilisateurs actifs, réduction du churn ou du temps de préparation (Lean Canvas, veille) via l’outil."
+        ]
+      },
+      "structure_lisibilite": {
+        "score": 78,
+        "details": "CV 1 page : conforme et très bon pour un profil en montée en compétence Data. Poste visé clairement indiqué dès l’en-tête (« Chef de Projet Data / IA ») : bon signal. Chronologie : expériences en ordre globalement inverse côté Data (2024-2025 puis 2009-2023) OK ; formations listées 2024-2025 puis 2024 OK. Point à améliorer : la section « LIENS » et « STACK TECHNIQUE » apparaissent aussi dans le texte brut au milieu des expériences (probable effet de mise en page/colonnes) : risque réel de parsing ATS et de lecture recruteur (les liens/skills semblent ‘couper’ l’expérience). Il faut sécuriser une structure linéaire : En-tête > Compétences > Expériences > Projets > Formation (ou Projets avant Expériences si objectif produit).",
+        "structuration_competences": "Compétences bien catégorisées (Langages/Frameworks, IA/ML, Analytics & Data Engineering, DevOps & Automatisation, Méthodologies). Recommandation : renommer « STACK TECHNIQUE » en « COMPETENCES TECHNIQUES » et éviter des micro-sous-blocs (« de base ») au profit de catégories ATS plus standards."
+      },
+      "presentation_projets": {
+        "score": 81,
+        "details": "Projets bien présentés : chaque projet a un nom, une stack, et des éléments concrets (AIRH : 7 agents, pipeline complet, scoring pondéré ; Data Jobs : +2000 offres, +40% pertinence ; FounderOS : modules identifiés). Très pertinent pour le poste visé (Data/IA + produit). À renforcer : ajouter systématiquement 1) le rôle exact (solo vs équipe), 2) l’état (MVP en prod ? beta ? utilisateurs ?), 3) des métriques d’exploitation (latence, coût, usage), 4) un lien direct par projet vers repo/démo (URL en clair) pour preuve immédiate. Sur AIRH, détailler les choix d’architecture (monolithe vs microservices, orchestrateur, storage, stratégie d’indexation vecteur, observabilité) et les compromis."
+      },
+      "preuves_competences": {
+        "score": 74,
+        "details": "Bon niveau de ‘preuves’ car beaucoup de compétences sont démontrées dans expériences/projets : PowerBI et Dataiku (Enedis), RAG/LangChain/Pinecone/Selenium (Data Jobs), React/FastAPI/PostgreSQL/MongoDB/MinIO/Metabase/Mage.ai (AIRH), Next.js/TypeScript/Tailwind/Gemini (FounderOS), Scrum Master mentionné (Data Jobs), management (pâtissier manager) utile pour Chef de Projet. Points faibles : plusieurs outils listés en compétences ne sont pas explicitement rattachés à un projet/expérience (risque de “skills shelf”). Aussi, AWS/Docker/Git/CI/CD sont cités mais sans exemple concret de pipeline, déploiement, registry, infra as code, etc.",
+        "skills_sans_preuve": [
+          "PySpark",
+          "DBT",
+          "AWS",
+          "Docker",
+          "CI/CD",
+          "BeautifulSoup4 (BS4)",
+          "N8n",
+          "Langflow",
+          "Gumloop",
+          "Langfuse",
+          "Design Thinking (usage mentionné mais sans livrables/atelier concret hors AIRH)",
+          "RGAA (mention conformité mais pas d’action vérifiable : audit, critères appliqués, corrections)"
+        ],
+        "liens_detectes": [
+          "https://www.linkedin.com/in/loumeau-quentin/",
+          "https://www.airh.online/",
+          "https://founderdashboard.vercel.app/"
+        ]
+      },
+      "red_flags": [
+        "Compétences listées sans preuve explicite dans expériences/projets : PySpark, DBT, AWS, Docker, CI/CD, BS4, N8n, Langflow, Gumloop, Langfuse, RGAA (à contextualiser ou retirer).",
+        "Risque de parsing/lecture : dans le texte brut, les sections LIENS/STACK TECHNIQUE semblent interrompre la section EXPÉRIENCE (probable mise en page en colonnes)."
+      ],
+      "points_forts": [
+        "Positionnement clair et différenciant (Chef de Projet Data/IA + multi-agents + recrutement tech).",
+        "Projets très pertinents et actuels (RAG, multi-agents, vector DB, scraping, full-stack).",
+        "Déjà plusieurs quantifications utiles (utilisateurs, volumes, gains, nombre de flows, +40% pertinence).",
+        "Valorisation cohérente de la reconversion avec compétences transférables (management, optimisation, international, animation d’ateliers).",
+        "Liens vers LinkedIn et projets live présents (preuve produit)."
+      ],
+      "conseils_prioritaires": [
+        "Sécuriser la lisibilité ATS : sortir d’une mise en page en colonnes et garantir un flux linéaire (les sections LIENS/COMPÉTENCES ne doivent pas apparaître au milieu de l’EXPERIENCE dans l’extraction texte). Si vous gardez les ancres, ajoutez aussi les URL en clair (ex. linkedin.com/in/… ; airh.online ; founderdashboard.vercel.app).",
+        "Ajouter 6–10 métriques techniques ‘signature’ sur Enedis + AIRH : temps d’exécution avant/après des flows Dataiku, volume de données, temps de réponse RAG, coût par requête, adoption (utilisateurs actifs), fiabilité (taux d’échec), et côté AIRH latence multi-agents + coût inference + taux de succès des runs.",
+        "Nettoyer la section compétences : soit retirer les outils non prouvés, soit ajouter une ligne de preuve par outil (ex. ‘DBT : modèle X, 12 tests, docs’, ‘Docker : image FastAPI, docker-compose’, ‘CI/CD : GitHub Actions avec lint+tests+deploy’). Objectif : zéro skill “hors contexte”.",
+        "Sur AIRH, expliciter 3–5 décisions d’architecture et leurs compromis (ex. choix Postgres vs Mongo, stockage MinIO, orchestration Mage.ai, stratégie d’indexation/search, observabilité/trace Langfuse) + ce que vous feriez différemment à l’échelle (10k CV/jour, multi-tenant, files/queues)."
+      ],
+      "adaptation_seniorite": "Profil ‘reconversion vers Data/IA’ avec expérience pro longue mais expérience tech récente (alternance 2024–2025 + projets). Attentes calibrées : comme un junior/confirmé côté Data/IA, les projets sont un atout majeur et sont bien exploités. Pour viser ‘Chef de Projet Data/IA’ (confirmé), il manque encore des marqueurs d’impact mesurable (SLA, gains de temps/coûts, adoption, qualité IA) et des preuves de delivery (déploiement, run, monitoring, CI/CD). La partie compétences transférables (management, optimisation, animation) est bien présente ; elle gagnerait à être reliée à des livrables tech/projet (roadmap, RACI, KPI, gestion des risques, conduite du changement sur les 150 utilisateurs)."
+    },
+    "analyse_projets": [
+      {
+        "titre": "AIRH - Plateforme SaaS de recrutement augmenté (système multi-agents)",
+        "resume": "SaaS / Projet live de recrutement augmenté : multi-agents (7) pour analyse CV + simulation d’entretien + pipeline data end-to-end.",
+        "evaluation": {
+          "pertinence": {
+            "score": 10,
+            "justification": "Cœur du poste visé: 'système multi-agents (7 agents)', 'recrutement augmenté', scoring candidats, et pipeline data (ingestion→monitoring)."
+          },
+          "complexite": {
+            "score": 8,
+            "justification": "Architecture multi-agents annoncée (CrewAI + LangGraph) + pipeline complet (parsing, stockage objet MinIO, PostgreSQL+MongoDB, orchestration Mage.ai). Pas de détails sur patterns de résilience, gestion d’état, évaluation offline/online."
+          },
+          "stack": {
+            "score": 8,
+            "justification": "Stack cohérente SaaS data/IA: React, FastAPI, PostgreSQL/MongoDB, MinIO, Metabase, Mage.ai, + frameworks agents. L’ensemble est moderne mais assez large (double DB relationnel/NoSQL + orchestration + observabilité) sans justification explicite."
+          },
+          "innovation": {
+            "score": 8,
+            "justification": "Au-delà d’un wrapper RAG: scoring multi-dimensionnel pondéré (40/30/20/10) + 'détection de fraude automatisée' + 'simulation d’entretien dynamique'. Innovation plausible, mais le CV ne décrit pas la méthode de fraude (règles, ML, signaux) ni l’évaluation."
+          },
+          "impact": {
+            "score": 5,
+            "justification": "Aucun KPI chiffré (temps de recrutement, qualité shortlist, taux de conversion, coûts/latence). Projet 'live' mentionné, mais sans métriques d’adoption/usage."
+          },
+          "ownership": {
+            "score": 10,
+            "justification": "Ownership explicitement end-to-end: 'Pilotage de A à Z : Design Thinking, business plan, développement full-stack, déploiement' + mémoire de fin d’études sur le sujet."
+          },
+          "maturite": {
+            "score": 6,
+            "justification": "Mention de monitoring qualité via Metabase + orchestration Mage.ai. En revanche: pas de preuve de tests, CI/CD, sécurité, RGPD, gestion des prompts/versions, observabilité LLM (traces, coûts), SLA/latence, ou scalabilité."
+          }
+        },
+        "points_forts": [
+          "Alignement parfait avec multi-agents + recrutement tech: 7 agents orchestrés et simulation d’entretien.",
+          "Vrai scope produit: full-stack + data pipeline + stockage objet + monitoring (Metabase) + orchestration (Mage.ai).",
+          "Ownership rare sur un projet IA: business plan + déploiement + projet live (donc contrainte produit réelle)."
+        ],
+        "points_vigilance": [
+          "Risque d’over-claim sur la 'détection de fraude' et la 'simulation dynamique' sans description de méthode ni métriques d’efficacité (FP/FN, protocoles d’évaluation).",
+          "Maturité production incomplète dans le CV: pas de mention de tests, CI/CD, sécurité, RGPD (données CV = sensibles), monitoring LLM (coût/latence), ni gestion des erreurs/timeout.",
+          "Complexité stack: PostgreSQL + MongoDB + MinIO + Mage + Metabase + CrewAI/LangGraph; il faut justifier les choix et la cohérence opérationnelle."
+        ],
+        "note_globale": 79,
+        "verdict_recruteur": "Projet le plus solide et le plus aligné: vraie construction agentique + pipeline data + produit SaaS. Techniquement crédible, mais je le considère 'production-lean': pour valider un niveau senior/CTO-like, il faut des preuves chiffrées (impact) et des éléments de qualité prod (sécurité/RGPD, tests, observabilité LLM, perf/coûts). À creuser en entretien."
+      },
+      {
+        "titre": "FounderOS - Dashboard tout-en-un pour fondateurs de startups",
+        "resume": "Side project / MVP produit: dashboard Next.js pour tâches founder (Lean Canvas, CRM lite, veille, finance, contenu) + module d’intelligence concurrentielle scoré.",
+        "evaluation": {
+          "pertinence": {
+            "score": 5,
+            "justification": "Pertinent côté produit/PM et un peu GenAI (API Gemini), mais moins aligné sur multi-agents/RAG/recrutement/pipelines."
+          },
+          "complexite": {
+            "score": 4,
+            "justification": "Le CV décrit des modules fonctionnels et un scoring concurrentiel, mais pas d’architecture IA (agents, RAG, ingestion), ni complexité backend/data. Semble surtout front + appels API."
+          },
+          "stack": {
+            "score": 7,
+            "justification": "Next.js + TypeScript + Tailwind = stack moderne et cohérente. 'API Gemini' intégrée, mais absence d’info sur backend, persistance, auth, ou pipeline données."
+          },
+          "innovation": {
+            "score": 6,
+            "justification": "Module d’intelligence concurrentielle avec 'Health Score', 'Radar 6 axes', SWOT intelligente: idée intéressante. Mais on ne voit pas ce qui est réellement automatisé (sources, ingestion, critères) vs simple prompting."
+          },
+          "impact": {
+            "score": 2,
+            "justification": "Aucun chiffre (utilisateurs, adoption, gain de temps, taux d’activation), pas de preuve de projet live."
+          },
+          "ownership": {
+            "score": 6,
+            "justification": "On suppose une réalisation personnelle (projet listé), mais contrairement à AIRH, pas de mention explicite de déploiement, pilotage A→Z, ou méthodes."
+          },
+          "maturite": {
+            "score": 3,
+            "justification": "Aucune mention de monitoring, tests, sécurité, contrôle coût/latence Gemini, ni gestion des données. Semble MVP/démo."
+          }
+        },
+        "points_forts": [
+          "Bonne culture produit: regrouper des besoins founders (canvas, CRM, veille, finance) dans un même outil.",
+          "Stack front moderne (Next.js/TS) et intégration GenAI (Gemini) utile pour des analyses structurées."
+        ],
+        "points_vigilance": [
+          "Projet peu probant pour évaluer la compétence 'multi-agents/RAG/pipeline' (pas décrit).",
+          "Innovation difficile à distinguer d’un 'prompt + UI' sans description de données, métriques, ou protocole d’évaluation.",
+          "Aucun signal de maturité production (auth, rôles, stockage, observabilité, coûts)."
+        ],
+        "note_globale": 47,
+        "verdict_recruteur": "Bon projet produit/UI, mais techniquement trop peu étayé côté data/IA pour le poste visé. Je le vois comme un bonus (sens produit), pas comme une preuve de maîtrise agentique ou pipeline. À ne pas sur-vendre."
+      },
+      {
+        "titre": "Data Jobs - Moteur de recommandation d'emploi RAG",
+        "resume": "Projet IA / prototype RAG: scraping d’offres, vectorisation Pinecone, recommandation via LangChain + Groq, amélioration de pertinence annoncée.",
+        "evaluation": {
+          "pertinence": {
+            "score": 8,
+            "justification": "RAG + pipeline (scraping→vectorisation) appliqué à l’emploi tech (proche recrutement). Moins multi-agents mais très aligné GenAI/pipelines."
+          },
+          "complexite": {
+            "score": 6,
+            "justification": "Scraping Selenium + vector store Pinecone + LangChain + LLM Groq = pipeline RAG classique. Pas de mention d’ingestion robuste (dédup, scheduling), évaluation IR (precision@k), ni serving/monitoring."
+          },
+          "stack": {
+            "score": 7,
+            "justification": "Python + LangChain + Pinecone + Selenium + Groq: stack standard RAG. Cohérente, mais dépendante de services externes; pas d’info sur persistance, API, ou déploiement."
+          },
+          "innovation": {
+            "score": 5,
+            "justification": "Amélioration via 'Prompt Engineering itératif' = approche courante. Pas de signal d’innovation type reranking, hybrid search, feedback loop, ou évaluation systématique."
+          },
+          "impact": {
+            "score": 6,
+            "justification": "+2 000 offres scrapées et '+40% pertinence' annoncés. Mais la mesure n’est pas définie (metric, baseline, protocole, dataset de test), donc crédibilité partielle."
+          },
+          "ownership": {
+            "score": 7,
+            "justification": "Réalisation technique décrite + 'pilotage des sprints en tant que Scrum Master'. Ownership delivery/orga visible, mais pas explicitement end-to-end produit (déploiement, users)."
+          },
+          "maturite": {
+            "score": 4,
+            "justification": "Pas de mention de monitoring, tests, gestion anti-bot/robustesse scraping, conformité (TOS scraping), ni optimisation coût/latence. On est sur un prototype solide."
+          }
+        },
+        "points_forts": [
+          "Bon cas d’usage RAG appliqué au recrutement: ingestion (scraping) + indexation (Pinecone) + recommandation.",
+          "Chiffres minimaux présents (+2 000 offres, +40% pertinence), ce qui est rare dans un CV.",
+          "Dimension delivery: rôle Scrum Master mentionné (capacité à structurer l’exécution)."
+        ],
+        "points_vigilance": [
+          "Le '+40% pertinence' est invérifiable sans métrique (NDCG@k, precision@k, taux de clic) ni protocole d’évaluation; à challenger en entretien.",
+          "RAG très 'standard LangChain + vector DB' sans éléments avancés (reranker, hybrid search, chunking strategy, eval harness, feedback loop).",
+          "Maturité et conformité: scraping Selenium sans mention de robustesse, légal/TOS, ni industrialisation (scheduler, retries, monitoring)."
+        ],
+        "note_globale": 61,
+        "verdict_recruteur": "Bon projet RAG pragmatique et utile, mais techniquement assez standard. Je le valorise comme preuve de compréhension des briques RAG et d’un mini-pipeline, pas comme démonstration d’architecture avancée. Si le candidat peut expliquer clairement la métrique du '+40%' et une stratégie d’industrialisation, la note remonte nettement."
+      }
+    ],
+    "coherence_globale_projets": {},
+    "conseils_amelioration": [
+      "Sécuriser la lisibilité ATS : sortir d’une mise en page en colonnes et garantir un flux linéaire (les sections LIENS/COMPÉTENCES ne doivent pas apparaître au milieu de l’EXPERIENCE dans l’extraction texte). Si vous gardez les ancres, ajoutez aussi les URL en clair (ex. linkedin.com/in/… ; airh.online ; founderdashboard.vercel.app).",
+      "Ajouter 6–10 métriques techniques ‘signature’ sur Enedis + AIRH : temps d’exécution avant/après des flows Dataiku, volume de données, temps de réponse RAG, coût par requête, adoption (utilisateurs actifs), fiabilité (taux d’échec), et côté AIRH latence multi-agents + coût inference + taux de succès des runs.",
+      "Nettoyer la section compétences : soit retirer les outils non prouvés, soit ajouter une ligne de preuve par outil (ex. ‘DBT : modèle X, 12 tests, docs’, ‘Docker : image FastAPI, docker-compose’, ‘CI/CD : GitHub Actions avec lint+tests+deploy’). Objectif : zéro skill “hors contexte”.",
+      "Sur AIRH, expliciter 3–5 décisions d’architecture et leurs compromis (ex. choix Postgres vs Mongo, stockage MinIO, orchestration Mage.ai, stratégie d’indexation/search, observabilité/trace Langfuse) + ce que vous feriez différemment à l’échelle (10k CV/jour, multi-tenant, files/queues)."
+    ]
+  }
+}