Upload 7 files

main.py

@@ -0,0 +1,70 @@
+import os
+import logging
+import tempfile
+
+from fastapi import FastAPI, UploadFile, File, HTTPException, Query
+from fastapi.concurrency import run_in_threadpool
+from fastapi.middleware.cors import CORSMiddleware
+
+from src.services.cv_service import parse_cv
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="CV Parser API",
+    description="API for parsing CVs.",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_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(...),
+    user_id: str = Query(None, description="ID of the user to link the CV to")
+):
+    """
+    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:
+        result = await run_in_threadpool(parse_cv, tmp_path, user_id)
+    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)) # Use PORT environment variable, default to 8001
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,23 @@
+fastapi
+uvicorn[standard]
+pydantic
+python-multipart
+
+langchain-core
+langchain-community
+langchain-openai
+langchain_groq
+langchain-huggingface
+crewai
+crewai-tools
+sentence_transformers
+torch
+transformers
+sentencepiece
+accelerate
+pypdf
+python-dotenv
+requests
+faiss-cpu
+
+httpx==0.28.1

src/agents/cv_agents.py

@@ -0,0 +1,251 @@
+import json
+import logging
+from typing import Dict, Any, List
+from crewai import Agent, Task, Crew, Process
+
+logger = logging.getLogger(__name__)
+
+class CVAgentOrchestrator:
+    def __init__(self, llm):
+        self.llm = llm
+        self._create_agents()
+    
+    def _create_agents(self):
+        self.section_splitter = Agent(
+            role="Analyseur de Structure de CV",
+            goal="Découper intelligemment un CV en sections thématiques",
+            backstory="Expert en analyse documentaire spécialisé dans la reconnaissance de structures de CV.",
+            verbose=False,
+            llm=self.llm
+        )
+        
+        self.contact_extractor = Agent(
+            role="Extracteur d'informations de contact",
+            goal="Extraire les coordonnées du candidat",
+            backstory="Expert en extraction d'informations de contact avec précision.",
+            verbose=False,
+            llm=self.llm
+        )
+        
+        self.skills_extractor = Agent(
+            role="Extracteur de compétences",
+            goal="Identifier hard skills et soft skills",
+            backstory="Spécialiste en identification de compétences techniques et comportementales.",
+            verbose=False,
+            llm=self.llm
+        )
+        
+        self.experience_extractor = Agent(
+            role="Extracteur d'expériences",
+            goal="Extraire les expériences professionnelles",
+            backstory="Expert en analyse de parcours professionnels.",
+            verbose=False,
+            llm=self.llm
+        )
+        
+        self.project_extractor = Agent(
+            role="Extracteur de projets",
+            goal="Identifier projets professionnels et personnels",
+            backstory="Spécialiste en identification de projets significatifs.",
+            verbose=False,
+            llm=self.llm
+        )
+        
+        self.education_extractor = Agent(
+            role="Extracteur de formations",
+            goal="Extraire formations et diplômes",
+            backstory="Expert en analyse de parcours académiques.",
+            verbose=False,
+            llm=self.llm
+        )
+        
+        self.reconversion_detector = Agent(
+            role="Détecteur de reconversion",
+            goal="Analyser les changements de carrière",
+            backstory="Conseiller d'orientation expert en transitions de carrière.",
+            verbose=False,
+            llm=self.llm
+        )
+        
+        self.profile_builder = Agent(
+            role="Constructeur de profil",
+            goal="Assembler le profil candidat final",
+            backstory="Expert en structuration de données JSON.",
+            verbose=False,
+            llm=self.llm
+        )
+    
+    def split_cv_sections(self, cv_content: str) -> Dict[str, str]:
+        task = Task(
+            description=f"Analyser ce CV et l'organiser en sections: {cv_content}",
+            expected_output="""JSON avec sections: contact, experiences, projects, education, skills, other""",
+            agent=self.section_splitter
+        )
+        
+        crew = Crew(
+            agents=[self.section_splitter],
+            tasks=[task],
+            process=Process.sequential,
+            verbose=False,
+            telemetry=False
+        )
+        
+        result = crew.kickoff()
+        return self._parse_sections_result(result)
+    
+    def extract_all_sections(self, sections: Dict[str, str]) -> Dict[str, Any]:
+        # Créer les tâches avec les sections en input
+        tasks = self._create_extraction_tasks(sections)
+        
+        crew = Crew(
+            agents=[
+                self.contact_extractor,
+                self.skills_extractor,
+                self.experience_extractor,
+                self.project_extractor,
+                self.education_extractor,
+                self.reconversion_detector,
+                self.profile_builder
+            ],
+            tasks=tasks,
+            process=Process.sequential,
+            verbose=True,  # Activer pour debug
+            telemetry=False
+        )
+        
+        # Passer les sections comme inputs
+        inputs = {
+            "contact": sections.get("contact", ""),
+            "experiences": sections.get("experiences", ""),
+            "projects": sections.get("projects", ""),
+            "education": sections.get("education", ""),
+            "skills": sections.get("skills", ""),
+            "other": sections.get("other", "")
+        }
+        
+        logger.info(f"Starting crew with inputs: {list(inputs.keys())}")
+        result = crew.kickoff(inputs=inputs)
+        logger.info(f"Crew completed. Raw result: {result.raw if hasattr(result, 'raw') else str(result)[:200]}...")
+        
+        return self._parse_final_result(result)
+    
+    def _create_extraction_tasks(self, sections: Dict[str, str]) -> List[Task]:
+        contact_task = Task(
+            description=(
+                "Voici la section contact du CV : {contact}\n"
+                "Extraire précisément le nom, email, téléphone et localisation du candidat."
+            ),
+            expected_output='{"nom": "...", "email": "...", "numero_de_telephone": "...", "localisation": "..."}',
+            agent=self.contact_extractor
+        )
+        
+        skills_task = Task(
+            description=(
+                "Voici les sections pertinentes du CV :\n"
+                "Expériences: {experiences}\n"
+                "Projets: {projects}\n"
+                "Compétences: {skills}\n"
+                "Extraire toutes les compétences techniques (hard skills) et comportementales (soft skills) mentionnées."
+            ),
+            expected_output='{"hard_skills": ["compétence1", "compétence2"], "soft_skills": ["compétence1", "compétence2"]}',
+            agent=self.skills_extractor
+        )
+        
+        experience_task = Task(
+            description=(
+                "Voici la section expériences du CV : {experiences}\n"
+                "Extraire toutes les expériences professionnelles avec poste, entreprise, dates et responsabilités."
+            ),
+            expected_output='[{"Poste": "titre", "Entreprise": "nom", "start_date": "date", "end_date": "date", "responsabilités": ["resp1", "resp2"]}]',
+            agent=self.experience_extractor
+        )
+        
+        project_task = Task(
+            description=(
+                "Voici les sections projets et expériences du CV :\n"
+                "Projets: {projects}\n"
+                "Identifier et extraire les projets professionnels et personnels distincts des responsabilités générales."
+            ),
+            expected_output='{"professional": [{"title": "titre", "technologies": ["tech1"], "outcomes": ["résultat1"]}], "personal": []}',
+            agent=self.project_extractor
+        )
+        
+        education_task = Task(
+            description=(
+                "Voici la section formations du CV : {education}\n"
+                "Extraire toutes les formations, diplômes et certifications avec institution et dates."
+            ),
+            expected_output='[{"degree": "diplôme", "institution": "établissement", "start_date": "date", "end_date": "date"}]',
+            agent=self.education_extractor
+        )
+        
+        reconversion_task = Task(
+            description=(
+                "En analysant les expériences extraites précédemment, déterminer si le candidat est en reconversion professionnelle. "
+                "Chercher des changements de secteur, de type de poste ou des transitions significatives."
+            ),
+            expected_output='{"reconversion_analysis": {"is_reconversion": true, "analysis": "Explication détaillée..."}}',
+            agent=self.reconversion_detector,
+            context=[experience_task]
+        )
+        
+        profile_task = Task(
+            description=(
+                "Assembler toutes les informations extraites des tâches précédentes en un profil candidat complet. "
+                "Créer un JSON valide avec une clé 'candidat' contenant toutes les sections."
+            ),
+            expected_output=(
+                '{"candidat": {'
+                '"informations_personnelles": {...}, '
+                '"compétences": {...}, '
+                '"expériences": [...], '
+                '"projets": {...}, '
+                '"formations": [...], '
+                '"reconversion": {...}'
+                '}}'
+            ),
+            agent=self.profile_builder,
+            context=[contact_task, skills_task, experience_task, project_task, education_task, reconversion_task]
+        )
+        
+        return [contact_task, skills_task, experience_task, project_task, education_task, reconversion_task, profile_task]
+    
+    def _parse_sections_result(self, result) -> Dict[str, str]:
+        result_str = result.raw if hasattr(result, 'raw') else str(result)
+        
+        if '```json' in result_str:
+            result_str = result_str.split('```json')[1].split('```')[0].strip()
+        elif '```' in result_str:
+            parts = result_str.split('```')
+            if len(parts) >= 3:
+                result_str = parts[1].strip()
+        
+        parsed = json.loads(result_str)
+        
+        # Assurer que toutes les sections nécessaires existent
+        default_sections = {
+            "contact": "",
+            "experiences": "",
+            "projects": "",
+            "education": "",
+            "skills": "",
+            "other": ""
+        }
+        
+        for key in default_sections:
+            if key not in parsed:
+                parsed[key] = default_sections[key]
+        
+        return parsed
+    
+    def _parse_final_result(self, result) -> Dict[str, Any]:
+        result_str = result.raw if hasattr(result, 'raw') else str(result)
+        
+        if '```json' in result_str:
+            result_str = result_str.split('```json')[1].split('```')[0].strip()
+        elif '```' in result_str:
+            parts = result_str.split('```')
+            if len(parts) >= 3:
+                result_str = parts[1].strip()
+        
+        return json.loads(result_str)

src/agents/scoring_agent.py

@@ -0,0 +1,183 @@
+import json
+import re
+import logging
+from datetime import datetime
+from typing import Dict, List, Any
+
+logger = logging.getLogger(__name__)
+
+class SimpleScoringAgent:
+    
+    def calculate_scores(self, candidat_data: Dict[str, Any]) -> Dict[str, List[Dict[str, Any]]]:
+        if not candidat_data or not isinstance(candidat_data, dict):
+            return {"analyse_competences": []}
+            
+        skills_data = candidat_data.get("compétences", {})
+        skills_list = self._extract_skills_list(skills_data)
+        
+        if not skills_list:
+            return {"analyse_competences": []}
+
+        skill_analysis = []
+        
+        for skill in skills_list:
+            level = self._determine_skill_level(skill, candidat_data)
+            skill_analysis.append({
+                "skill": skill,
+                "level": level
+            })
+        
+        return {"analyse_competences": skill_analysis}
+
+    def _extract_skills_list(self, skills_data: Dict[str, Any]) -> List[str]:
+        """Extrait la liste des compétences"""
+        skills_list = []
+        
+        if isinstance(skills_data, dict):
+            skills_list.extend(skills_data.get("hard_skills", []))
+            skills_list.extend(skills_data.get("soft_skills", []))
+        elif isinstance(skills_data, list):
+            skills_list = [item.get("nom") for item in skills_data if item.get("nom")]
+        
+        return [skill for skill in skills_list if skill and isinstance(skill, str) and skill.strip()]
+
+    def _determine_skill_level(self, skill: str, candidat_data: Dict[str, Any]) -> str:
+        """Détermine le niveau d'une compétence selon des règles simples"""
+        
+        frequency = self._count_skill_mentions(skill, candidat_data)
+        max_duration = self._get_max_duration_for_skill(skill, candidat_data)
+        has_pro_experience = self._has_professional_experience(skill, candidat_data)
+        
+        # Règles simples de classification
+        if has_pro_experience and max_duration >= 3.0:
+            return "expert"
+        elif has_pro_experience and max_duration >= 1.0:
+            return "avance"
+        elif frequency >= 3 or max_duration >= 0.5:
+            return "intermediaire"
+        else:
+            return "debutant"
+
+    def _count_skill_mentions(self, skill: str, candidat_data: Dict[str, Any]) -> int:
+        """Compte le nombre de mentions de la compétence"""
+        skill_lower = skill.lower()
+        total_mentions = 0
+        
+        # Recherche dans toutes les sections
+        all_text = self._get_all_text_content(candidat_data).lower()
+        total_mentions = all_text.count(skill_lower)
+        
+        return total_mentions
+
+    def _get_max_duration_for_skill(self, skill: str, candidat_data: Dict[str, Any]) -> float:
+        """Trouve la durée maximum d'utilisation de la compétence"""
+        skill_lower = skill.lower()
+        max_duration = 0.0
+        
+        experiences_key = "expériences" if "expériences" in candidat_data else "experiences_professionnelles"
+        experiences = candidat_data.get(experiences_key, [])
+        
+        if not isinstance(experiences, list):
+            return 0.0
+        
+        for exp in experiences:
+            if not isinstance(exp, dict):
+                continue
+                
+            exp_text = json.dumps(exp, ensure_ascii=False).lower()
+            
+            if skill_lower in exp_text:
+                duration = self._calculate_experience_duration(exp)
+                max_duration = max(max_duration, duration)
+        
+        return max_duration
+
+    def _has_professional_experience(self, skill: str, candidat_data: Dict[str, Any]) -> bool:
+        """Vérifie si la compétence a été utilisée en contexte professionnel"""
+        skill_lower = skill.lower()
+        
+        experiences_key = "expériences" if "expériences" in candidat_data else "experiences_professionnelles"
+        experiences = candidat_data.get(experiences_key, [])
+        
+        if not isinstance(experiences, list):
+            return False
+        
+        for exp in experiences:
+            if not isinstance(exp, dict):
+                continue
+                
+            exp_text = json.dumps(exp, ensure_ascii=False).lower()
+            if skill_lower in exp_text:
+                return True
+        
+        return False
+
+    def _get_all_text_content(self, candidat_data: Dict[str, Any]) -> str:
+        """Récupère tout le contenu textuel du CV"""
+        all_content = []
+        
+        # Expériences
+        experiences_key = "expériences" if "expériences" in candidat_data else "experiences_professionnelles"
+        for exp in candidat_data.get(experiences_key, []):
+            if isinstance(exp, dict):
+                all_content.append(json.dumps(exp, ensure_ascii=False))
+        
+        # Projets
+        projects = candidat_data.get("projets", {})
+        if isinstance(projects, dict):
+            for project_type in ["professional", "personal"]:
+                for project in projects.get(project_type, []):
+                    if isinstance(project, dict):
+                        all_content.append(json.dumps(project, ensure_ascii=False))
+        
+        # Formations
+        for formation in candidat_data.get("formations", []):
+            if isinstance(formation, dict):
+                all_content.append(json.dumps(formation, ensure_ascii=False))
+        
+        return " ".join(all_content)
+
+    def _calculate_experience_duration(self, exp: Dict[str, Any]) -> float:
+        """Calcule la durée d'une expérience en années"""
+        start_date_str = exp.get("date_debut", exp.get("start_date", ""))
+        end_date_str = exp.get("date_fin", exp.get("end_date", ""))
+        
+        if not isinstance(start_date_str, str):
+            start_date_str = str(start_date_str) if start_date_str else ""
+        if not isinstance(end_date_str, str):
+            end_date_str = str(end_date_str) if end_date_str else ""
+        
+        return self._calculate_duration_in_years(start_date_str, end_date_str)
+
+    def _calculate_duration_in_years(self, start_date_str: str, end_date_str: str) -> float:
+        """Calcule la durée entre deux dates en années"""
+        start_date = self._parse_date(start_date_str)
+        end_date = self._parse_date(end_date_str)
+        
+        if start_date and end_date:
+            if end_date < start_date:
+                return 0.0
+            return (end_date - start_date).days / 365.25
+        
+        return 0.0
+
+    def _parse_date(self, date_str: str) -> datetime:
+        """Parse une date de manière simple"""
+        if not date_str or not isinstance(date_str, str):
+            return None
+            
+        date_str_lower = date_str.lower().strip()
+        if date_str_lower in ["aujourd'hui", "maintenant", "en cours", "current", "présent", "actuellement"]:
+            return datetime.now()
+        
+        # Extraction simple de l'année
+        year_match = re.search(r'\b(20\d{2}|19\d{2})\b', date_str)
+        if year_match:
+            year = int(year_match.group(1))
+            return datetime(year, 1, 1)
+        
+        return None
+
+# Alias pour maintenir la compatibilité
+ScoringAgent = SimpleScoringAgent
+ImprovedScoringAgent = SimpleScoringAgent

src/config.py

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

src/models.py

@@ -0,0 +1,37 @@
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+def load_all_models() -> Dict[str, Any]:
+    models = {
+        "status": False,
+        "deep_learning_analyzer": None,
+        "rag_handler": None,
+        "llm": None
+    }
+    
+    try:
+        from src.core.deep_learning_analyzer import MultiModelInterviewAnalyzer
+        models["deep_learning_analyzer"] = MultiModelInterviewAnalyzer()
+        logger.info("✅ Deep Learning Analyzer chargé")
+    except Exception as e:
+        logger.error(f"❌ Erreur chargement Deep Learning Analyzer: {e}")
+    
+    try:
+        from src.core.rag_handler import get_rag_handler
+        models["rag_handler"] = get_rag_handler()
+        logger.info("✅ RAG Handler chargé")
+    except Exception as e:
+        logger.error(f"❌ Erreur chargement RAG Handler: {e}")
+    
+    try:
+        from src.config import crew_openai
+        models["llm"] = crew_openai()
+        logger.info("✅ LLM chargé")
+    except Exception as e:
+        logger.error(f"❌ Erreur chargement LLM: {e}")
+    
+    models["status"] = all(v is not None for k, v in models.items() if k != "status")
+    
+    return models

src/services/cv_service.py

@@ -0,0 +1,82 @@
+import json
+import logging
+import os
+from datetime import datetime
+from typing import Dict, Any, List
+from src.config import load_pdf
+from src.agents.cv_agents import CVAgentOrchestrator
+from src.agents.scoring_agent import SimpleScoringAgent
+
+logger = logging.getLogger(__name__)
+
+async def parse_cv(pdf_path: str, user_id: str = None) -> Dict[str, Any]:
+    # Initialize orchestrator and scoring agent here or pass them as arguments
+    # For simplicity, initializing them here. In a real app, consider dependency injection.
+    orchestrator = CVAgentOrchestrator(llm=None) # LLM will be passed to agents directly
+    scoring_agent = SimpleScoringAgent()
+
+    cv_text = load_pdf(pdf_path)
+    if not cv_text or not cv_text.strip():
+        return _create_fallback_data()    
+    
+    logger.info(f"CV text loaded: {len(cv_text)} characters")
+    sections = orchestrator.split_cv_sections(cv_text)
+    logger.info(f"Sections extracted: {list(sections.keys())}")
+    cv_data = orchestrator.extract_all_sections(sections)
+    logger.info(f"CV data extracted: {cv_data is not None}")
+    
+    if not cv_data or not cv_data.get("candidat") or not _is_valid_extraction(cv_data):
+        logger.warning("Agent extraction failed or incomplete, using fallback extraction")
+        return _create_fallback_data()
+    
+    logger.info("Calculating skill levels...")
+    scores = scoring_agent.calculate_scores(cv_data["candidat"])
+    if scores and scores.get("analyse_competences"):
+        cv_data["candidat"].update(scores)
+        skills_count = len(scores.get("analyse_competences", []))
+        levels_summary = _get_levels_summary(scores.get("analyse_competences", []))
+        logger.info(f"Skill levels calculated: {skills_count} skills - {levels_summary}")
+    else:
+        logger.warning("No skill levels calculated, adding empty analysis")
+        cv_data["candidat"]["analyse_competences"] = []
+    
+    return cv_data
+
+def _create_fallback_data() -> Dict[str, Any]:
+    return {
+        "candidat": {
+            "informations_personnelles": {
+                "nom": "Données non extraites",
+                "email": "N/A",
+                "numero_de_telephone": "N/A",
+                "localisation": "N/A"
+            },
+            "compétences": {
+                "hard_skills": [],
+                "soft_skills": []
+            },
+            "expériences": [],
+            "projets": [],
+            "formations": [],
+            "reconversion": {
+                "is_reconversion": False,
+                "analysis": "N/A"
+            },
+            "analyse_competences": []
+        }
+    }
+
+def _get_levels_summary(competences: List[Dict[str, Any]]) -> str:
+    levels_count = {}
+    for comp in competences:
+        level = comp.get("level", "unknown")
+        levels_count[level] = levels_count.get(level, 0) + 1
+    return ", ".join([f"{count} {level}" for level, count in levels_count.items()])
+
+def _is_valid_extraction(cv_data: Dict[str, Any]) -> bool:
+    candidat = cv_data.get("candidat", {})
+    has_info = bool(candidat.get("informations_personnelles", {}).get("nom", "").strip())
+    has_skills = bool(candidat.get("compétences", {}).get("hard_skills", []) or 
+                     candidat.get("compétences", {}).get("soft_skills", []))
+    has_experience = bool(candidat.get("expériences", []))
+    return has_info or has_skills or has_experience