Spaces:

QuentinL52
/

cv_parser

Running

App Files Files Community

quentinL52 commited on 11 days ago

Commit

f88b8e8

1 Parent(s): a2e2b2d

update

Browse files

Files changed (7) hide show

src/config/agents.yaml +92 -5
src/config/app_config.py +38 -14
src/config/skill_domain_map.json +393 -0
src/config/tasks.yaml +279 -26
src/data/metiers.json +1273 -0
src/parser_flow/CV_agent_flow.py +716 -106
src/services/cv_service.py +61 -5

src/config/agents.yaml CHANGED Viewed

@@ -1,3 +1,5 @@
 cv_splitter:
   role: >
     Expert en Structure Documentaire
@@ -6,8 +8,7 @@ cv_splitter:
   backstory: >
     Tu es un algorithme de parsing de haute précision capable de structurer n'importe quel document non structuré en format JSON clair.
     Ta priorité est la fidélité de l'extraction et la séparation propre des sections.
-  verbose: false
 skills_extractor:
   role: >
@@ -75,9 +76,95 @@ language_extractor:
 identity_extractor:
   role: >
-    Extracteur d'identité
   goal: >
-    Extraire les informations d'identité du candidat
   backstory: >
-    Expert en identification de personnes.
   verbose: false

+# ===== AGENTS EXISTANTS (copie de cv_parser_api) =====
 cv_splitter:
   role: >
     Expert en Structure Documentaire
   backstory: >
     Tu es un algorithme de parsing de haute précision capable de structurer n'importe quel document non structuré en format JSON clair.
     Ta priorité est la fidélité de l'extraction et la séparation propre des sections.
+  verbose: true
 skills_extractor:
   role: >
 identity_extractor:
   role: >
+    Expert en Extraction d'Identité et Analyse Nominale
+  goal: >
+    Extraire l'identité complète du candidat (Nom, Prénom) de manière ultra-robuste.
+  backstory: >
+    Expert en identification de personnes, capable de repérer un nom même s'il est placé
+    de manière inhabituelle ou s'il n'est mentionné qu'au tout début du document.
+    Tu sais utiliser le nom du fichier comme un "indice" précieux pour confirmer
+    ou découvrir l'identité si le texte du CV est ambigu ou incomplet.
+    Ta priorité est d'extraire le NOM et le PRÉNOM séparément et ensemble (Nom Complet).
+  verbose: false
+# ===== Analyse =====
+header_analyzer:
+  role: >
+    Analyste d'En-tête de CV
+  goal: >
+    Extraire le poste visé tel qu'il est écrit dans l'en-tête du CV (titre ou sous-titre juste après le nom du candidat).
+  backstory: >
+    Tu es un recruteur senior spécialisé dans l'analyse de CV tech/data/IA.
+    Ta mission PRINCIPALE est d'extraire le titre de poste EXACT tel qu'il apparaît dans l'en-tête du CV.
+    Le poste visé se trouve TOUJOURS dans le HEADER
+    (ex: "Data Analyst", "Chef de Projet IA", "Développeur Full-Stack - Spécialiste React").
+    Tu dois recopier ce titre FIDÈLEMENT, sans le simplifier, le reformuler, ni l'interpréter.
+  verbose: true
+metier_matcher:
+  role: >
+    Conseiller en Orientation Professionnelle Data/IA
+  goal: >
+    Comparer le profil complet du candidat (compétences, projets, expériences, méthodologies)
+    avec le référentiel de métiers et recommander les 3 postes les mieux adaptés.
+  backstory: >
+    Tu es un expert en orientation professionnelle spécialisé dans les métiers de la data et de l'IA.
+    Tu connais parfaitement les fiches métiers du référentiel et tu sais évaluer objectivement
+    l'adéquation entre un profil et un poste. Tu comprends les liens implicites entre compétences
+    (ex: Metabase est un outil BI, LangChain est lié au LLM engineering).
+    Tu évalues la couverture des compétences techniques, des outils, de l'expérience requise,
+    ET des méthodologies de travail (Agile, Scrum, DevOps, CI/CD, TDD, Design Thinking).
+    Les méthodologies sont devenues un critère de sélection majeur dans le recrutement tech.
+    Pour les profils en reconversion, tu valorises les compétences transférables
+    (gestion d'équipe, planification, optimisation de processus, communication internationale).
+    Ton analyse est factuelle et basée sur des preuves concrètes du CV.
+  verbose: false
+cv_quality_checker:
+  role: >
+    Auditeur de Qualité CV Tech
   goal: >
+    Évaluer objectivement la qualité du CV selon les meilleures pratiques tech 2025,
+    en adaptant les critères au niveau de séniorité du candidat.
   backstory: >
+    Tu es un consultant RH expert en recrutement tech et data.
+    Tu ADAPTES tes critères au NIVEAU DE SÉNIORITÉ du candidat :
+    - Junior : focus sur les projets, formations, stages/alternances bien décrits
+    - Confirmé : focus sur l'impact mesurable, la progression, les responsabilités croissantes
+    - Senior/Staff : focus sur les choix architecturaux et leurs compromis (systèmes distribués,
+      microservices), le leadership technique (mentoring, revues de code, décisions structurelles),
+      la gestion de la scalabilité
+    Tu exiges des MÉTRIQUES TECHNIQUES SPÉCIFIQUES : réduction de latence, amélioration du temps
+    de chargement, optimisation de requêtes, volume d'utilisateurs supporté, réduction du temps
+    de déploiement CI/CD, couverture de tests.
+    Tu vérifies que les compétences sont STRUCTURÉES par catégories (Langages, Frameworks, BDD,
+    DevOps/Cloud) et non en liste plate.
+    Tu vérifies que chaque compétence listée est RÉELLEMENT démontrée dans les expériences/projets.
+    Pour les RECONVERSIONS : tu vérifies la mise en valeur des compétences transférables
+    (management, optimisation, communication) et leur lien explicite avec le nouveau domaine.
   verbose: false
+project_analyzer:
+  role: >
+    Analyste de Projets Techniques & Conseiller en Mise en Avant
+  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é.
+  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.
+  verbose: false

src/config/app_config.py CHANGED Viewed

@@ -1,31 +1,62 @@
 import os
 from dotenv import load_dotenv
 load_dotenv()
 import pymupdf4llm
 from langchain_groq import ChatGroq
 from langchain_openai import ChatOpenAI
 import litellm
 litellm.set_verbose = False
-def load_pdf(pdf_path):
-    md_text = pymupdf4llm.to_markdown(pdf_path)
-    return md_text
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 def get_big_llm():
-    """GPT-4o pour les tâches complexes."""
     return ChatOpenAI(
         model="gpt-4o",
         temperature=0.0,
         api_key=OPENAI_API_KEY
     )
 def get_small_llm():
-    """GPT-4o-mini pour l'extraction."""
     return ChatOpenAI(
         model="gpt-4o-mini",
         temperature=0.0,
@@ -33,19 +64,12 @@ def get_small_llm():
         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
     )
-def get_openai_small_llm():
-    """GPT-4o-mini - Fallback."""
-    return ChatOpenAI(
-        model="gpt-4o-mini",
-        temperature=0.0,
-        api_key=OPENAI_API_KEY
-    )

+"""
+Configuration des LLMs et utilitaires de chargement.
+"""
 import os
 from dotenv import load_dotenv
 load_dotenv()
+import fitz
 import pymupdf4llm
 from langchain_groq import ChatGroq
 from langchain_openai import ChatOpenAI
 import litellm
 litellm.set_verbose = False
+def load_pdf(pdf_path: str) -> str:
+    """Convertit un PDF en texte Markdown via pymupdf4llm (structure + formatage)."""
+    return pymupdf4llm.to_markdown(pdf_path)
+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).
+    Utilise fitz directement pour capturer les headers/sidebars que pymupdf4llm
+    peut ignorer ou réordonner sur les CV à mise en page complexe (bannières colorées,
+    colonnes, boîtes décoratives).
+    """
+    doc = fitz.open(pdf_path)
+    if not doc:
+        return ""
+    page = doc[0]
+    # Récupère les blocs texte avec leurs coordonnées
+    blocks = page.get_text("blocks")  # (x0, y0, x1, y1, text, block_no, block_type)
+    # Filtre les blocs texte (type 0) non vides
+    text_blocks = [b for b in blocks if b[6] == 0 and b[4].strip()]
+    # Trie par ligne (y arrondi à 10px pour gérer l'alignement imparfait), puis par colonne (x)
+    text_blocks.sort(key=lambda b: (round(b[1] / 10) * 10, b[0]))
+    doc.close()
+    return "\n".join(b[4].strip() for b in text_blocks)
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 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",
         temperature=0.0,
+        max_tokens=16384,
         api_key=OPENAI_API_KEY
     )
 def get_small_llm():
+    """GPT-4o-mini pour l'extraction rapide."""
     return ChatOpenAI(
         model="gpt-4o-mini",
         temperature=0.0,
         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/skill_domain_map.json ADDED Viewed

	@@ -0,0 +1,393 @@

+{
+    "bi_reporting": [
+        "metabase",
+        "power bi",
+        "powerbi",
+        "tableau",
+        "looker",
+        "qlik",
+        "qlikview",
+        "qliksense",
+        "dax",
+        "mdx",
+        "olap",
+        "ssas",
+        "ssrs",
+        "ssis",
+        "crystal reports",
+        "microstrategy",
+        "data studio",
+        "google data studio",
+        "superset",
+        "redash",
+        "grafana",
+        "kibana",
+        "thoughtspot",
+        "domo",
+        "sap analytics cloud"
+    ],
+    "data_engineering_platforms": [
+        "airflow",
+        "dbt",
+        "spark",
+        "pyspark",
+        "kafka",
+        "fivetran",
+        "talend",
+        "nifi",
+        "luigi",
+        "dagster",
+        "prefect",
+        "mage",
+        "databricks",
+        "stitch",
+        "matillion",
+        "informatica",
+        "pentaho",
+        "etl",
+        "elt",
+        "data pipeline",
+        "airbyte",
+        "meltano",
+        "glue",
+        "aws glue",
+        "emr",
+        "athena",
+        "synapse",
+        "azure data factory",
+        "adf"
+    ],
+    "data_science_analysis": [
+        "excel",
+        "google sheets",
+        "pandas",
+        "numpy",
+        "matplotlib",
+        "seaborn",
+        "plotly",
+        "jupyter",
+        "notebook",
+        "sql",
+        "statistiques",
+        "statistics",
+        "r",
+        "stata",
+        "spss",
+        "sas",
+        "scipy",
+        "statsmodels",
+        "polars",
+        "dask",
+        "streamit",
+        "bokeh",
+        "altair"
+    ],
+    "machine_learning_classic": [
+        "scikit-learn",
+        "sklearn",
+        "xgboost",
+        "lightgbm",
+        "catboost",
+        "mlflow",
+        "optuna",
+        "hyperopt",
+        "feature engineering",
+        "random forest",
+        "regression",
+        "classification",
+        "clustering",
+        "ml",
+        "machine learning",
+        "pca",
+        "svm",
+        "knn",
+        "ensemble learning",
+        "gradient boosting",
+        "time series",
+        "prophet",
+        "arima"
+    ],
+    "deep_learning_frameworks": [
+        "tensorflow",
+        "pytorch",
+        "keras",
+        "jax",
+        "mxnet",
+        "fastai",
+        "onnx",
+        "tensorrt",
+        "cuda",
+        "cudnn",
+        "torchvision",
+        "torchaudio"
+    ],
+    "nlp_llm_models": [
+        "transformers",
+        "huggingface",
+        "bert",
+        "gpt",
+        "gpt-3",
+        "gpt-4",
+        "gpt-4o",
+        "claude",
+        "llama",
+        "llama2",
+        "llama3",
+        "mistral",
+        "mixtral",
+        "gemini",
+        "palm",
+        "bert",
+        "roberta",
+        "t5",
+        "whisper",
+        "stable diffusion",
+        "midjourney",
+        "nlp",
+        "natural language processing",
+        "tokenization",
+        "embeddings",
+        "fine-tuning",
+        "lora",
+        "qlora",
+        "quantization"
+    ],
+    "ai_orchestration_agents": [
+        "langchain",
+        "langgraph",
+        "crewai",
+        "autogen",
+        "haystack",
+        "llama-index",
+        "llamaindex",
+        "agents",
+        "autonomous agents",
+        "tool use",
+        "function calling",
+        "prompt engineering",
+        "rag",
+        "retrieval augmented generation",
+        "semantic search",
+        "agentic workflows"
+    ],
+    "vector_databases": [
+        "pinecone",
+        "chromadb",
+        "weaviate",
+        "milvus",
+        "faiss",
+        "qdrant",
+        "elasticsearch",
+        "opensearch",
+        "pgvector",
+        "supabase vector",
+        "redis stack",
+        "lancedb",
+        "marqo"
+    ],
+    "cloud_ai_platforms": [
+        "openai",
+        "anthropic",
+        "google cloud vertex ai",
+        "vertex ai",
+        "aws bedrock",
+        "bedrock",
+        "azure openai",
+        "sagemaker",
+        "aws sagemaker",
+        "replicate",
+        "together ai",
+        "groq",
+        "perplexity"
+    ],
+    "backend_frameworks": [
+        "fastapi",
+        "django",
+        "flask",
+        "express",
+        "nestjs",
+        "spring",
+        "spring boot",
+        "node.js",
+        "nodejs",
+        "ruby on rails",
+        "laravel",
+        "symfony",
+        "go",
+        "golang",
+        "gin",
+        "fiber",
+        "elixir",
+        "phoenix",
+        "api rest",
+        "graphql",
+        "grpc",
+        "microservices",
+        "serverless"
+    ],
+    "frontend_web": [
+        "react",
+        "reactjs",
+        "vue",
+        "vuejs",
+        "angular",
+        "nextjs",
+        "next.js",
+        "nuxt",
+        "svelte",
+        "typescript",
+        "javascript",
+        "html",
+        "css",
+        "tailwind",
+        "tailwind css",
+        "bootstrap",
+        "sass",
+        "webpack",
+        "vite",
+        "three.js",
+        "d3.js",
+        "redux",
+        "zustand",
+        "react-query",
+        "tanstack"
+    ],
+    "mobile_development": [
+        "react native",
+        "flutter",
+        "swift",
+        "swiftui",
+        "kotlin",
+        "jetpack compose",
+        "ios",
+        "android",
+        "expo",
+        "capacitor",
+        "ionic",
+        "pwa"
+    ],
+    "devops_infrastructure": [
+        "docker",
+        "kubernetes",
+        "k8s",
+        "terraform",
+        "ansible",
+        "pulumi",
+        "chef",
+        "puppet",
+        "cloudformation",
+        "helm",
+        "nginx",
+        "traefik",
+        "envoy",
+        "istio",
+        "server management",
+        "linux",
+        "bash",
+        "powershell"
+    ],
+    "ci_cd_pipelines": [
+        "jenkins",
+        "github actions",
+        "gitlab ci",
+        "circleci",
+        "travis ci",
+        "argocd",
+        "fluxcd",
+        "ci/cd",
+        "cicd",
+        "automation",
+        "deployment"
+    ],
+    "cloud_providers": [
+        "aws",
+        "amazon web services",
+        "azure",
+        "microsoft azure",
+        "gcp",
+        "google cloud",
+        "google cloud platform",
+        "firebase",
+        "vercel",
+        "heroku",
+        "railway",
+        "digitalocean",
+        "cloudinary",
+        "supabase",
+        "lambda",
+        "s3",
+        "ec2",
+        "vpc"
+    ],
+    "database_systems": [
+        "postgresql",
+        "postgres",
+        "mysql",
+        "mariadb",
+        "mongodb",
+        "redis",
+        "memcached",
+        "cassandra",
+        "dynamodb",
+        "neo4j",
+        "firestore",
+        "bigquery",
+        "snowflake",
+        "redshift",
+        "clickhouse",
+        "sqlite",
+        "oracle",
+        "sql server",
+        "db2"
+    ],
+    "cybersecurity": [
+        "owasp",
+        "sast",
+        "dast",
+        "pentest",
+        "penetration testing",
+        "cybersecurity",
+        "security audit",
+        "cryptographie",
+        "cryptography",
+        "oauth",
+        "oauth2",
+        "jwt",
+        "ssl",
+        "tls",
+        "iam",
+        "sso",
+        "ldap",
+        "keycloak",
+        "waf",
+        "siem",
+        "soc"
+    ],
+    "project_management_agile": [
+        "agile",
+        "scrum",
+        "kanban",
+        "jira",
+        "confluence",
+        "notion",
+        "trello",
+        "monday",
+        "linear",
+        "asana",
+        "slack",
+        "product manager",
+        "product owner",
+        "scrum master",
+        "lean management",
+        "design thinking",
+        "figma",
+        "miro"
+    ],
+    "automatisation": [
+        "n8n",
+        "gumloop",
+        "make",
+        "zapier",
+        "power automate"
+    ]
+}

src/config/tasks.yaml CHANGED Viewed

@@ -1,30 +1,34 @@
 split_cv_task:
   description: >
-    ANALYSE EXTRÊMEMENT RAPIDE REQUISE.
-    Ton objectif unique est de découper le texte brut du CV en blocs JSON.
-    Ne résume pas. Ne reformule pas. Copie-colle le texte brut dans les sections correspondantes.
-    TEXTE DU CV :
     "{cv_content}"
     RÈGLES STRICTES :
-    1. "experiences": Contient UNIQUEMENT les blocs parlant d'historique professionnel (Entreprise, Poste, Dates).
-    2. "projects": Contient UNIQUEMENT les sections explicitement titrées "Projets" ou les descriptions de projets académiques/personnels distincts. SI PAS DE SECTION PROJET, LAISSER VIDE. Ne pas inventer.
-    3. "skills": Contient les listes de compétences, langages, outils.
-    4. "education": Contient les diplômes et formations.
-    5. "languages": Contient les langues mentionnées (Français, Anglais, etc.) avec éventuellement leur niveau.
-    6. "personal_info": Contient les informations personnelles (Prénom).
   expected_output: >
     Un objet JSON valide strictement structuré ainsi :
     {{
       "experiences": "texte brut...",
       "projects": "texte brut...",
       "education": "texte brut...",
       "skills": "texte brut...",
-      "languages": "texte brut...",
-      "personal_info": "texte brut..."
     }}
 skills_task:
   description: >
@@ -123,23 +127,272 @@ etudiant_task:
 language_task:
   description: >
-    Analyse le texte suivant pour identifier les langues parlées par le candidat.
-    SECTION LANGUES : "{languages}"
     RÈGLES :
-    1. Identifie chaque langue mentionnée dans la SECTION LANGUES.
-    2. Si la SECTION LANGUES est vide : le candidat parle au moins la LANGUE DU CV.
   expected_output: >
-    JSON : {{"langues": [{{"langue": "Anglais"}}]}}
 identity_task:
   description: >
-    Analyse le texte suivant pour extraire UNIQUEMENT le prénom du candidat.
-    SECTION INFO PERSO : "{personal_info}"
     RÈGLES :
-    1. Identifie le prénom du candidat.
-    2. Si plusieurs noms sont présents, essaie de déduire le prénom principal.
-    3. Si introuvable, renvoie une chaîne vide ou null.
   expected_output: >
-    JSON : {{"first_name": "Jean"}}

+# === CV splitter ===
 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).
+    3. "projects" : Sections explicitement titrées "Projets". Laisser VIDE si absent, ne pas inventer.
+    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.).
   expected_output: >
     Un objet JSON valide strictement structuré ainsi :
     {{
+      "header": "texte brut du header (nom, titre, contact)...",
       "experiences": "texte brut...",
       "projects": "texte brut...",
       "education": "texte brut...",
       "skills": "texte brut...",
+      "languages": "texte brut..."
     }}
+# === Tache d'extractions des informations ===
 skills_task:
   description: >
 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.
   expected_output: >
+    JSON : {{"langues": [{{"langue": "Français", "niveau": "Natif"}}, {{"langue": "Anglais", "niveau": "B2"}}]}}
 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.
   expected_output: >
+    JSON : {{"first_name": "..."}}
+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.
+  expected_output: >
+    JSON : {{
+      "poste_vise": "Le titre EXACT tel qu'écrit sur le CV",
+      "confiance": 90
+    }}
+# === partie matching ===
+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,
+    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%)
+       - 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).
+    3. Pour les profils en reconversion, valorise les compétences transférables
+       (gestion d'équipe → leadership, optimisation de production → optimisation de processus data,
+       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.
+    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.
+  expected_output: >
+    JSON : {{
+      "postes_recommandes": [
+        {{
+          "metier_id": "data_analyst",
+          "nom": "Data Analyst",
+          "categorie": "Noyau data & analytique",
+          "score_matching": 85,
+          "detail_scores": {{
+            "competences_techniques": 80,
+            "outils_technologies": 90,
+            "experiences_projets": 85,
+            "methodologies": 75
+          }},
+          "competences_matchees": ["SQL", "Python", "Power BI"],
+          "competences_manquantes": ["Looker", "dbt"],
+          "methodologies_matchees": ["Agile", "Scrum"],
+          "justification": "Le profil couvre 85% des compétences requises..."
+        }}
+      ],
+      "poste_vise_dans_top3": true,
+      "analyse_poste_vise": "Analyse détaillée de l'adéquation..."
+    }}
+cv_quality_task:
+  description: >
+    É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 ?
+    2. QUANTIFICATION DES RÉSULTATS (25 points) :
+       - Les expériences mentionnent-elles des MÉTRIQUES TECHNIQUES SPÉCIFIQUES ?
+         Cherche : réduction de latence (ms), amélioration du temps de chargement (%),
+         optimisation de requêtes SQL (x fois plus rapide), volume d'utilisateurs supporté,
+         réduction du temps de déploiement CI/CD, couverture de tests (%),
+         réduction des coûts d'infrastructure, nombre de pipelines automatisés,
+         volume de données traité, temps de réponse des APIs.
+       - Donne des suggestions SPÉCIFIQUES de métriques que le candidat pourrait ajouter
+         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.
+    4. PRÉSENTATION DES PROJETS (20 points) :
+       - Chaque projet a-t-il un titre, des technos, et des résultats ?
+       - Les projets sont-ils pertinents pour le poste visé ?
+       - Y a-t-il une variété de projets (pro + perso) ?
+    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".
+       - 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,
+         ne jamais conclure à l'absence de liens sans avoir vérifié les deux sources de texte.
+       - 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}" :
+    - 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
+      (systèmes distribués, microservices), leadership technique (mentoring, revues de code),
+      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
+    - 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
+  expected_output: >
+    JSON : {{
+      "score_global": 72,
+      "compatibilite_ats": {{ "score": 80, "details": "..." }},
+      "quantification_resultats": {{ "score": 50, "details": "...", "metriques_suggerees": ["Préciser le temps de réponse des dashboards PowerBI", "Quantifier le volume de données traité par les flows Dataiku"] }},
+      "structure_lisibilite": {{ "score": 85, "details": "...", "structuration_competences": "Compétences bien catégorisées par domaine" }},
+      "presentation_projets": {{ "score": 70, "details": "..." }},
+      "preuves_competences": {{ "score": 65, "details": "...", "skills_sans_preuve": ["skill_hors_contexte_uniquement"], "liens_detectes": ["github.com/user", "linkedin.com/in/user"] }},
+      "red_flags": ["..."],
+      "points_forts": ["..."],
+      "conseils_prioritaires": ["Conseil spécifique et actionnable 1", "Conseil spécifique 2"],
+      "adaptation_seniorite": "Analyse adaptée au profil confirmé..."
+    }}
+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é.
+    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).
+    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.
+  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é..."
+        }}
+      ],
+      "coherence_globale": {{
+        "score": 85,
+        "commentaire": "Les projets racontent une histoire cohérente..."
+      }}
+    }}

src/data/metiers.json ADDED Viewed

	@@ -0,0 +1,1273 @@

+{
+  "metadata": {
+    "version": "2.0",
+    "date": "2026-02-06",
+    "langue": "fr",
+    "description": "Métiers Data/IA avec compétences et outils enrichis 2025-2026"
+  },
+  "metiers": [
+    {
+      "id": "data_analyst",
+      "nom": "Data Analyst",
+      "categorie": "Noyau data & analytique",
+      "description": "Analyse les données pour produire des rapports, tableaux de bord et recommandations opérationnelles au service des métiers.",
+      "missions_principales": [
+        "Collecter, nettoyer et structurer les données issues de différentes sources",
+        "Construire et maintenir des tableaux de bord et rapports réguliers",
+        "Analyser les tendances, identifier des anomalies et opportunités",
+        "Traduire les besoins métier en indicateurs et analyses",
+        "Présenter les résultats et recommandations aux équipes métier"
+      ],
+      "competences_techniques": [
+        "Solide maîtrise de SQL (jointures, agrégations, CTE, window functions de base)",
+        "Bonne maîtrise d’Excel/Google Sheets (formules avancées, tableaux croisés dynamiques, macros simples)",
+        "Visualisation de données avec un ou plusieurs outils BI",
+        "Manipulation et préparation de données avec Python (pandas) ou R pour les profils plus techniques",
+        "Compréhension des bases de données relationnelles et schémas classiques (étoile, snowflake)",
+        "Notions de statistiques descriptives (moyenne, médiane, variance, corrélations, tests simples)",
+        "Connaissance de base des data warehouses et data lakes",
+        "Bonnes pratiques de requêtage (performance, lisibilité, documentation)",
+        "Notions d’automatisation des rapports (scheduling, rafraîchissement des datasets)",
+        "Capacité à interpréter les résultats d’AB testing ou d’expérimentations simples"
+      ],
+      "outils_technologies": [
+        "SQL (PostgreSQL, MySQL, SQL Server, BigQuery, Snowflake)",
+        "Excel, Google Sheets",
+        "BI : Power BI, Tableau, Looker, Qlik",
+        "Python (pandas, numpy) ou R (dplyr, ggplot2) pour les profils plus techniques",
+        "Outils de data warehouse : BigQuery, Snowflake, Redshift (en consommation)",
+        "Outils de collaboration : Confluence, Notion, Jira",
+        "Git en lecture / basique pour récupérer des scripts ou requêtes partagées"
+      ],
+      "competences_soft": [
+        "Capacité à comprendre rapidement les besoins métier",
+        "Clarté dans la communication écrite et orale",
+        "Esprit de synthèse et sens de la pédagogie",
+        "Rigueur et attention aux détails",
+        "Capacité à challenger les chiffres et à détecter des incohérences"
+      ],
+      "niveau_etude": "Bac+3 à Bac+5 (licence pro, bachelor, Master en statistiques, économie, informatique décisionnelle ou école de commerce avec majeure data/BI).",
+      "formations_utiles": [
+        "Licence / Master en statistiques, MIAGE, économie quantitative",
+        "Master ou mastère spécialisé en Business Intelligence ou data analytics",
+        "Bootcamps data analytics (3–6 mois)",
+        "Certifications Power BI, Tableau, Looker"
+      ],
+      "experience_requise": "0–2 ans pour un profil junior, 3–5 ans pour un profil confirmé pouvant piloter un périmètre métier."
+    },
+    {
+      "id": "bi_analyst",
+      "nom": "Business Intelligence Analyst",
+      "categorie": "Noyau data & analytique",
+      "description": "Conçoit et administre des solutions décisionnelles (BI) pour fournir aux métiers une vision fiable et partagée des indicateurs clés.",
+      "missions_principales": [
+        "Recueillir les besoins des métiers en matière de reporting et d’indicateurs",
+        "Concevoir et développer des tableaux de bord dynamiques et interactifs",
+        "Modéliser les données pour le décisionnel (schémas en étoile, cubes OLAP)",
+        "Optimiser les requêtes et sources pour garantir de bonnes performances",
+        "Administrer les plateformes BI (droits, rafraîchissements, gouvernance des reports)"
+      ],
+      "competences_techniques": [
+        "Maîtrise des concepts BI (dimensions, faits, grain, mesures, KPI)",
+        "SQL avancé appliqué au décisionnel",
+        "Conception de schémas en étoile et modèles analytiques",
+        "Utilisation avancée d’un ou plusieurs outils BI (DAX, MDX, calculs complexes)",
+        "Gestion des sources de données, connexions, gateways et rafraîchissement",
+        "Notions de performance tuning sur requêtes et modèles BI",
+        "Compréhension des principes de gouvernance BI (catalogue de rapports, validation, cycles de vie)"
+      ],
+      "outils_technologies": [
+        "Power BI (DAX, Power Query), Tableau, Looker, Qlik",
+        "SQL Server, Oracle, PostgreSQL",
+        "Outils ETL/ELT simples (Power Query, Fivetran, Stitch, Talend dans certains environnements)",
+        "Outils de gestion de versions de rapports / assets BI (Git, workspaces managés)"
+      ],
+      "competences_soft": [
+        "Excellente compréhension des besoins métier et de la chaîne de décision",
+        "Capacité à prioriser les demandes de reporting",
+        "Sens de la pédagogie pour former les utilisateurs aux outils BI",
+        "Communication claire avec les équipes IT et métiers"
+      ],
+      "niveau_etude": "Bac+3 à Bac+5 en informatique décisionnelle, statistiques, école d’ingénieur/commerce avec spécialisation BI.",
+      "formations_utiles": [
+        "Master ou mastère spécialisé en Business Intelligence / décisionnel",
+        "Formations éditeur (Power BI, Tableau, Qlik)",
+        "Certifications officielles des outils BI"
+      ],
+      "experience_requise": "1–3 ans dans le décisionnel ou la data pour être opérationnel en autonomie."
+    },
+    {
+      "id": "data_miner",
+      "nom": "Data Miner",
+      "categorie": "Noyau data & analytique",
+      "description": "Utilise des techniques de fouille de données pour découvrir des patterns, segments et relations cachées dans de grands volumes de données.",
+      "missions_principales": [
+        "Préparer et explorer de grands volumes de données",
+        "Mettre en œuvre des méthodes de segmentation, scoring, clustering",
+        "Identifier des patterns et signaux faibles pertinents pour le métier",
+        "Tester et valider des hypothèses statistiques",
+        "Documenter les résultats et proposer des recommandations opérationnelles"
+      ],
+      "competences_techniques": [
+        "Statistiques descriptives et inférentielles",
+        "Techniques de clustering (K-means, DBSCAN, hiérarchique, etc.)",
+        "Réduction de dimension (PCA, t-SNE, UMAP)",
+        "Notions de machine learning supervisé pour scoring prédictif",
+        "Manipulation de données avec SQL et Python/R",
+        "Visualisation avancée (cartes de chaleur, matrices de corrélation, etc.)"
+      ],
+      "outils_technologies": [
+        "Python (pandas, scikit-learn, scipy)",
+        "R (tidyverse, caret, factoextra)",
+        "Outils de data mining type RapidMiner, KNIME, Orange dans certains contextes",
+        "SQL pour l’extraction de données",
+        "BI/visualisation pour présenter les résultats"
+      ],
+      "competences_soft": [
+        "Curiosité analytique et capacité à formuler des hypothèses",
+        "Rigueur dans la méthodologie et la validation",
+        "Capacité à expliquer des patterns complexes de façon accessible"
+      ],
+      "niveau_etude": "Bac+3 à Bac+5 en statistiques, data science, mathématiques appliquées.",
+      "formations_utiles": [
+        "Licence/Master en statistiques ou data science",
+        "Formations data mining, segmentation, scoring marketing",
+        "MOOC spécialisés en data mining et clustering"
+      ],
+      "experience_requise": "1–3 ans d’expérience en analyse de données ou data science."
+    },
+    {
+      "id": "statistician",
+      "nom": "Statisticien Data",
+      "categorie": "Noyau data & analytique",
+      "description": "Conçoit des plans d’échantillonnage et des modèles statistiques pour analyser et interpréter les données de manière rigoureuse.",
+      "missions_principales": [
+        "Concevoir des études statistiques et plans de sondage",
+        "Choisir et appliquer les méthodes statistiques appropriées",
+        "Valider la qualité des données et la robustesse des résultats",
+        "Produire des rapports et avis statistiques pour éclairer les décisions",
+        "Collaborer avec des data scientists et métiers sur la méthodologie"
+      ],
+      "competences_techniques": [
+        "Statistiques descriptives, inférentielles, modèles linéaires et généralisés",
+        "Tests d’hypothèses, intervalles de confiance, ANOVA",
+        "Modèles de régression (linéaire, logistique, Poisson, etc.)",
+        "Méthodes bayésiennes de base",
+        "Logiciels statistiques (R, SAS, éventuellement Stata/SPSS)",
+        "Programmation en R ou Python pour l’automatisation d’analyses",
+        "Gestion de données d’enquête et pondérations"
+      ],
+      "outils_technologies": [
+        "R (tidyverse, lme4, brms, etc.)",
+        "SAS, SPSS, Stata selon les secteurs",
+        "Python (pandas, statsmodels, scipy)",
+        "SQL pour l’accès aux données",
+        "LaTeX ou RMarkdown pour la production de rapports"
+      ],
+      "competences_soft": [
+        "Rigueur scientifique et sens du détail",
+        "Capacité à challenger la qualité des données et les hypothèses",
+        "Bonne communication avec des non-statisticiens"
+      ],
+      "niveau_etude": "Bac+5 minimum (Master en statistiques, mathématiques appliquées) ; Doctorat apprécié dans certains domaines (santé, recherche, R&D).",
+      "formations_utiles": [
+        "Master en statistiques ou biostatistiques",
+        "Doctorat en statistiques / mathématiques appliquées",
+        "Formations spécialisées selon le domaine (santé, économie, industrie)"
+      ],
+      "experience_requise": "0–2 ans pour junior, 3–5 ans pour confirmé."
+    },
+    {
+      "id": "data_scientist",
+      "nom": "Data Scientist",
+      "categorie": "Noyau data & analytique",
+      "description": "Conçoit des modèles prédictifs, explore les données et construit des solutions ML/IA pour répondre à des problématiques métier complexes.",
+      "missions_principales": [
+        "Réaliser l'exploration et la préparation de données sur différentes sources et formats",
+        "Concevoir, entraîner, évaluer et comparer des modèles de machine learning et deep learning",
+        "Traduire des besoins métier en problématiques data et en indicateurs mesurables",
+        "Industrialiser des prototypes en scripts ou jobs reproductibles",
+        "Collaborer avec les équipes data engineering, produit et métier",
+        "Communiquer les résultats via visualisations, rapports et data storytelling"
+      ],
+      "competences_techniques": [
+        "Python avancé (pandas, numpy, scipy, scikit-learn, statsmodels)",
+        "Programmation orientée objet, bonnes pratiques (tests unitaires, packaging, logging, CI)",
+        "Statistiques avancées (tests d’hypothèses, échantillonnage, bootstrap, méthodes bayésiennes de base)",
+        "Machine learning supervisé et non supervisé (régression, arbres, gradient boosting, SVM, clustering, réduction de dimension)",
+        "Deep learning (CNN, RNN, transformers) pour texte, image et séries temporelles",
+        "Traitement de données à grande échelle avec Spark / PySpark ou Dask",
+        "Feature engineering, sélection de variables, encoding, normalisation, gestion des valeurs manquantes",
+        "Évaluation de modèles (cross-validation, métriques de classification et régression, AUC, F1, courbes PR, calibration)",
+        "Concepts de MLOps de base (suivi d’expériences, versioning de modèles et de données, reproductibilité)",
+        "Cloud data & AI (AWS, GCP ou Azure) pour entraînement et déploiement",
+        "Bon niveau SQL (jointures complexes, CTE, window functions, optimisation)",
+        "Connaissances de base en LLMs et GenAI (APIs, RAG simple, prompt engineering de base)"
+      ],
+      "outils_technologies": [
+        "Python, SQL, éventuellement R",
+        "scikit-learn, XGBoost, LightGBM, CatBoost",
+        "TensorFlow, Keras, PyTorch, Hugging Face Transformers",
+        "Apache Spark / PySpark, Dask",
+        "pandas, polars",
+        "Matplotlib, Seaborn, Plotly, Power BI, Tableau",
+        "MLflow, Weights & Biases, DVC",
+        "JupyterLab, VS Code, Databricks, Vertex AI Workbench, SageMaker Studio",
+        "PostgreSQL, MySQL, BigQuery, Snowflake, MongoDB",
+        "Git, GitHub/GitLab, GitHub Actions / GitLab CI"
+      ],
+      "competences_soft": [
+        "Capacité à vulgariser des résultats techniques à des publics non techniques",
+        "Orientation produit et impact business",
+        "Esprit critique et rigueur scientifique",
+        "Curiosité et veille technologique continue",
+        "Travail en équipe, pair programming ponctuel, feedback constructif"
+      ],
+      "niveau_etude": "Bac+5 (Master data science, statistiques, mathématiques appliquées ou école d’ingénieur) ; Doctorat apprécié pour des postes orientés R&D.",
+      "formations_utiles": [
+        "Master Data Science / IA",
+        "École d’ingénieur avec majeure data/IA",
+        "Certifications cloud orientées data/ML (AWS ML Specialty, GCP Professional ML Engineer, Azure DP-100)",
+        "MOOC/bootcamps avancés en machine learning, deep learning, NLP et MLOps"
+      ],
+      "experience_requise": "0–2 ans pour junior, 3–5 ans pour confirmé, 6+ ans pour senior / lead."
+    },
+    {
+      "metiers": [
+        {
+          "id": "data_engineer",
+          "nom": "Data Engineer",
+          "categorie": "Ingénierie data & IA",
+          "description": "Construit et maintient les pipelines et plateformes de données modernes (batch et streaming) pour alimenter l’analytics, le reporting et les systèmes d’IA.",
+          "missions_principales": [
+            "Concevoir et implémenter des architectures de données (data lake, data warehouse, lakehouse)",
+            "Mettre en place des pipelines ELT/ETL robustes, monitorés et testés",
+            "Gérer l’ingestion de données en batch et temps réel (streaming)",
+            "Optimiser les performances, la disponibilité et les coûts des plateformes data, notamment dans le cloud",
+            "Collaborer avec data scientists, analysts et équipes produit pour exposer des données consommables",
+            "Mettre en œuvre des pratiques de qualité, sécurité et gouvernance des données"
+          ],
+          "competences_techniques": [
+            "SQL avancé (requêtes complexes, tuning, indexation, partitionnement)",
+            "Python pour data engineering (scripts, packages, tests, typage, logging)",
+            "Modern data stack : dbt (data modeling & transformations), orchestration (Airflow, Dagster, Prefect)",
+            "Streaming & messaging : Apache Kafka, Confluent, AWS Kinesis, GCP Pub/Sub",
+            "Traitement distribué : Apache Spark (batch & streaming), éventuellement Flink ou Beam",
+            "Cloud data warehouses : Snowflake, BigQuery, Redshift, Synapse",
+            "Stockage data lake : S3, GCS, ADLS ; formats Parquet, ORC, Delta Lake, Apache Iceberg",
+            "CI/CD & DevOps : Git, pipelines CI, conteneurisation (Docker), infrastructure as code (Terraform, CloudFormation, Pulumi)",
+            "Concepts d’architecture data (lambda, kappa, lakehouse, microservices data)",
+            "Notions de sécurité : IAM, chiffrement au repos/en transit, gestion des secrets, data masking",
+            "Tests de données : tests unitaires, de contrats et de qualité (schémas, contraintes, anomalies)"
+          ],
+          "outils_technologies": [
+            "Orchestration : Apache Airflow, Dagster, Prefect",
+            "Transformation : dbt (core ou cloud)",
+            "Streaming : Kafka, Confluent Platform, AWS Kinesis, GCP Pub/Sub",
+            "Traitement : Spark (Databricks, EMR, DataProc), Flink, Beam",
+            "Cloud : AWS (Glue, Redshift, S3), GCP (Dataflow, BigQuery, GCS), Azure (Data Factory, Synapse, ADLS)",
+            "Data warehouse : Snowflake, BigQuery, Redshift, Synapse",
+            "Monitoring : Prometheus, Grafana, services de monitoring cloud natif",
+            "Infra as code : Terraform, CloudFormation, Pulumi",
+            "Conteneurs : Docker, Kubernetes (EKS, GKE, AKS)",
+            "Qualité & catalogue : Great Expectations, Soda Core, OpenMetadata, Amundsen"
+          ],
+          "competences_soft": [
+            "Orientation fiabilité et résilience (SRE mindset appliqué aux données)",
+            "Capacité à collaborer avec data scientists, analysts, product et infra",
+            "Documentation claire des architectures et pipelines",
+            "Analyse de risques (SLA/SLO, volumétrie, coûts cloud, dette technique)",
+            "Autonomie et capacité à prioriser les chantiers structurants"
+          ],
+          "niveau_etude": "Bac+3 à Bac+5 (licence pro, Master, école d’ingénieur en informatique, systèmes distribués ou data).",
+          "formations_utiles": [
+            "Master Big Data / Systèmes distribués / Cloud",
+            "Bootcamps ou formations intensives en data engineering et modern data stack",
+            "Certifications cloud data (AWS Data Analytics, GCP Professional Data Engineer, Azure DP-203)",
+            "Formations spécialisées Kafka, Spark, dbt, Airflow/Dagster"
+          ],
+          "experience_requise": "1–2 ans pour profils juniors, 3–5 ans pour confirmé, 5+ ans pour data architect."
+        },
+        {
+          "id": "analytics_engineer",
+          "nom": "Analytics Engineer",
+          "categorie": "Ingénierie data & IA",
+          "description": "Fait le pont entre data engineering et data analytics : modèle les données pour les rendre directement exploitables par les analystes et les métiers.",
+          "missions_principales": [
+            "Modéliser les données analytiques (modèles dimensionnels, marts orientés métier)",
+            "Écrire et maintenir les transformations SQL (ELT) dans le data warehouse",
+            "Documenter les modèles de données et les définitions de KPI",
+            "Collaborer avec les data analysts pour répondre rapidement aux besoins métier",
+            "Assurer la qualité, la cohérence et la performance des datasets analytiques"
+          ],
+          "competences_techniques": [
+            "SQL avancé (window functions, CTE, optimisation)",
+            "Modélisation de données BI (étoile, snowflake, data vault simplifié)",
+            "Transformation ELT dans un data warehouse cloud",
+            "Utilisation avancée de dbt (models, tests, documentation, lineage)",
+            "Notions de performance des requêtes et des schémas dans DW cloud",
+            "Compréhension des besoins métier et des métriques business",
+            "Notions de Git et CI pour les projets analytics"
+          ],
+          "outils_technologies": [
+            "dbt (core/cloud)",
+            "Data warehouses : Snowflake, BigQuery, Redshift, Synapse",
+            "SQL (PostgreSQL, BigQuery, Snowflake)",
+            "Orchestration : Airflow, Dagster, Prefect (en collaboration avec data engineers)",
+            "BI : Power BI, Looker, Tableau (en consommation et préparation de modèles)",
+            "Git, GitHub/GitLab pour versionner le code analytics"
+          ],
+          "competences_soft": [
+            "Forte sensibilité business",
+            "Communication efficace avec les métiers et les analystes",
+            "Rigueur dans la documentation et la définition de KPI",
+            "Capacité à prioriser les demandes analytics"
+          ],
+          "niveau_etude": "Bac+3 à Bac+5 (informatique décisionnelle, statistiques, école d’ingénieur ou commerce avec spécialisation data).",
+          "formations_utiles": [
+            "Formations modern data stack (dbt, Snowflake/BigQuery, Looker/Power BI)",
+            "Bootcamps data analytics / analytics engineering",
+            "Certifications sur data warehouses cloud"
+          ],
+          "experience_requise": "1–3 ans en data analysis/BI ou data engineering."
+        },
+        {
+          "id": "dataops_engineer",
+          "nom": "DataOps Engineer",
+          "categorie": "Ingénierie data & IA",
+          "description": "Industrialise et automatise les processus data (du sourcing à la consommation) en appliquant les principes DevOps au monde de la donnée.",
+          "missions_principales": [
+            "Automatiser le déploiement et la surveillance des pipelines de données",
+            "Mettre en place des tests et contrôles qualité sur les données",
+            "Gérer les environnements (dev, test, prod) pour les workflows data",
+            "Superviser les SLA/SLO des flux et agir en cas d’incidents",
+            "Collaborer avec data engineers, analysts et SRE pour fiabiliser la plateforme"
+          ],
+          "competences_techniques": [
+            "Bon niveau en Python et/ou bash pour l’automatisation",
+            "Orchestration de workflows (Airflow, Dagster, Prefect)",
+            "CI/CD (GitHub Actions, GitLab CI, Jenkins)",
+            "Monitoring & alerting (Prometheus, Grafana, outils cloud natifs)",
+            "Concepts DataOps (tests de données, data contracts, observabilité des données)",
+            "Connaissance des architectures data et des principaux outils de la stack data",
+            "Notions de conteneurisation et Kubernetes"
+          ],
+          "outils_technologies": [
+            "Airflow, Dagster, Prefect",
+            "Git, GitHub/GitLab, Jenkins",
+            "Prometheus, Grafana, Loki, outils de logs",
+            "Great Expectations, Soda pour la qualité des données",
+            "Docker, Kubernetes",
+            "Outils de ticketing (Jira) et de gestion d’incidents"
+          ],
+          "competences_soft": [
+            "Culture fiabilité / SRE appliquée aux données",
+            "Capacité à collaborer avec plusieurs profils (ingénieurs, ops, métier)",
+            "Rigueur, sens du détail, gestion de l’urgence en cas d’incident"
+          ],
+          "niveau_etude": "Bac+3 à Bac+5 en informatique, systèmes, data engineering.",
+          "formations_utiles": [
+            "Formations DevOps/Cloud complétées par un volet data",
+            "Certifications cloud (AWS, GCP, Azure)",
+            "Formations DataOps, Data Observability"
+          ],
+          "experience_requise": "2–4 ans en data engineering, DevOps ou SRE."
+        },
+        {
+          "id": "mlops_engineer",
+          "nom": "MLOps Engineer",
+          "categorie": "Ingénierie data & IA",
+          "description": "Automatise et fiabilise le cycle de vie des modèles de machine learning (training, déploiement, monitoring, retraining) en production.",
+          "missions_principales": [
+            "Concevoir et maintenir des pipelines de training, validation et déploiement des modèles",
+            "Intégrer le tracking d’expériences, de datasets et de modèles dans les workflows",
+            "Mettre en place le monitoring des modèles (performance, dérive, incidents)",
+            "Automatiser le retraining et la mise à jour des modèles",
+            "Collaborer avec data scientists, ML engineers et équipes infra/DevOps"
+          ],
+          "competences_techniques": [
+            "Solide base DevOps (Linux, réseaux, CI/CD, conteneurs, Kubernetes)",
+            "Connaissance pratique des frameworks ML (scikit-learn, TensorFlow, PyTorch)",
+            "MLOps : experiment tracking, model registry, feature store, pipelines ML",
+            "Outils de déploiement ML (batch, API temps réel, streaming)",
+            "Monitoring de modèles : dérive, performance, fairness, logs",
+            "Cloud AI : SageMaker, Vertex AI, Azure ML, Databricks ML",
+            "Notions de sécurité et conformité spécifique à l’IA (audit, traçabilité)"
+          ],
+          "outils_technologies": [
+            "MLflow, Kubeflow, ZenML, Metaflow",
+            "Weights & Biases, Neptune.ai",
+            "CI/CD : GitHub Actions, GitLab CI, Argo CD",
+            "Serving : FastAPI, TorchServe, TF Serving, Triton, BentoML",
+            "Infrastructure : Docker, Kubernetes, Helm",
+            "Monitoring : Prometheus, Grafana, outils de model monitoring (Evidently AI, WhyLabs)",
+            "Cloud AI : AWS SageMaker, GCP Vertex AI, Azure ML"
+          ],
+          "competences_soft": [
+            "Culture de la fiabilité et de l’automatisation",
+            "Communication avec data scientists et DevOps",
+            "Capacité à standardiser les pratiques dans l’équipe",
+            "Veille technologique sur l’écosystème MLOps/LLMOps"
+          ],
+          "niveau_etude": "Bac+3 à Bac+5 en informatique, data, ou équivalent, avec forte appétence pour l’IA et le DevOps.",
+          "formations_utiles": [
+            "Formations MLOps spécialisées",
+            "Certifications cloud ML (AWS, GCP, Azure)",
+            "Formations avancées en Kubernetes et CI/CD"
+          ],
+          "experience_requise": "2–5 ans en ML engineering, DevOps ou data engineering."
+        },
+        {
+          "id": "ml_engineer",
+          "nom": "Machine Learning Engineer",
+          "categorie": "Ingénierie data & IA",
+          "description": "Met en production des modèles de ML/IA, conçoit des APIs de prédiction et gère le cycle de vie des modèles (training, déploiement, monitoring, retraining).",
+          "missions_principales": [
+            "Industrialiser des prototypes de data science en services robustes et scalables",
+            "Concevoir des APIs de prédiction (batch, temps réel, streaming) pour les produits",
+            "Mettre en place des pipelines de training, validation, déploiement et monitoring de modèles",
+            "Optimiser les performances (latence, coût, consommation GPU/CPU) et la robustesse des systèmes ML",
+            "Collaborer avec les équipes produit, data science, DevOps/MLOps et sécurité"
+          ],
+          "competences_techniques": [
+            "Python avancé et bonnes pratiques d’ingénierie logicielle (tests, patterns, CI/CD, observabilité)",
+            "Maîtrise de frameworks ML et deep learning (scikit-learn, TensorFlow, PyTorch)",
+            "Connaissance des LLMs et transformers (fine-tuning, prompt engineering, RAG)",
+            "MLOps : conception de pipelines de training et déploiement, gestion des versions de modèles et de données",
+            "Déploiement de modèles : REST/gRPC, batch inference, streaming inference",
+            "Optimisation : quantization, pruning, distillation, ONNX, TensorRT, optimisation GPU",
+            "Monitoring de modèles (dérive de données, dérive de labels, performance en production, fairness)",
+            "Cloud AI : SageMaker, Vertex AI, Azure ML, Databricks ML",
+            "Bases solides en statistiques, ML classique et deep learning",
+            "Notions de sécurité spécifiques à l’IA (attaques adversariales, prompt injection pour LLMs)"
+          ],
+          "outils_technologies": [
+            "scikit-learn, XGBoost, LightGBM",
+            "TensorFlow, Keras, PyTorch",
+            "Hugging Face (Transformers, PEFT), LangChain, LlamaIndex, APIs OpenAI/Anthropic",
+            "MLflow, Kubeflow, ZenML, DVC, Weights & Biases",
+            "FastAPI, Flask, TorchServe, TensorFlow Serving, Triton Inference Server, BentoML",
+            "GitHub Actions, GitLab CI, Argo CD, Tekton",
+            "Docker, Kubernetes, Helm, GPU sur cloud",
+            "Prometheus, Grafana, outils de model monitoring spécialisés"
+          ],
+          "competences_soft": [
+            "Capacité à arbitrer entre performance modèle et contraintes produit (latence, coûts, maintenance)",
+            "Travail rapproché avec les équipes infra, data engineering et produit",
+            "Sens de la fiabilité, de l’observabilité et de l’automatisation",
+            "Capacité à documenter des systèmes complexes (diagrammes d’architecture, RFC techniques, READMEs)"
+          ],
+          "niveau_etude": "Bac+5 (Master/école d’ingénieur en IA, informatique, math appliquées) ; doctorat utile pour postes de R&D avancés.",
+          "formations_utiles": [
+            "Master IA / ML Engineering",
+            "Formations spécialisées MLOps et architectures cloud-native",
+            "Certifications cloud ML (AWS, GCP, Azure)",
+            "Formations avancées en LLMs, GenAI, optimisation de modèles et systèmes de recommandation"
+          ],
+          "experience_requise": "1–3 ans pour ML Engineer junior, 3–6 ans pour confirmé, 6+ ans pour Staff / Principal ML Engineer."
+        },
+        {
+          "id": "deep_learning_engineer",
+          "nom": "Deep Learning Engineer",
+          "categorie": "Ingénierie data & IA",
+          "description": "Spécialiste des réseaux de neurones profonds, conçoit des architectures deep learning pour la vision, le langage, le son ou les séries temporelles.",
+          "missions_principales": [
+            "Concevoir et entraîner des architectures de réseaux de neurones adaptées aux cas d’usage",
+            "Optimiser les modèles pour la précision, la robustesse et la performance",
+            "Exploiter le GPU et les accélérateurs matériels pour accélérer l’entraînement et l’inférence",
+            "Collaborer avec les équipes produit et recherche sur les approches d’IA avancées",
+            "Documenter et partager les résultats d’expérimentation"
+          ],
+          "competences_techniques": [
+            "Python avancé, POO, bonnes pratiques de code scientifique",
+            "Maîtrise de PyTorch et/ou TensorFlow pour le deep learning",
+            "Connaissance des architectures CNN, RNN, LSTM, transformers, diffusion models",
+            "Optimisation de l’entraînement (schedule de learning rate, régularisation, augmentation de données)",
+            "Utilisation du GPU (CUDA, cuDNN, profiling) et éventuellement TPU",
+            "Gestion de larges datasets (chargement, préprocessing, data loaders optimisés)",
+            "Notions de recherche (lecture et implémentation d’articles récents)",
+            "Suivi d’expériences et reproduction de résultats"
+          ],
+          "outils_technologies": [
+            "PyTorch, TensorFlow, Keras",
+            "Hugging Face Transformers, timm, diffusers",
+            "CUDA, cuDNN, PyTorch Lightning, Accelerate",
+            "Weights & Biases, MLflow, Neptune.ai",
+            "Jupyter, VS Code, environnement GPU (on-prem ou cloud)",
+            "Outils de profiling GPU/CPU"
+          ],
+          "competences_soft": [
+            "Curiosité scientifique, goût pour l’expérimentation",
+            "Capacité à lire et implémenter des papiers de recherche",
+            "Rigueur dans l’évaluation et la réplication de résultats"
+          ],
+          "niveau_etude": "Bac+5 à Bac+8 (Master IA, école d’ingénieur, doctorat en IA/vision/NLP).",
+          "formations_utiles": [
+            "Master spécialisé en deep learning",
+            "Doctorat en IA / vision / NLP",
+            "Formations NVIDIA, fast.ai, MOOCs DL avancés"
+          ],
+          "experience_requise": "1–3 ans en DL appliqué, plus pour les rôles senior/R&D."
+        },
+        {
+          "id": "ai_engineer",
+          "nom": "AI Engineer",
+          "categorie": "Ingénierie data & IA",
+          "description": "Construit des systèmes d’IA end-to-end, combinant modèles, règles, APIs, LLMs et intégrations produit pour répondre à des cas d’usage métiers.",
+          "missions_principales": [
+            "Assembler des composants d’IA (ML classique, deep learning, LLMs, règles, APIs externes) en solutions complètes",
+            "Intégrer les systèmes d’IA dans les produits existants (backend, frontend, workflows métier)",
+            "Optimiser expérience utilisateur, latence et coûts d’inférence",
+            "Assurer la supervision, les logs et la gestion d’erreurs des systèmes IA",
+            "Collaborer avec les équipes produit, design et métier pour définir les fonctionnalités IA"
+          ],
+          "competences_techniques": [
+            "Bon niveau en Python et un langage backend (TypeScript/Node, Java, Go selon le contexte)",
+            "Connaissance de plusieurs familles de modèles (ML, DL, LLMs, systèmes de recommandation)",
+            "Intégration d’APIs d’IA (OpenAI, Anthropic, Vertex AI, Hugging Face Inference)",
+            "Patterns d’applications LLM (RAG, agents, outils, memory, évaluation)",
+            "Déploiement de services IA (APIs, serverless functions, microservices)",
+            "Notions de sécurité applicative (auth, rate limiting, gestion de secrets)"
+          ],
+          "outils_technologies": [
+            "Python, TypeScript/Node.js",
+            "Frameworks web : FastAPI, Flask, Express",
+            "LLM frameworks : LangChain, LlamaIndex, semantic-kernel",
+            "APIs LLM : OpenAI, Anthropic, Gemini, LLaMA via providers",
+            "Vector DB : Pinecone, Weaviate, Qdrant, Redis, PGVector",
+            "Cloud : AWS, GCP, Azure (APIs managées d’IA, serverless)",
+            "Observabilité : OpenTelemetry, Prometheus, Grafana"
+          ],
+          "competences_soft": [
+            "Orientation produit et UX",
+            "Capacité à prototyper rapidement et itérer",
+            "Communication avec designers, PM et métiers"
+          ],
+          "niveau_etude": "Bac+3 à Bac+5 (informatique/IA), avec forte appétence pour le développement logiciel.",
+          "formations_utiles": [
+            "Formations en IA appliquée et développement d’applications LLM",
+            "Bootcamps IA fullstack",
+            "Certifications LLM/GenAI proposées par les hyperscalers"
+          ],
+          "experience_requise": "2–5 ans en dev logiciel et/ou ML engineering."
+        },
+        {
+          "id": "data_platform_engineer",
+          "nom": "Data Platform Engineer",
+          "categorie": "Ingénierie data & IA",
+          "description": "Conçoit, construit et maintient la plateforme data/IA globale (outils, services, standards) utilisée par les équipes data et produit.",
+          "missions_principales": [
+            "Concevoir l’architecture globale de la plateforme data/IA",
+            "Packager des services self-service pour les équipes data (environnements, templates, pipelines)",
+            "Gérer l’infrastructure (Kubernetes, cloud, sécurité, monitoring)",
+            "Standardiser les outils (suite MLOps, DataOps, gouvernance)",
+            "Assurer la scalabilité et l’optimisation des coûts de la plateforme"
+          ],
+          "competences_techniques": [
+            "Architecture systèmes distribués",
+            "Maîtrise des principaux composants de la stack data & MLOps",
+            "Cloud computing (AWS/GCP/Azure) orienté data et IA",
+            "Kubernetes, networking, sécurité, observabilité",
+            "Infra as Code (Terraform, Pulumi) et GitOps"
+          ],
+          "outils_technologies": [
+            "Kubernetes, Helm, Istio/Linkerd (selon contexte)",
+            "Terraform, Pulumi, ArgoCD",
+            "Spark, Kafka, data warehouses cloud",
+            "Outils MLOps/DataOps (MLflow, Airflow, dbt, catalogues, quality tools)",
+            "Monitoring : Prometheus, Grafana, Loki"
+          ],
+          "competences_soft": [
+            "Leadership technique transversal",
+            "Capacité à définir des standards et conventions",
+            "Communication avec de multiples équipes",
+            "Vision long terme sur l’architecture"
+          ],
+          "niveau_etude": "Bac+5 (école d’ingénieur / Master informatique, systèmes distribués).",
+          "formations_utiles": [
+            "Formations avancées en cloud & Kubernetes",
+            "Certifications architecte cloud (AWS/GCP/Azure)",
+            "Formations data platform / data mesh"
+          ],
+          "experience_requise": "5+ ans en data engineering/infra, dont expérience significative en architecture."
+        }
+      ]
+    },
+    {
+      "metiers": [
+        {
+          "id": "cdo",
+          "nom": "Chief Data Officer (CDO)",
+          "categorie": "Gouvernance, qualité, protection",
+          "description": "Dirige la stratégie data de l’entreprise. Responsable de la gouvernance, de la valorisation et de la conformité des données pour créer de la valeur business.",
+          "missions_principales": [
+            "Définir et piloter la stratégie data alignée sur les objectifs business",
+            "Superviser la gouvernance des données (qualité, métadonnées, catalogue)",
+            "Garantir la conformité RGPD, AI Act et autres réglementations",
+            "Construire et animer la plateforme data/IA (outils, standards, budget)",
+            "Évangeliser la culture data et mesurer l’impact business des initiatives data",
+            "Collaborer avec C-level (CEO, CIO, CTO, CMO) sur la transformation data-driven"
+          ],
+          "competences_techniques": [
+            "Architecture data et modern data stack (lakehouse, data mesh, data product)",
+            "Gouvernance data (qualité, catalogue, lineage, ownership)",
+            "Conformité RGPD, AI Act, NIST AI RMF, ISO 42001",
+            "Cloud data platforms (AWS, GCP, Azure) et coûts optimisation",
+            "Data product management et data mesh",
+            "AI/ML gouvernance (bias, fairness, explainability, model cards)",
+            "KPI data (ROI data projects, data maturity, adoption metrics)",
+            "Outils de data governance et catalogue"
+          ],
+          "outils_technologies": [
+            "Data catalogs : Collibra, Alation, DataHub, Amundsen, OpenMetadata",
+            "Data governance : Informatica, Talend, Atlan",
+            "Data quality : Great Expectations, Soda, Monte Carlo",
+            "Cloud data platforms : Snowflake, BigQuery, Databricks",
+            "Observabilité data : Monte Carlo, Bigeye",
+            "Outils de conformité : Credo AI, Holistic AI",
+            "BI executive : Tableau, Power BI, Looker"
+          ],
+          "competences_soft": [
+            "Leadership stratégique et vision business",
+            "Capacité à influencer le C-level et à vendre la valeur des données",
+            "Gestion du changement et acculturation data",
+            "Communication claire et storytelling data",
+            "Gestion d’équipe pluridisciplinaire (data scientists, engineers, analysts)"
+          ],
+          "niveau_etude": "Bac+5 (MBA, école d’ingénieur/commerce, Master data science) + expérience significative.",
+          "formations_utiles": [
+            "MBA ou executive education (INSEAD, HEC, etc.)",
+            "Certifications data governance (CDMP, DAMA)",
+            "Formations AI governance et compliance (AI Act, NIST)",
+            "Executive programs data leadership (MIT, Stanford)"
+          ],
+          "experience_requise": "10+ ans en data/analytics, dont 3–5 ans en rôle de gouvernance/leadership data."
+        },
+        {
+          "id": "cao",
+          "nom": "Chief Analytics Officer (CAO)",
+          "categorie": "Gouvernance, qualité, protection",
+          "description": "Dirige la stratégie analytique et décisionnelle. Responsable de la création de valeur par l’analytics et l’IA prédictive.",
+          "missions_principales": [
+            "Définir la roadmap analytics et IA prédictive",
+            "Piloter les projets d’analytics avancés et ML",
+            "Mesurer l’impact business des insights et modèles",
+            "Construire et animer les équipes analytics/data science",
+            "Aligner les priorités analytics avec les objectifs stratégiques"
+          ],
+          "competences_techniques": [
+            "Analytics avancé et machine learning",
+            "Gestion de portefeuille de projets data science",
+            "KPI analytics (ROI, précision modèles, adoption)",
+            "Roadmapping technique et priorisation",
+            "Cloud analytics (Databricks, Snowflake ML, BigQuery ML)"
+          ],
+          "outils_technologies": [
+            "Cloud analytics platforms : Databricks, Snowflake ML, BigQuery ML",
+            "BI avancé : Looker, Tableau, Power BI",
+            "MLOps : MLflow, Vertex AI, SageMaker",
+            "Outils de gestion de projets data (Jira, Asana, Monday)"
+          ],
+          "competences_soft": [
+            "Leadership technique et business",
+            "Storytelling analytics",
+            "Gestion d’équipe data science",
+            "Vision stratégique"
+          ],
+          "niveau_etude": "Bac+5 (Master analytics/data science, école d’ingénieur/commerce).",
+          "formations_utiles": [
+            "Master analytics/data science",
+            "MBA ou executive education",
+            "Certifications cloud analytics"
+          ],
+          "experience_requise": "8+ ans analytics/data science, dont 3+ ans leadership."
+        },
+        {
+          "id": "data_manager",
+          "nom": "Data Manager",
+          "categorie": "Gouvernance, qualité, protection",
+          "description": "Gère les ressources et processus data. Assure la qualité, la disponibilité et la conformité des données au quotidien.",
+          "missions_principales": [
+            "Gérer les inventaires de données et métadonnées",
+            "Assurer la qualité des données selon les standards",
+            "Piloter la conformité et les audits data",
+            "Coordonner les équipes data sur les projets transversaux",
+            "Optimiser les processus de gestion des données"
+          ],
+          "competences_techniques": [
+            "Data quality frameworks et métriques",
+            "Data catalog et lineage",
+            "Conformité RGPD de base",
+            "SQL pour audits et contrôles qualité",
+            "Outils de data governance"
+          ],
+          "outils_technologies": [
+            "Data catalogs : Collibra, Alation, DataHub",
+            "Data quality : Great Expectations, Soda Core",
+            "Excel/Google Sheets avancé",
+            "SQL, BI tools pour audits"
+          ],
+          "competences_soft": [
+            "Organisation et gestion de projet",
+            "Collaboration transversale",
+            "Rigueur et sens du détail"
+          ],
+          "niveau_etude": "Bac+3 à Bac+5 (informatique, gestion, commerce).",
+          "formations_utiles": [
+            "Formations data governance",
+            "Certifications RGPD/data management"
+          ],
+          "experience_requise": "3–7 ans en data/analytique."
+        },
+        {
+          "id": "data_product_manager",
+          "nom": "Data Product Manager",
+          "categorie": "Produits, projets, stratégie",
+          "description": "Gère les produits data comme un produit business (data lake, data mart, API data, ML features). Définit la roadmap et la valeur métier.",
+          "missions_principales": [
+            "Définir la vision et roadmap du produit data",
+            "Prioriser les features selon l’impact business et les besoins des consommateurs data",
+            "Collaborer avec data engineers, analysts et métiers pour définir les spécifications",
+            "Mesurer l’adoption, l’usage et le ROI du produit data",
+            "Évangeliser le produit auprès des consommateurs internes"
+          ],
+          "competences_technences": [
+            "Data product thinking (usage, adoption, métriques produit)",
+            "Compréhension technique de la stack data (warehouse, pipelines, quality)",
+            "Roadmapping et priorisation (RICE, Kano, etc.)",
+            "KPI data products (usage metrics, data freshness, adoption)",
+            "Data mesh et data productisation",
+            "SQL et BI pour valider les hypothèses"
+          ],
+          "outils_technologies": [
+            "Roadmapping : Productboard, Aha!, Jira, Notion",
+            "Prototyping : Figma pour mockups de dashboards/API",
+            "Analytics : Mixpanel, Amplitude pour adoption data",
+            "BI : Looker, Tableau, Power BI",
+            "SQL, dbt pour valider les datasets",
+            "Data catalogs pour discovery"
+          ],
+          "competences_soft": [
+            "Product mindset appliqué aux données",
+            "Communication avec métiers et data teams",
+            "Storytelling data product",
+            "Gestion de stakeholders multiples"
+          ],
+          "niveau_etude": "Bac+5 (école commerce, Master data, école d’ingénieur).",
+          "formations_utiles": [
+            "Formations product management",
+            "Formations data product (Reforge, Product School)",
+            "Certifications product management"
+          ],
+          "experience_requise": "3+ ans product management ou data analytics."
+        },
+        {
+          "id": "ai_product_manager",
+          "nom": "AI Product Manager",
+          "categorie": "Produits, projets, stratégie",
+          "description": "Gère les produits utilisant l’IA (chatbots, systèmes de recommandation, agents IA, outils GenAI). Aligne besoins métier et capacités techniques IA.",
+          "missions_principales": [
+            "Définir la roadmap produit IA",
+            "Prioriser features IA selon ROI, UX et faisabilité technique",
+            "Collaborer avec data scientists, ML engineers et design",
+            "Tester et mesurer l’efficacité des modèles IA (A/B testing, métriques produit)",
+            "Gérer les risques éthiques et réglementaires de l’IA"
+          ],
+          "competences_techniques": [
+            "Compréhension des modèles ML/LLM (capacités, limites, coûts)",
+            "Patterns d’applications IA (RAG, agents, outils, fine-tuning)",
+            "Métriques produit IA (précision, latence, coût d’inférence, satisfaction user)",
+            "UX d’interactions IA (prompts, feedback loops)",
+            "Notions d’éthique IA et compliance AI Act"
+          ],
+          "outils_technologies": [
+            "Productboard, Jira, Aha! pour roadmapping",
+            "Figma pour mockups d’interfaces IA",
+            "Amplitude, Mixpanel pour analytics IA",
+            "APIs LLM : OpenAI, Anthropic, Vertex AI",
+            "LangChain, LlamaIndex pour prototyping",
+            "Prompt engineering tools"
+          ],
+          "competences_soft": [
+            "Product thinking appliqué à l’IA",
+            "Collaboration avec data scientists et ML engineers",
+            "Gestion des attentes sur les capacités IA",
+            "Sensibilité éthique et UX"
+          ],
+          "niveau_etude": "Bac+5 (école commerce, Master IA/data, école d’ingénieur).",
+          "formations_utiles": [
+            "Formations product management IA",
+            "Bootcamps GenAI product",
+            "Certifications LLM/GenAI"
+          ],
+          "experience_requise": "2–4 ans product management + appétence IA."
+        },
+        {
+          "id": "consultant_data",
+          "nom": "Consultant Data",
+          "categorie": "Produits, projets, stratégie",
+          "description": "Conseille les entreprises sur leur transformation data. Diagnostique, propose des architectures et accompagne la mise en œuvre.",
+          "missions_principales": [
+            "Diagnostiquer la maturité data de l’entreprise",
+            "Proposer des architectures data adaptées",
+            "Accompagner la mise en œuvre des projets data",
+            "Former les équipes aux bonnes pratiques",
+            "Mesurer l’impact des transformations data"
+          ],
+          "competences_techniques": [
+            "Data maturity assessment",
+            "Architecture data (lakehouse, data mesh, data fabric)",
+            "Modern data stack",
+            "Cloud migration data",
+            "Data governance frameworks",
+            "ROI calculation pour projets data"
+          ],
+          "outils_technologies": [
+            "Outils d’audit data (Collibra, Talend, Informatica)",
+            "Cloud platforms (AWS, GCP, Azure)",
+            "Modern data stack (dbt, Airflow, Snowflake, etc.)",
+            "Outils de modélisation (ER/Studio, Lucidchart)",
+            "Excel, Power BI pour business cases"
+          ],
+          "competences_soft": [
+            "Consulting mindset",
+            "Communication claire et structurée",
+            "Gestion de projet et stakeholders",
+            "Pédagogie et formation"
+          ],
+          "niveau_etude": "Bac+5 (école d’ingénieur, commerce, Master data).",
+          "formations_utiles": [
+            "Formations consulting data",
+            "Certifications cloud et data engineering",
+            "MBA ou mastère spécialisé"
+          ],
+          "experience_requise": "3–7 ans en data/projects."
+        },
+        {
+          "id": "data_project_manager",
+          "nom": "Chef de Projet Data",
+          "categorie": "Produits, projets, stratégie",
+          "description": "Pilote les projets data de bout en bout. Gère les ressources, risques, budget et livraison des initiatives data.",
+          "missions_principales": [
+            "Planifier et piloter les projets data (scope, planning, budget)",
+            "Gérer les équipes pluridisciplinaires (data engineers, scientists, analysts)",
+            "Suivre les risques et les indicateurs de projet",
+            "Communiquer avec les sponsors et stakeholders",
+            "Assurer la livraison conforme aux attentes"
+          ],
+          "competences_techniques": [
+            "Gestion de projet agile (Scrum, Kanban)",
+            "Compréhension technique data/IA",
+            "KPI projet data (data freshness, modèle accuracy, adoption)",
+            "Outils de gestion de projet",
+            "Notions de budget cloud data"
+          ],
+          "outils_technologies": [
+            "Jira, Confluence, Asana, Monday.com",
+            "MS Project, Smartsheet",
+            "Power BI/Tableau pour dashboards projet",
+            "GitHub/GitLab pour suivi technique"
+          ],
+          "competences_soft": [
+            "Leadership d’équipe",
+            "Gestion de stakeholders",
+            "Résolution de conflits",
+            "Communication claire"
+          ],
+          "niveau_etude": "Bac+5 (management, informatique).",
+          "formations_utiles": [
+            "Certifications PMP, Scrum Master, Prince2",
+            "Formations gestion de projet data"
+          ],
+          "experience_requise": "3–7 ans gestion de projet IT/data."
+        },
+        {
+          "id": "data_strategist",
+          "nom": "Data Strategist",
+          "categorie": "Produits, projets, stratégie",
+          "description": "Définit la stratégie data de l’entreprise. Identifie les opportunités data et aligne avec les objectifs business.",
+          "missions_principales": [
+            "Identifier les opportunités data stratégiques",
+            "Construire la roadmap data à 2–3 ans",
+            "Mesurer l’impact business des initiatives data",
+            "Conseiller le C-level sur les investissements data",
+            "Veille technologique et benchmarking data"
+          ],
+          "competences_techniques": [
+            "Data strategy frameworks",
+            "Data maturity models",
+            "ROI calculation data projects",
+            "Benchmarking data stack",
+            "Trends data (data mesh, GenAI, real-time)"
+          ],
+          "outils_technologies": [
+            "Excel, Google Sheets pour business cases",
+            "Power BI/Tableau pour présentations",
+            "Outils de veille (Gartner, Forrester)",
+            "Notion/Confluence pour documentation"
+          ],
+          "competences_soft": [
+            "Vision stratégique",
+            "Communication C-level",
+            "Storytelling business",
+            "Benchmarking"
+          ],
+          "niveau_etude": "Bac+5 (MBA, école commerce, Master data).",
+          "formations_utiles": [
+            "MBA, executive education",
+            "Formations data strategy"
+          ],
+          "experience_requise": "7+ ans data, 3+ ans stratégie."
+        },
+        {
+          "id": "data_steward",
+          "nom": "Data Steward",
+          "categorie": "Gouvernance, qualité, protection",
+          "description": "Assure la qualité et la gouvernance des données au quotidien. Documente, contrôle et corrige les données.",
+          "missions_principales": [
+            "Contrôler la qualité des données selon les règles métier",
+            "Documenter les métadonnées et glossaires",
+            "Corriger les anomalies et erreurs détectées",
+            "Former les contributeurs aux bonnes pratiques data",
+            "Participer aux audits qualité"
+          ],
+          "competences_techniques": [
+            "Data quality rules et métriques",
+            "Métadonnées et glossaires",
+            "SQL pour contrôles qualité",
+            "Excel/Google Sheets avancé",
+            "Outils data quality"
+          ],
+          "outils_technologies": [
+            "Excel, Google Sheets",
+            "SQL",
+            "Data quality tools (Great Expectations, Soda)",
+            "Data catalogs (DataHub, Amundsen)",
+            "Jira pour tracking des issues data"
+          ],
+          "competences_soft": [
+            "Rigueur et attention aux détails",
+            "Collaboration avec métiers et IT",
+            "Pédagogie",
+            "Organisation"
+          ],
+          "niveau_etude": "Bac+2 à Bac+3.",
+          "formations_utiles": [
+            "Formations data quality/governance",
+            "Certifications data stewardship"
+          ],
+          "experience_requise": "1–3 ans data/analytique."
+        }
+      ]
+    },
+    {
+      "metiers": [
+        {
+          "id": "nlp_engineer",
+          "nom": "NLP Engineer / Ingénieur TAL",
+          "categorie": "Spécialistes techniques IA",
+          "description": "Développe des solutions de traitement automatique du langage naturel (chatbots, analyse de sentiments, NER, traduction, résumé).",
+          "missions_principales": [
+            "Construire des pipelines NLP end-to-end (préprocessing, embedding, modèles, postprocessing)",
+            "Fine-tuner des modèles de langage pour des cas d’usage spécifiques",
+            "Implémenter des patterns RAG et agents conversationnels",
+            "Optimiser la performance et la latence des systèmes NLP",
+            "Évaluer la qualité des modèles NLP (BLEU, ROUGE, perplexity, human eval)"
+          ],
+          "competences_techniques": [
+            "Maîtrise des modèles transformers et LLMs",
+            "Fine-tuning et PEFT (LoRA, QLoRA)",
+            "RAG (retrieval-augmented generation) et vector search",
+            "NLP evaluation metrics (BLEU, ROUGE, BERTScore, perplexity)",
+            "Embeddings et vector databases",
+            "Prompt engineering et chain-of-thought",
+            "Langage spécifique (NER, POS tagging, dependency parsing)"
+          ],
+          "outils_technologies": [
+            "Hugging Face Transformers, PEFT",
+            "spaCy, NLTK, Stanford CoreNLP",
+            "LangChain, LlamaIndex, Haystack",
+            "Vector DB : Pinecone, Weaviate, Qdrant, PGVector",
+            "APIs : OpenAI GPT, Anthropic Claude, Google Gemini, Cohere",
+            "FastAPI pour APIs NLP",
+            "Docker/Kubernetes pour déploiement"
+          ],
+          "competences_soft": [
+            "Compréhension linguistique",
+            "Curiosité pour les langues et cultures",
+            "Collaboration avec UX et métiers"
+          ],
+          "niveau_etude": "Bac+5 (Master IA/NLP, école d’ingénieur).",
+          "formations_utiles": [
+            "Master spécialisation NLP",
+            "Formations Hugging Face, spaCy",
+            "MOOCs NLP avancés"
+          ],
+          "experience_requise": "1–3 ans NLP/ML."
+        },
+        {
+          "id": "cv_engineer",
+          "nom": "Computer Vision Engineer",
+          "categorie": "Spécialistes techniques IA",
+          "description": "Développe des solutions d’analyse d’images et vidéos (détection d’objets, segmentation, tracking, 3D reconstruction).",
+          "missions_principales": [
+            "Construire des pipelines vision end-to-end",
+            "Fine-tuner des modèles de vision (YOLO, DETR, Segment Anything)",
+            "Optimiser pour edge devices et temps réel",
+            "Implémenter tracking et multi-object tracking",
+            "Évaluer la précision (mAP, IoU, FPS)"
+          ],
+          "competences_techniques": [
+            "CNN et architectures vision (ResNet, EfficientNet, Vision Transformers)",
+            "Object detection (YOLOv8, YOLOv9, RT-DETR)",
+            "Segmentation (Mask R-CNN, SAM, U-Net)",
+            "Tracking (DeepSORT, ByteTrack)",
+            "Optimisation edge (TensorRT, ONNX Runtime, TFLite)",
+            "3D vision de base (depth estimation, point clouds)"
+          ],
+          "outils_technologies": [
+            "PyTorch, TensorFlow, OpenCV",
+            "Ultralytics YOLO, Detectron2, MMdetection",
+            "Segment Anything Model (SAM)",
+            "ONNX, TensorRT, OpenVINO",
+            "Docker pour déploiement edge",
+            "Roboflow pour datasets et annotation"
+          ],
+          "competences_soft": [
+            "Sens visuel",
+            "Rigueur dans l’évaluation",
+            "Collaboration avec hardware"
+          ],
+          "niveau_etude": "Bac+5 (Master vision/IA).",
+          "formations_utiles": [
+            "Formations CV avancées",
+            "Certifications NVIDIA"
+          ],
+          "experience_requise": "1–3 ans CV/ML."
+        },
+        {
+          "id": "llm_engineer",
+          "nom": "LLM Engineer",
+          "categorie": "Spécialistes techniques IA",
+          "description": "Spécialiste des Large Language Models. Fine-tune, déploie et optimise des modèles de langage pour des cas d’usage spécifiques.",
+          "missions_principales": [
+            "Fine-tuner des LLMs open-source (Llama, Mistral, Mixtral)",
+            "Implémenter RAG, agents, tools et memory",
+            "Optimiser coûts et latence (quantization, distillation)",
+            "Évaluer qualité (human eval, LLM-as-judge)",
+            "Déployer en production (APIs, streaming, edge)"
+          ],
+          "competences_techniques": [
+            "Fine-tuning (PEFT, LoRA, QLoRA)",
+            "RAG (advanced retrieval, reranking, hybrid search)",
+            "Agents LLM (tools calling, reasoning)",
+            "Quantization (bitsandbytes, GPTQ, AWQ)",
+            "Evaluation LLM (human eval, LLM-as-judge, benchmarks)",
+            "Prompt engineering avancé"
+          ],
+          "outils_technologies": [
+            "Hugging Face (Transformers, TRL, PEFT)",
+            "Unsloth, Axolotl pour fine-tuning rapide",
+            "LangChain, LlamaIndex, Haystack",
+            "vLLM, Text Generation Inference pour serving",
+            "Vector DB : Pinecone, Weaviate, Milvus",
+            "Ollama, LM Studio pour local eval"
+          ],
+          "competences_soft": [
+            "Rapidité d’apprentissage",
+            "Expérimentation",
+            "Collaboration"
+          ],
+          "niveau_etude": "Bac+5 (Master IA/NLP).",
+          "formations_utiles": [
+            "Formations Hugging Face LLM",
+            "Bootcamps LLM engineering"
+          ],
+          "experience_requise": "1–2 ans ML/NLP."
+        },
+        {
+          "id": "prompt_engineer",
+          "nom": "Prompt Engineer",
+          "categorie": "Spécialistes techniques IA",
+          "description": "Optimise les prompts et interactions avec les LLMs pour maximiser la qualité et la cohérence des réponses.",
+          "missions_principales": [
+            "Concevoir des prompts optimisés pour différents LLMs",
+            "Tester et itérer sur les prompts (A/B testing)",
+            "Créer des templates et patterns réutilisables",
+            "Former les équipes aux bonnes pratiques de prompting",
+            "Mesurer l’efficacité des prompts (qualité, coût, latence)"
+          ],
+          "competences_techniques": [
+            "Prompt engineering techniques (chain-of-thought, few-shot, tree-of-thoughts)",
+            "Compréhension des capacités/limites des différents LLMs",
+            "A/B testing de prompts",
+            "Métriques d’évaluation (human eval, LLM-as-judge)"
+          ],
+          "outils_technologies": [
+            "Promptfoo, LangSmith, PromptLayer",
+            "OpenAI Playground, Anthropic Console",
+            "LangChain, LlamaIndex pour templating",
+            "Jupyter pour experimentation"
+          ],
+          "competences_soft": [
+            "Créativité linguistique",
+            "Sens analytique",
+            "Pédagogie"
+          ],
+          "niveau_etude": "Bac+3 minimum.",
+          "formations_utiles": [
+            "Bootcamps prompt engineering",
+            "Cours OpenAI/Anthropic"
+          ],
+          "experience_requise": "0–1 an."
+        },
+        {
+          "id": "data_viz_specialist",
+          "nom": "Data Visualisation Specialist",
+          "categorie": "Visualisation, décisionnel, métier",
+          "description": "Crée des visualisations impactantes et narratives pour communiquer les insights data de manière accessible et persuasive.",
+          "missions_principales": [
+            "Concevoir des visualisations adaptées au message et au public",
+            "Créer des dashboards interactifs et storytelling data",
+            "Optimiser l’UX et l’accessibilité des visualisations",
+            "Collaborer avec data analysts et métiers",
+            "Produire des présentations data impactantes"
+          ],
+          "competences_techniques": [
+            "Principes de data visualization (Tufte, Cleveland)",
+            "Design graphique et UX/UI pour data",
+            "Utilisation avancée des outils de visualisation",
+            "SQL pour préparation des datasets viz",
+            "Animation et interactivité data"
+          ],
+          "outils_technologies": [
+            "Tableau, Power BI, Looker",
+            "D3.js, Observable, Vega-Lite",
+            "Figma pour design",
+            "Flourish, Datawrapper pour storytelling",
+            "ggplot2, Plotly pour Python/R"
+          ],
+          "competences_soft": [
+            "Sens esthétique et créativité",
+            "Storytelling data",
+            "Compréhension du public cible"
+          ],
+          "niveau_etude": "Bac+3 (design, informatique).",
+          "formations_utiles": [
+            "Formations data visualization",
+            "Certifications Tableau/Power BI"
+          ],
+          "experience_requise": "1–3 ans."
+        },
+        {
+          "id": "data_architect",
+          "nom": "Data Architect",
+          "categorie": "Infrastructure et sécurité",
+          "description": "Conçoit l’architecture globale des systèmes de données (data lake, warehouse, pipelines, gouvernance) pour répondre aux besoins actuels et futurs.",
+          "missions_principales": [
+            "Définir l’architecture data stratégique",
+            "Choisir les technologies adaptées (lakehouse vs warehouse, on-prem vs cloud)",
+            "Modéliser les données (data modeling, schemas)",
+            "Garantir scalabilité, performance, coûts",
+            "Documenter l’architecture et standards"
+          ],
+          "competences_techniques": [
+            "Architecture lakehouse/data mesh/data fabric",
+            "Modélisation de données (étoile, data vault, Kimball)",
+            "Benchmarking technologies data",
+            "Optimisation coûts/performance cloud",
+            "Data governance architecture"
+          ],
+          "outils_technologies": [
+            "Snowflake, Databricks, BigQuery",
+            "Terraform, Lucidchart, dbt",
+            "Collibra, Alation pour gouvernance"
+          ],
+          "competences_soft": [
+            "Vision stratégique",
+            "Communication technique/business",
+            "Benchmarking"
+          ],
+          "niveau_etude": "Bac+5 (école d’ingénieur).",
+          "formations_utiles": [
+            "Certifications architecte cloud",
+            "Formations data modeling"
+          ],
+          "experience_requise": "5+ ans data engineering."
+        },
+        {
+          "id": "ai_ethics_specialist",
+          "nom": "AI Ethics Specialist",
+          "categorie": "Formation, accompagnement, éthique",
+          "description": "Assure l’éthique et la conformité des systèmes IA. Évalue les risques (bias, fairness, privacy) et propose des solutions responsables.",
+          "missions_principales": [
+            "Auditer les modèles IA (bias, fairness, robustness)",
+            "Implémenter des garde-fous et mitigations",
+            "Rédiger model cards et documentation éthique",
+            "Former aux bonnes pratiques IA responsable",
+            "Conseiller sur AI Act et conformité"
+          ],
+          "competences_techniques": [
+            "Bias detection et mitigation",
+            "Fairness metrics (demographic parity, equal opportunity)",
+            "Explainability (SHAP, LIME, counterfactuals)",
+            "AI Act classification et obligations",
+            "Privacy (DP-SGD, federated learning)"
+          ],
+          "outils_technologies": [
+            "IBM AI Fairness 360, Aequitas",
+            "SHAP, LIME pour explainability",
+            "Credo AI, Holistic AI pour gouvernance",
+            "What-If Tool (Google), Facets",
+            "AI FactSheets 360"
+          ],
+          "competences_soft": [
+            "Pensée critique éthique",
+            "Communication interdisciplinaire",
+            "Pédagogie"
+          ],
+          "niveau_etude": "Bac+5 (éthique, droit, informatique).",
+          "formations_utiles": [
+            "Certifications AI ethics/governance",
+            "Formations AI Act"
+          ],
+          "experience_requise": "2–5 ans IA/compliance."
+        },
+        {
+          "id": "dpo",
+          "nom": "Data Protection Officer (DPO)",
+          "categorie": "Gouvernance, qualité, protection",
+          "description": "Garantit la conformité RGPD et protection des données personnelles dans les projets data/IA.",
+          "missions_principales": [
+            "Effectuer les DPIA (Data Protection Impact Assessment)",
+            "Gérer les demandes d’exercice des droits (droit à l’oubli, etc.)",
+            "Conseiller sur la conformité des traitements",
+            "Auditer les systèmes de données",
+            "Former aux obligations RGPD"
+          ],
+          "competences_techniques": [
+            "RGPD, CNIL, ePrivacy",
+            "Data mapping et register of processing",
+            "DPIA, transferts internationaux",
+            "Sécurité des données (encryption, pseudonymisation)"
+          ],
+          "outils_technologies": [
+            "Outils compliance (OneTrust, TrustArc)",
+            "Excel pour data mapping",
+            "Outils de chiffrement"
+          ],
+          "competences_soft": [
+            "Rigueur juridique",
+            "Communication",
+            "Pédagogie"
+          ],
+          "niveau_etude": "Bac+5 (droit, gestion).",
+          "formations_utiles": [
+            "Certifications DPO/RGPD"
+          ],
+          "experience_requise": "3+ ans compliance."
+        }
+      ]
+    }
+  ]
+}

src/parser_flow/CV_agent_flow.py CHANGED Viewed

@@ -1,110 +1,237 @@
 import json
 import logging
 import os
 import yaml
 import asyncio
 from datetime import datetime
-from typing import Dict, Any
 from crewai import Agent, Task, Crew, Process
 from src.config.app_config import get_small_llm, get_big_llm
 logger = logging.getLogger(__name__)
 class CVAgentOrchestrator:
     def __init__(self):
         self.llm = get_small_llm()
         self.big_llm = get_big_llm()
         self.agents_config = self._load_yaml("agents.yaml")
         self.tasks_config = self._load_yaml("tasks.yaml")
         self._create_agents()
     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)
-        with open(config_path, 'r', encoding='utf-8') as f:
             return yaml.safe_load(f)
     def _create_agents(self):
         def make_agent(name, llm_override=None):
             return Agent(
                 config=self.agents_config[name],
                 llm=llm_override or self.llm,
                 allow_delegation=False,
-                verbose=False,
                 max_iter=1,
-                respect_context_window=True
             )
-        self.cv_splitter = make_agent('cv_splitter', llm_override=self.big_llm)
-        self.skills_extractor = make_agent('skills_extractor')
-        self.experience_extractor = make_agent('experience_extractor')
-        self.project_extractor = make_agent('project_extractor')
-        self.education_extractor = make_agent('education_extractor')
-        self.reconversion_detector = make_agent('reconversion_detector')
-        self.language_extractor = make_agent('language_extractor')
-        self.etudiant_detector = make_agent('etudiant_detector')
-        self.identity_extractor = make_agent('identity_extractor')
-    async def split_cv_sections(self, cv_content: str) -> Dict[str, str]:
-        """
-        decoupage du cv en sections
-        """
-        task_config = self.tasks_config['split_cv_task'].copy()
-        task_config['description'] = task_config['description'].format(cv_content=cv_content[:20000])
-        task = Task(
-            config=task_config,
-            agent=self.cv_splitter
         )
         crew = Crew(
             agents=[self.cv_splitter],
             tasks=[task],
             process=Process.sequential,
-            verbose=False
         )
         result = await crew.kickoff_async()
-        parsed = self._parse_json_output(result, default_structure={})
         return parsed
-    async def extract_all_sections(self, sections: Dict[str, str]) -> Dict[str, Any]:
-        """
-        execution des taches en parraléle.
-        """
         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())
         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', '')
-            }),
-            ('etudiant_task', self.etudiant_detector, {
-                'education': sections.get('education', ''),
-                'current_date': datetime.now().strftime("%Y-%m-%d")
-            }),
-            ('identity_task', self.identity_extractor, {
-                'personal_info': sections.get('personal_info', '')
-            })
         ]
-        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)
@@ -116,117 +243,600 @@ class CVAgentOrchestrator:
             else:
                 results_map[key] = result
-        return self._aggregate_results(results_map)
-    def _aggregate_results(self, results_map: Dict[str, Any]) -> Dict[str, Any]:
         def get_parsed(key, default=None):
             if key not in results_map:
                 return default
             return self._parse_json_output(results_map[key], default)
-        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", {})
-        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
-        langues_raw = get_parsed('language_task', {})
         if isinstance(competences, dict):
-            # Deduplicate hard_skills while preserving order
             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()
                 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 [],
             }
         }
     def _is_still_student(self, date_str: str) -> bool:
         if not date_str:
             return False
         date_str = str(date_str).lower().strip()
-        ongoing_keywords = ["present", "présent", "current", "cours", "aujourd'hui", "now"]
         if any(keyword in date_str for keyword in ongoing_keywords):
             return True
         try:
             now = datetime.now()
             end_date = None
-            if len(date_str) == 10 and date_str[4] == '-' and date_str[7] == '-':
-                 end_date = datetime.strptime(date_str, "%Y-%m-%d")
-            elif len(date_str) == 7 and date_str[4] == '-':
-                 end_date = datetime.strptime(date_str, "%Y-%m")
-            elif '/' in date_str:
-                parts = date_str.split('/')
                 if len(parts) == 2:
-                    m, y = parts
                     if len(y) == 4:
-                         end_date = datetime.strptime(date_str, "%m/%Y")
                     elif len(y) == 2:
-                         end_date = datetime.strptime(date_str, "%m/%y")
             elif len(date_str) == 4 and date_str.isdigit():
-                 end_date = datetime.strptime(date_str, "%Y")
-                 end_date = end_date.replace(month=12, day=31)
             if end_date:
                 return end_date >= now
             return False
         except (ValueError, IndexError):
             logger.warning(f"Date parsing failed for: {date_str}")
             return False
     def _parse_json_output(self, crew_output, default_structure=None) -> Any:
-        raw = crew_output.raw if hasattr(crew_output, 'raw') else str(crew_output)
-        if '```json' in raw:
-            raw = raw.split('```json')[1].split('```')[0].strip()
-        elif '```' in raw:
-            parts = raw.split('```')
             if len(parts) >= 3:
                 raw = parts[1].strip()
-        # Clean common LLM artifacts
-        raw = raw.strip().lstrip('\ufeff')  # BOM
-        try:
-            return json.loads(raw)
-        except json.JSONDecodeError:
-            # Try to find the first JSON object or array in the output
-            for start_char, end_char in [('{', '}'), ('[', ']')]:
-                start_idx = raw.find(start_char)
-                end_idx = raw.rfind(end_char)
                 if start_idx != -1 and end_idx > start_idx:
                     try:
-                        return json.loads(raw[start_idx:end_idx + 1])
                     except json.JSONDecodeError:
-                        continue
-            logger.error(f"JSON Parse Error (after cleanup): {raw[:200]}")
-            return default_structure if default_structure is not None else {}

+"""
+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)
+Produit un JSON en 2 parties : informations + recommandations.
+"""
 import json
 import logging
 import os
 import yaml
 import asyncio
 from datetime import datetime
+from typing import Dict, Any, List
 from crewai import Agent, Task, Crew, Process
 from src.config.app_config import get_small_llm, get_big_llm
 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."""
     def __init__(self):
         self.llm = get_small_llm()
         self.big_llm = get_big_llm()
         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)
+        with open(config_path, "r", encoding="utf-8") as f:
             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)."""
+        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
+    # ──────────────────────────────────────────────
     def _create_agents(self):
         def make_agent(name, llm_override=None):
             return Agent(
                 config=self.agents_config[name],
                 llm=llm_override or self.llm,
                 allow_delegation=False,
+                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.skills_extractor = make_agent("skills_extractor")
+        self.experience_extractor = make_agent("experience_extractor")
+        self.project_extractor = make_agent("project_extractor")
+        self.education_extractor = make_agent("education_extractor")
+        self.reconversion_detector = make_agent("reconversion_detector")
+        self.language_extractor = make_agent("language_extractor")
+        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")
+    # ──────────────────────────────────────────────
+    # PHASE 1 : Découpage du CV en sections
+    # ──────────────────────────────────────────────
+    async def split_cv_sections(self, cv_content: str, cv_raw_start: str = "") -> Dict[str, str]:
+        """Découpe le CV en sections via l'agent cv_splitter."""
+        task_config = self.tasks_config["split_cv_task"].copy()
+        # Échapper les accolades dans le contenu CV pour éviter les erreurs de format
+        safe_content = cv_content[:20000].replace("{", "{{").replace("}", "}}")
+        safe_raw = cv_raw_start[:2000].replace("{", "{{").replace("}", "}}")
+        task_config["description"] = task_config["description"].format(
+            cv_content=safe_content,
+            cv_raw_start=safe_raw,
         )
+        task = Task(config=task_config, agent=self.cv_splitter)
         crew = Crew(
             agents=[self.cv_splitter],
             tasks=[task],
             process=Process.sequential,
+            verbose=False,
         )
         result = await crew.kickoff_async()
+        parsed = self._parse_json_output(result, default_structure={})
         return parsed
+    # ──────────────────────────────────────────────
+    # PHASE 2 : Extraction parallèle (8 agents)
+    # ──────────────────────────────────────────────
+    async def extract_all_sections(
+        self, sections: Dict[str, str], cv_raw_start: str = "", file_name: str = ""
+    ) -> Dict[str, Any]:
+        """Exécute les 8 tâches d'extraction en parallèle."""
         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 + "}"
+                    if placeholder in desc:
+                        desc = desc.replace(placeholder, str(v))
+                t_config["description"] = desc
+            except Exception as e:
+                logger.error(f"Unexpected error formatting task '{task_key}': {e}")
             task = Task(config=t_config, agent=agent)
             c = Crew(agents=[agent], tasks=[task], verbose=False)
             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,
+                },
+            ),
+        ]
+        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)
             else:
                 results_map[key] = result
+        return self._aggregate_extraction_results(results_map)
+    # ──────────────────────────────────────────────
+    # PHASE 3 : Analyse & Recommandation (5 agents)
+    # ──────────────────────────────────────────────
+    async def analyze_and_recommend(
+        self,
+        cv_full_text: str,
+        sections: Dict[str, str],
+        extraction: Dict[str, Any],
+        cv_raw_start: str = "",
+    ) -> Dict[str, Any]:
+        """Exécute les 4 tâches d'analyse en 2 étapes optimisées.
+        Étape 3a : header_analyzer seul (rapide, nécessaire pour tous les autres)
+        Étape 3b : 3 agents en parallèle (quality, metier, project)
+        """
+        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", {})
+        # 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]
+        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 "{}"
+        # 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"
+        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())
+        # 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 ---
+        parallel_tasks = [
+            (
+                "cv_quality_task",
+                self.cv_quality_checker,
+                {
+                    "cv_full_text": cv_full_text[:8000],
+                    "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,
+                    "experiences_summary": experiences_summary,
+                    "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
+        return self._aggregate_recommendations(
+            analysis_results,
+            header_data,
+            poste_vise,
+        )
+    # ──────────────────────────────────────────────
+    # 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)."""
         def get_parsed(key, default=None):
             if key not in results_map:
                 return default
             return self._parse_json_output(results_map[key], default)
+        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", {}
+        )
+        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
+        langues_raw = get_parsed("language_task", {})
         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()
+                )
                 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 []
+                ),
             }
         }
+    # ──────────────────────────────────────────────
+    # Agrégation des recommandations (Phase 3)
+    # ──────────────────────────────────────────────
+    def _aggregate_recommendations(
+        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."""
+        def get_parsed(key, default=None):
+            if key not in analysis_results:
+                return default
+            return self._parse_json_output(analysis_results[key], default)
+        metier_data = get_parsed("metier_matching_task", {"postes_recommandes": []})
+        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 ────────────────────────────────────────────
+        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": (
+                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 []
+            ),
+            "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)
+                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",
+        ]
+        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 _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 ""
     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."""
         if not date_str:
             return False
         date_str = str(date_str).lower().strip()
+        ongoing_keywords = [
+            "present", "présent", "current", "cours", "aujourd'hui", "now"
+        ]
         if any(keyword in date_str for keyword in ongoing_keywords):
             return True
         try:
             now = datetime.now()
             end_date = None
+            if len(date_str) == 10 and date_str[4] == "-" and date_str[7] == "-":
+                end_date = datetime.strptime(date_str, "%Y-%m-%d")
+            elif len(date_str) == 7 and date_str[4] == "-":
+                end_date = datetime.strptime(date_str, "%Y-%m")
+            elif "/" in date_str:
+                parts = date_str.split("/")
                 if len(parts) == 2:
+                    _, y = parts
                     if len(y) == 4:
+                        end_date = datetime.strptime(date_str, "%m/%Y")
                     elif len(y) == 2:
+                        end_date = datetime.strptime(date_str, "%m/%y")
             elif len(date_str) == 4 and date_str.isdigit():
+                end_date = datetime.strptime(date_str, "%Y")
+                end_date = end_date.replace(month=12, day=31)
             if end_date:
                 return end_date >= now
             return False
         except (ValueError, IndexError):
             logger.warning(f"Date parsing failed for: {date_str}")
             return False
     def _parse_json_output(self, crew_output, default_structure=None) -> Any:
+        """Parse la sortie JSON d'un agent CrewAI avec nettoyage robuste."""
+        if crew_output is None:
+            return default_structure if default_structure is not None else {}
+        raw = crew_output.raw if hasattr(crew_output, "raw") else str(crew_output)
+        # Extraire le bloc JSON si encapsulé dans des backticks
+        if "```json" in raw:
+            raw = raw.split("```json")[1].split("```")[0].strip()
+        elif "```" in raw:
+            parts = raw.split("```")
             if len(parts) >= 3:
                 raw = parts[1].strip()
+        raw = raw.strip().lstrip("\ufeff")
+        def _try_parse(text: str):
+            """Tente un parse direct puis un parse avec extraction du premier bloc JSON."""
+            try:
+                return json.loads(text)
+            except json.JSONDecodeError:
+                pass
+            for start_char, end_char in [("{", "}"), ("[", "]")]:
+                start_idx = text.find(start_char)
+                end_idx = text.rfind(end_char)
                 if start_idx != -1 and end_idx > start_idx:
                     try:
+                        return json.loads(text[start_idx : end_idx + 1])
                     except json.JSONDecodeError:
+                        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)
+            if result is not None:
+                return result
+        logger.error(f"JSON Parse Error (after cleanup): {raw[:200]}")
+        return default_structure if default_structure is not None else {}

src/services/cv_service.py CHANGED Viewed

@@ -1,14 +1,70 @@
 import logging
 from typing import Dict, Any
-from src.config.app_config import load_pdf
 from src.parser_flow.CV_agent_flow import CVAgentOrchestrator
 logger = logging.getLogger(__name__)
-async def parse_cv(pdf_path: str, user_id: str = None) -> Dict[str, Any]:
     orchestrator = CVAgentOrchestrator()
     cv_text = load_pdf(pdf_path)
-    sections = await orchestrator.split_cv_sections(cv_text)
-    cv_data = await orchestrator.extract_all_sections(sections)
-    return cv_data

+"""
+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)
+"""
 import logging
 from typing import Dict, Any
+from src.config.app_config import load_pdf, load_pdf_first_page_text
 from src.parser_flow.CV_agent_flow import CVAgentOrchestrator
 logger = logging.getLogger(__name__)
+async def parse_cv_enriched(pdf_path: str, file_name: str = "") -> Dict[str, Any]:
+    """
+    Parse un CV avec extraction + analyse complète.
+    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)
+    """
     orchestrator = CVAgentOrchestrator()
+    # Double extraction :
+    # - 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)
+    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
+    )
+    logger.info("Phase 3 : Analyse et recommandation...")
+    recommendations = await orchestrator.analyze_and_recommend(
+        cv_full_text=cv_text,
+        sections=sections,
+        extraction=extraction,
+        cv_raw_start=cv_raw_start,
+    )
+    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