Initial commit

.gitignore

@@ -0,0 +1,37 @@
+# Environnement
+.env
+.env.*
+!.env.example
+venv/
+env/
+ENV/
+.venv/
+
+# Python
+__pycache__/
+*.py[cod]
+*.pyc
+*$py.class
+*.so
+.Python
+
+# Tests
+.pytest_cache/
+.coverage
+htmlcov/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# Distribution
+dist/
+build/
+*.egg-info/
+
+# OS
+.DS_Store
+Thumbs.db
+
+nul

main.py

@@ -0,0 +1,92 @@
+import os
+import logging
+import tempfile
+import uuid
+from langtrace_python_sdk import inject_additional_attributes
+
+from fastapi import FastAPI, UploadFile, File, HTTPException
+
+from fastapi.middleware.cors import CORSMiddleware
+
+from src.services.cv_service import parse_cv
+from langtrace_python_sdk import langtrace
+
+langtrace.init(api_key=os.getenv("LANGTRACE_API_KEY"))
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="CV Parser API",
+    description="parsing de CV agentique",
+    version="2.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+ALLOWED_ORIGINS = os.getenv("CORS_ORIGINS", "http://localhost:8000").split(",")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+from pydantic import BaseModel
+
+class HealthCheck(BaseModel):
+    status: str = "ok"
+
+@app.get("/", response_model=HealthCheck, tags=["Status"])
+async def health_check():
+    return HealthCheck()
+
+@app.post("/parse-cv/", tags=["CV Parsing"])
+async def parse_cv_endpoint(
+    file: UploadFile = File(...)
+):
+    """
+    Parses a CV file (PDF) and returns the parsed data.
+    """
+    if file.content_type != "application/pdf":
+        raise HTTPException(status_code=400, detail="PDF file required")
+
+    contents = await file.read()
+
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+        tmp.write(contents)
+        tmp_path = tmp.name
+
+    try:
+        session_id = str(uuid.uuid4())
+        attributes = {
+            "session.id": session_id,
+            "user_id": session_id
+        }
+
+        async def _traced_parse():
+            return await parse_cv(tmp_path)
+
+        result = await inject_additional_attributes(
+            _traced_parse,
+            attributes
+        )
+    except Exception as e:
+        logger.error(f"Error processing CV: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Internal Server Error: {str(e)}")
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+    if not result:
+        raise HTTPException(status_code=500, detail="Failed to extract data from CV.")
+
+    return result
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 8001)) 
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,22 @@
+fastapi
+uvicorn[standard]
+pydantic
+python-multipart
+
+langchain-core
+langchain-community
+langchain-openai
+langchain_groq
+langchain-huggingface
+crewai
+crewai-tools
+accelerate
+pymupdf4llm
+python-dotenv
+requests
+litellm
+
+httpx==0.28.1
+langtrace-python-sdk
+sentence-transformers
+setuptools<70.0.0

src/config/agents.yaml

@@ -0,0 +1,83 @@
+cv_splitter:
+  role: >
+    Expert en Structure Documentaire
+  goal: >
+    Analyser et découper le CV en sections logiques.
+  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: >
+    Analyste de Compétences (Semantic Matcher)
+  goal: >
+    Identifier les compétences techniques et comportementales avec preuves et niveau de maîtrise
+  backstory: >
+    Expert technique capable de distinguer le simple "Name Dropping" de la compétence réelle.
+    Tu cherches des preuves d'utilisation (contexte) pour valider chaque compétence, si une compétence est mentionnée sans contexte indique sans contexte, si une compétence est presente sur projet et experience indique les 2.
+  verbose: false
+
+experience_extractor:
+  role: >
+    Extracteur d'expériences
+  goal: >
+    Extraire les expériences professionnelles
+  backstory: >
+    Expert en analyse de parcours professionnels.
+  verbose: false
+
+project_extractor:
+  role: >
+    Extracteur de projets
+  goal: >
+    Identifier projets professionnels et personnels
+  backstory: >
+    Spécialiste en identification de projets significatifs.
+  verbose: false
+
+education_extractor:
+  role: >
+    Extracteur de formations
+  goal: >
+    Extraire formations et diplômes
+  backstory: >
+    Expert en analyse de parcours académiques.
+  verbose: false
+
+reconversion_detector:
+  role: >
+    Détecteur de reconversion
+  goal: >
+    Detecter les changements de carrière
+  backstory: >
+    Conseiller d'orientation expert en transitions de carrière.
+  verbose: false
+
+etudiant_detector:
+  role: >
+    Détecteur d'étudiant
+  goal: >
+    Detecter les candidats étudiants
+  backstory: >
+    specilisé dans la detection d'etudes en cours.
+  verbose: false
+
+language_extractor:
+  role: >
+    Extracteur de langues
+  goal: >
+    Identifier les langues parlées et leur niveau de maîtrise
+  backstory: >
+    Expert en évaluation linguistique capable d'identifier les langues et compétences linguistiques.
+  verbose: false
+
+identity_extractor:
+  role: >
+    Extracteur d'identité
+  goal: >
+    Extraire les informations d'identité du candidat
+  backstory: >
+    Expert en identification de personnes.
+  verbose: false

src/config/app_config.py

@@ -0,0 +1,51 @@
+
+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,
+        max_tokens=1500,
+        api_key=OPENAI_API_KEY
+    )
+
+def get_fast_llm():
+    """Groq llama-3.1-8b - Le plus RAPIDE."""
+    return ChatGroq(
+        model="groq/llama-3.1-8b-instant",
+        temperature=0.0,
+        max_tokens=1500,
+        groq_api_key=GROQ_API_KEY
+    )
+
+def get_openai_small_llm():
+    """GPT-4o-mini - Fallback."""
+    return ChatOpenAI(
+        model="gpt-4o-mini",
+        temperature=0.0,
+        api_key=OPENAI_API_KEY
+    )

src/config/tasks.yaml

@@ -0,0 +1,145 @@
+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: >
+    Analyse les sections suivantes pour lister les compétences avec leur contexte d'utilisation.
+    Expériences : {experiences}
+    Projets : {projects}
+    academique : {education}
+    Skills Explicit : {skills}
+    
+    RÈGLES DE CLASSIFICATION :
+    1. 'hard_skills' : Outils, langages, technos (ex: Python, SQL, Excel, React, FastAPI, LangChain).
+       IMPORTANT: Inclure TOUTES les technologies mentionnées dans les projets, expériences et académique.
+    2. 'soft_skills' : Qualités humaines (ex: Leadership, Communication, Rigueur).
+    3. NE PAS INVENTER. Si ce n'est pas écrit, ne l'ajoute pas.
+    4. Pour chaque skill, indique si elle est présente dans une expérience, un projet, academique, sans contexte, si elle est presente dans plusieurs section indique le .
+  expected_output: >
+    JSON : {{
+      "hard_skills": ["Python", "SQL", "FastAPI"],
+      "soft_skills": ["Rigueur", "Leadership"],
+      "skills_with_context": [
+        {{"skill": "Python", "context": "projet"}},
+        {{"skill": "FastAPI", "context": "entreprise"}}
+      ]
+    }}
+
+experience_task:
+  description: >
+    Tu es un extracteur de données strict. Analyse ce texte d'expérience :
+    "{experiences}"
+    
+    Pour CHAQUE poste identifié :
+    1. Titre du poste
+    2. Nom de l'entreprise
+    3. Dates (Début - Fin)
+    4. Description (Liste des tâches/responsabilités)
+    
+    RÈGLE : Ne confonds PAS les projets scolaires avec des expériences pro. Les stages et alternances SONT des expériences.
+  expected_output: >
+    Liste JSON : [{{"Poste": "...", "Entreprise": "...", "start_date": "...", "end_date": "...", "responsabilités": ["task 1", "task 2"]}}]
+
+project_task:
+  description: >
+    Analyse ce texte de projets : "{projects}"
+    
+    RÈGLES STRICTES DE STRUCTURE :
+    Chaque projet DOIT avoir exactement ces clés :
+    - "title" : Titre du projet
+    - "technologies" : Liste de strings (Ex: ["Python", "React"])
+    - "outcomes" : Liste de strings décrivant les résultats ou fonctionnalités (Ex: ["Appli déployée", "User base x2"])
+    - "domaine metier" : (exemple un projet en lien avec la recommandation d'emploi est classé comme recrutement/RH)
+    
+    Sépare :
+    - "professional" : Projets réalisés en entreprise (distincts du simple poste).
+    - "personal" : Projets perso, Github, Hackathons, Écoles.
+    
+    Si une liste est vide, renvoie [].
+  expected_output: >
+    JSON : {{
+      "professional": [
+        {{ "title": "Data Jobs", "technologies": ["Python", "API"], "outcomes": ["App crée", "Optimisation X"], "domaine metier": "recrutement/RH" }}
+      ], 
+      "personal": []
+    }}
+
+education_task:
+  description: >
+    Analyse la section education : "{education}"
+    Extrait les diplômes.
+  expected_output: >
+    Liste JSON : [{{"degree": "...", "institution": "...", "start_date": "...", "end_date": "..."}}]
+
+reconversion_task:
+  description: >
+    Analyse les expériences : "{experiences}"
+    Et "{education}"
+    Le candidat est-il en reconversion ? (Changement majeur de domaine récent).
+    indique aussi le contexte (de quelle domaine ou poste vient t'il et quelle est sa réortientation)
+    pour le contexte de reconversion tu dois prendre en compte les experience et les education.
+  expected_output: >
+    JSON : {{"reconversion_analysis": {{"is_reconversion": true/false, "context": "..."}}
+
+etudiant_task:
+  description: >
+    Analyse la section education : "{education}"
+    Nous sommes le {current_date}.
+    Le candidat est-il ACTUELLEMENT étuditant ? 
+    CRITÈRES :
+    1. Regarde les dates de fin des formations.
+    2. Identifie la date de fin de la formation la plus récente.
+    3. Si cette date est FUTURE par rapport à {current_date} ou si c'est écrit "En cours" / "Présent", alors is_etudiant = true.
+    4. Récupère explicitement cette date sous le champ 'latest_education_end_date' (format YYYY-MM-DD ou MM/YYYY ou "Present").
+    5. indique aussi le niveau d'études (ex: bac+2, bac+5) du diplome le plus proche de {current_date}.
+    6. indique la spécialité exemple: ingenieur IA, data analyste, devellopeur frontend, etc.
+  expected_output: >
+    JSON : {{"etudiant_analysis": {{"is_etudiant": true/false, "niveau_etudes": "bac+5", "specialite": "data analyste", "latest_education_end_date": "YYYY-MM-DD"}}}}
+
+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"}}

src/parser_flow/CV_agent_flow.py

@@ -0,0 +1,232 @@
+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)
+
+        results_map = {}
+        for key, result in zip(keys, results_list):
+            if isinstance(result, Exception):
+                logger.error(f"Task '{key}' failed: {result}")
+            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 {}

src/services/cv_service.py

@@ -0,0 +1,14 @@
+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
+