update

src/config/tasks.yaml

@@ -334,65 +334,49 @@ cv_quality_task:
 
 project_analysis_task:
   description: >
-    Évalue CHAQUE projet du CV, fournis une critique objective et complète,
-    et recommande quels projets mettre en avant pour le poste visé.
+    É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}
 
-    EXPÉRIENCES DU CANDIDAT : {experiences_summary}
-
     PROJETS PROFESSIONNELS : {professional_projects}
     PROJETS PERSONNELS : {personal_projects}
 
     RECONVERSION : {reconversion_data}
 
-    Pour CHAQUE projet, analyse EN PROFONDEUR :
-    1. COHÉRENCE AVEC LE POSTE VISÉ : Le domaine et les technos sont-ils pertinents ?
-       Compare avec les compétences et outils du référentiel métier ci-dessus.
-    2. QUALITÉ DE DESCRIPTION : Est-ce bien décrit ? Y a-t-il des résultats MESURABLES
-       et des métriques techniques spécifiques (performance, volume, impact) ?
-    3. COMPLEXITÉ TECHNIQUE : Trivial vs ambitieux. Évalue l'architecture, les choix techniques.
-    4. IMPACT DÉMONTRÉ : Métriques, utilisateurs, déploiement en production ?
-    5. TECHNOLOGIES : Actuelles et recherchées pour le poste visé ?
-
-    RECOMMANDATION DE MISE EN AVANT :
-    - Classe les projets par ORDRE DE PRIORITÉ pour le poste visé.
-    - Pour chaque projet, explique POURQUOI il devrait être mis en avant (ou pas) pour ce poste.
-    - Donne des conseils CONCRETS pour améliorer la description de chaque projet
-      (quelles métriques ajouter, quels aspects techniques détailler, quels résultats valoriser).
+    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 :
-    - Score de cohérence de 0 à 100 pour chaque projet.
-    - Si un projet semble artificiel ou trop vague, signale-le.
-    - Les projets doivent raconter une histoire cohérente avec le profil global.
+    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).
   expected_output: >
     JSON : {{
       "analyse_projets": [
         {{
           "titre": "Dashboard RH",
-          "type": "professional",
-          "score_coherence": 90,
-          "points_forts": ["Technologies pertinentes", "Impact mesurable"],
-          "points_amelioration": ["Ajouter des métriques de performance spécifiques"],
-          "coherence_avec_poste_vise": "Très cohérent - projet BI directement lié au poste",
-          "technologies_pertinentes": true,
-          "complexite": "moyenne",
-          "conseils_description": ["Préciser le volume de données", "Ajouter le temps de génération"]
-        }}
-      ],
-      "ordre_mise_en_avant": [
-        {{
-          "titre": "Projet X",
           "rang": 1,
-          "raison": "Ce projet démontre directement les compétences clés du poste visé..."
+          "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"]
         }}
       ],
       "coherence_globale": {{
         "score": 85,
-        "commentaire": "Les projets racontent une histoire cohérente..."
+        "commentaire": "Ensemble de projets cohérent avec le poste visé"
       }}
     }}
 

src/parser_flow/CV_agent_flow.py

@@ -1,10 +1,12 @@
 """
 Orchestrateur CV enrichi avec 3 phases :
-  Phase 1 : Découpage du CV en sections
-  Phase 2 : Extraction parallèle (8 agents existants)
-  Phase 3 : Analyse & Recommandation parallèle (5 nouveaux agents)
+  Phase 1  : Découpage du CV en sections (cv_splitter)
+  Phase 2  : Extraction parallèle (8 agents)
+  Phase 3a : Analyse d'en-tête (run_header_analysis) — tourne en // avec Phase 2
+  Phase 3b : Analyse & Recommandation — 3 agents en parallèle après Phase 2 + 3a
 
-Produit un JSON en 2 parties : informations + recommandations.
+Flux optimisé : Phase 1 → (Phase 2 // Phase 3a) → Phase 3b
+Produit un JSON en 2 parties : candidat + recommandations.
 """
 
 import json
@@ -246,7 +248,66 @@ class CVAgentOrchestrator:
         return self._aggregate_extraction_results(results_map)
 
     # ──────────────────────────────────────────────
-    # PHASE 3 : Analyse & Recommandation (5 agents)
+    # 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(
@@ -255,12 +316,15 @@ class CVAgentOrchestrator:
         sections: Dict[str, str],
         extraction: Dict[str, Any],
         cv_raw_start: str = "",
+        header_data: Dict = None,
     ) -> Dict[str, Any]:
-        """Exécute les 4 tâches d'analyse en 2 étapes optimisées.
+        """Exécute les 3 tâches d'analyse en parallèle.
 
-        Étape 3a : header_analyzer seul (rapide, nécessaire pour tous les autres)
-        Étape 3b : 3 agents en parallèle (quality, metier, project)
+        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", {})
@@ -269,11 +333,9 @@ class CVAgentOrchestrator:
         skills_with_context = competences.get("skills_with_context", [])
         reconversion = candidat.get("reconversion", {})
 
-        # Identifier les domaines de compétences et méthodologies
         skill_domains = self._map_skills_to_domains(hard_skills)
         methodologies = self._extract_methodologies(hard_skills, skill_domains)
 
-        # Préparer les résumés pour les prompts
         experiences_summary = json.dumps(
             candidat.get("expériences", []), ensure_ascii=False
         )[:3000]
@@ -285,14 +347,16 @@ class CVAgentOrchestrator:
             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 "{}"
 
-        # Préparer le référentiel métiers complet (30 métiers)
         metiers_reference = self._prepare_metiers_for_prompt()
 
-        # Skills résumé pour header analysis (fallback)
-        skills_summary = ", ".join(hard_skills[:20]) if hard_skills else "Non identifiées"
+        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()
@@ -301,71 +365,15 @@ class CVAgentOrchestrator:
             c = Crew(agents=[agent], tasks=[task], verbose=False)
             return (task_key, c.kickoff_async())
 
-        # Utilise le texte brut fitz si fourni, sinon fallback sur le début du Markdown
-        raw_for_header = cv_raw_start[:2000] if cv_raw_start else cv_full_text[:2000]
-        header_section = sections.get("header", "")
-        safe_cv_raw = raw_for_header.replace("{", "{{").replace("}", "}}")
-        safe_header = header_section.replace("{", "{{").replace("}", "}}")
-        safe_skills = skills_summary.replace("{", "{{").replace("}", "}}")
-        header_data = {
-            "poste_vise": "Non identifié",
-            "niveau_seniorite": "non précisé",
-            "confiance": 0,
-        }
-
-        try:
-            header_coroutine = create_task_async(
-                "poste_visé_task",
-                self.header_analyzer,
-                cv_raw_start=safe_cv_raw,
-                header=safe_header,
-                skills_summary=safe_skills,
-            )
-            header_result = await header_coroutine[1]
-
-            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 result: poste_vise='{header_data.get('poste_vise')}', confiance={header_data.get('confiance')}")
-        except Exception as e:
-            logger.error(f"Header analyzer failed: {e}", exc_info=True)
-
-        poste_vise = header_data.get("poste_vise", "Non identifié")
-        niveau_seniorite = header_data.get("niveau_seniorite", "non précisé")
-
-        # --- Fallback programmatique si le LLM n'a pas trouvé le poste ---
-        if poste_vise == "Non identifié":
-            logger.warning("Header analyzer returned 'Non identifié', trying fallback extraction...")
-            fallback = self._fallback_extract_poste_vise(
-                cv_full_text, header_section
-            )
-            if fallback:
-                poste_vise = fallback
-                header_data["poste_vise"] = fallback
-                header_data["source_detection"] = "fallback_programmatique"
-                header_data["confiance"] = 70
-                logger.info(f"Fallback found poste_vise: '{fallback}'")
-
-        # Préparer le détail du métier pour le project_analyzer
-        metier_reference_detail = self._get_metier_reference_for_poste(poste_vise)
-
-        # --- Étape 3b : 3 agents en parallèle ---
+        # 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[:8000],
+                    "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],
+                    "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,
@@ -393,7 +401,6 @@ class CVAgentOrchestrator:
                 {
                     "poste_vise": poste_vise,
                     "metier_reference_detail": metier_reference_detail,
-                    "experiences_summary": experiences_summary,
                     "professional_projects": professional_projects,
                     "personal_projects": personal_projects,
                     "reconversion_data": reconversion_data,
@@ -415,11 +422,34 @@ class CVAgentOrchestrator:
             else:
                 analysis_results[key] = result
 
-        return self._aggregate_recommendations(
-            analysis_results,
-            header_data,
-            poste_vise,
-        )
+        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
@@ -611,9 +641,8 @@ class CVAgentOrchestrator:
         self,
         analysis_results: Dict[str, Any],
         header_data: Dict,
-        poste_vise: str,
     ) -> Dict[str, Any]:
-        """Agrège les résultats d'analyse avec des recommandations orientées projets."""
+        """Agrège les résultats d'analyse en un objet recommandations structuré."""
 
         def get_parsed(key, default=None):
             if key not in analysis_results:
@@ -627,22 +656,11 @@ class CVAgentOrchestrator:
         )
         project_data = get_parsed("project_analysis_task", {"analyse_projets": []})
 
-        # ── Conseils d'amélioration ────────────────────────────────────────────
+        # Conseils d'amélioration : uniquement les conseils qualité CV
         conseils = []
-
-        # 1. Conseils qualité CV
         if isinstance(quality_data, dict):
             conseils.extend(quality_data.get("conseils_prioritaires", []))
 
-        # 2. Projets à mettre en avant
-        if isinstance(project_data, dict):
-            for item in (project_data.get("ordre_mise_en_avant", []) or [])[:3]:
-                if isinstance(item, dict) and item.get("raison"):
-                    conseils.append(
-                        f"Projet prioritaire #{item.get('rang', '?')} à mettre en avant"
-                        f" - '{item.get('titre', '?')}' : {item['raison']}"
-                    )
-
         return {
             "header_analysis": header_data,
             "postes_recommandes": (
@@ -661,11 +679,6 @@ class CVAgentOrchestrator:
                 if isinstance(project_data, dict)
                 else []
             ),
-            "ordre_mise_en_avant_projets": (
-                project_data.get("ordre_mise_en_avant", [])
-                if isinstance(project_data, dict)
-                else []
-            ),
             "coherence_globale_projets": (
                 project_data.get("coherence_globale", {})
                 if isinstance(project_data, dict)
@@ -824,14 +837,9 @@ class CVAgentOrchestrator:
                         pass
             return None
 
-        # Tentative 1 : parse du texte tel quel (gère "JSON : {...}" et JSON propre)
         result = _try_parse(raw)
         if result is not None:
             return result
-
-        # Tentative 2 : le LLM a copié les {{ }} du expected_output YAML.
-        # ⚠️ On ne remplace QUE si {{ est détecté — évite de casser un JSON
-        # compact valide du type {"inner": {"key": "val"}} → {"inner": {"key": "val"}
         if "{{" in raw:
             cleaned = raw.replace("{{", "{").replace("}}", "}")
             result = _try_parse(cleaned)

src/services/cv_service.py

@@ -1,11 +1,16 @@
 """
 Service de parsing et analyse de CV enrichi.
-Pipeline en 3 phases :
-  1. Découpage en sections (avec extraction brute pour le header)
-  2. Extraction parallèle (compétences, expériences, projets, etc.)
-  3. Analyse et recommandation (poste visé, matching métiers, qualité CV, projets)
+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)
+
+Flux : Phase 1 → asyncio.gather(Phase 2, Phase 3a) → Phase 3b
+Gain estimé : ~5-8 secondes vs pipeline séquentiel précédent.
 """
 
+import asyncio
 import logging
 from typing import Dict, Any
 
@@ -25,39 +30,50 @@ async def parse_cv(pdf_path: str, file_name: str = "") -> Dict[str, Any]:
     """
     orchestrator = CVAgentOrchestrator()
 
-    # Double extraction :
-    # - cv_text : Markdown (bon pour la structure des sections)
+    # 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)
 
+    # ── 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)
 
-    logger.info("Phase 2 : Extraction parallèle des données...")
-    extraction = await orchestrator.extract_all_sections(
-        sections, cv_raw_start=cv_raw_start, file_name=file_name
+    # ── 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
+        ),
     )
 
-    logger.info("Phase 3 : Analyse et recommandation...")
+    # ── 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,
         cv_raw_start=cv_raw_start,
+        header_data=header_data,
     )
 
     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", {}),
+        "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", {}),
     }