ai_interview

.env.example

@@ -1,18 +0,0 @@
-# ========================
-#     LLM API KEYS
-# ========================
-OPENAI_API_KEY=your_openai_api_key
-LANGTRACE_API_KEY=your_langtrace_api_key
-
-# ========================
-#     REDIS
-# ========================
-REDIS_URL=redis://default:password@redis-host:port/0
-
-# ========================
-#     BACKEND API
-# ========================
-# Development
-BACKEND_API_URL=http://localhost:8000
-# Production (uncomment for deployment)
-# BACKEND_API_URL=https://api.yoursite.com

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

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

Dockerfile

@@ -1,22 +1,44 @@
 FROM python:3.11-slim
 
-RUN useradd -m -u 1000 user
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
+# Variables d'environnement
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    PYTHONPATH=/app
 
-ENV NLTK_DATA="/home/user/nltk_data"
+# Variables pour les modèles ML - utilisation de /tmp (toujours writable)
+ENV HF_HOME=/tmp/cache \
+    TRANSFORMERS_CACHE=/tmp/cache \
+    HF_HUB_CACHE=/tmp/cache/hub \
+    SENTENCE_TRANSFORMERS_HOME=/tmp/cache/sentence_transformers
 
+# Répertoire de travail
 WORKDIR /app
 
-COPY --chown=user ./requirements.txt requirements.txt
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
+# Installer les dépendances système
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
 
-RUN mkdir -p /home/user/nltk_data && \
-    python -m textblob.download_corpora && \
-    python -m nltk.downloader punkt_tab
+# Installer uv
+RUN pip install uv
 
-COPY --chown=user . /app
-RUN chmod +x /app/start.sh
+# Copier et installer les dépendances Python
+COPY requirements.txt .
+RUN uv pip install --system --no-cache -r requirements.txt
 
+# Copier le code source
+COPY . .
+
+# Créer les répertoires de cache dans /tmp (toujours writable)
+RUN mkdir -p /tmp/cache/hub \
+             /tmp/cache/sentence_transformers \
+             /tmp/vector_store && \
+    chmod -R 777 /tmp
+
+# Exposer le port HF Spaces
 EXPOSE 7860
-CMD ["./start.sh"]
+
+# Commande de démarrage
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,25 +1,10 @@
 ---
-title: Interview Agents API
-emoji: 🎤
-colorFrom: blue
-colorTo: purple
+title: Interview Agents Api
+emoji: 🏃
+colorFrom: green
+colorTo: pink
 sdk: docker
-app_file: main.py
 pinned: false
 ---
 
-# Interview Agents API
-
-API de simulation d'entretiens avec agents IA utilisant LangGraph.
-
-## Description
-
-Cette API permet de simuler des entretiens d'embauche avec des agents IA intelligents.
-
-## Configuration
-
-Assurez-vous de configurer vos variables d'environnement dans les Settings du Space Hugging Face.
-
-## Documentation
-
-Une documentation détaillée de l'API (points d'entrée, schémas de données et exemples) est disponible dans le fichier [API_DOCUMENTATION.md](API_DOCUMENTATION.md).
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

documentation/API_DOCUMENTATION.md

@@ -1,126 +0,0 @@
-# Interview Simulation API Documentation
-
-Cette documentation détaille l'utilisation de l'API de simulation d'entretiens, motorisée par LangGraph et FastAPI.
-
-## Introduction
-
-L'**Interview Simulation API** permet de mener des simulations d'entretiens d'embauche réalistes. Elle utilise un système d'agents spécialisés (Icebreaker, Auditeur, Enquêteur, Stratège, Projecteur) pour évaluer un candidat par rapport à une offre d'emploi spécifique.
-
-**Base URL:** `http://localhost:7860` (ou URL de déploiement)  
-**Version:** `1.0.0`
-
-## Configuration & Authentification
-
-L'API utilise des variables d'environnement pour la configuration :
-- `OPENAI_API_KEY`: Requis pour les agents LLM.
-- `LANGTRACE_API_KEY`: Pour l'observabilité (Langtrace).
-- `CORS_ORIGINS`: Liste des origines autorisées (défaut: `*`).
-
-## Endpoints
-
-### 1. Health Check
-Vérifie que l'API est opérationnelle.
-
-- **URL:** `/`
-- **Method:** `GET`
-- **Success Response (200 OK):**
-  ```json
-  {
-    "status": "ok"
-  }
-  ```
-
-### 2. Simulate Interview
-Déclenche ou poursuit une simulation d'entretien.
-
-- **URL:** `/simulate-interview/`
-- **Method:** `POST`
-- **Request Body:**
-  ```json
-  {
-    "user_id": "string",          // ID unique de l'utilisateur
-    "job_offer_id": "string",     // ID de l'offre d'emploi
-    "cv_document": {              // Données extraites du CV
-      "candidat": { ... }         // Voir section "Data Models"
-    },
-    "job_offer": {                // Détails de l'offre
-      "poste": "string",
-      "entreprise": "string",
-      "mission": "string",
-      ...
-    },
-    "messages": [                 // Historique de la conversation (optionnel)
-      {
-        "role": "user",
-        "content": "Bonjour"
-      },
-      ...
-    ],
-    "cheat_metrics": { ... }      // Métriques anti-triche (optionnel)
-  }
-  ```
-
-- **Success Response (200 OK):**
-  ```json
-  {
-    "response": "Texte généré par l'agent IA",
-    "status": "interviewing" | "interview_finished"
-  }
-  ```
-
-- **Error Responses:**
-  - `400 Bad Request`: Payload incomplet ou données invalides.
-  - `500 Internal Server Error`: Erreur lors de l'exécution du graph LangGraph.
-
-## Data Models (Schemas)
-
-### Feedback Output (Output final de l'analyse)
-Une fois l'entretien terminé, un rapport complet est généré (via Celery) suivant cette structure :
-
-- **CandidatFeedback**: Points forts, axes d'amélioration, conseils, score global.
-- **EntrepriseInsights**:
-    - **Dashboard**: Technique, Cognitive, Comportementale (0-100).
-    - **Decision**: RECRUTER, APPROFONDIR ou REJETER.
-    - **Fraud Detection**: Score global d'usage d'IA, mots-clés détectés, alertes (red flags).
-
-## Exemples d'Usage
-
-### Exemple cURL
-```bash
-curl -X POST http://localhost:7860/simulate-interview/ \
-  -H "Content-Type: application/json" \
-  -d '{
-    "user_id": "user_123",
-    "job_offer_id": "job_456",
-    "cv_document": { "candidat": { "first_name": "Jean", "expériences": [] } },
-    "job_offer": { "poste": "Développeur Python", "entreprise": "TechCorp" },
-    "messages": []
-  }'
-```
-
-### Exemple Python (Requests)
-```python
-import requests
-
-url = "http://localhost:7860/simulate-interview/"
-payload = {
-    "user_id": "user_123",
-    "job_offer_id": "job_456",
-    "cv_document": { "candidat": { "first_name": "Jean", "expériences": [] } },
-    "job_offer": { "poste": "Développeur Python", "entreprise": "TechCorp" },
-    "messages": [{"role": "user", "content": "Je suis prêt."}]
-}
-
-response = requests.post(url, json=payload)
-print(response.json())
-```
-
-## Error Handling
-
-Toutes les erreurs renvoient un format JSON standardisé :
-```json
-{
-  "error": "Description de l'erreur"
-}
-```
-

documentation/cv_structure.json

@@ -1,121 +0,0 @@
-{
-    "_id": {
-        "$oid": "69946f80c8bcf8b152b53a6a"
-    },
-    "user_id": "user_...",
-    "parsed_data": {
-        "candidat": {
-            "first_name": "...",
-            "compétences": {
-                "hard_skills": [
-                    "...",
-                    "..."
-                ],
-                "soft_skills": [
-                    "...",
-                    "..."
-                ],
-                "skills_with_context": [
-                    {
-                        "skill": "...",
-                        "context": "entreprise"
-                    },
-                    {
-                        "skill": "...",
-                        "context": "projet"
-                    },
-                    {
-                        "skill": "...",
-                        "context": "academique"
-                    },
-                    {
-                        "skill": "...",
-                        "context": "sans contexte"
-                    }
-                ]
-            },
-            "expériences": [
-                {
-                    "Poste": "...",
-                    "Entreprise": "...",
-                    "start_date": "Déc. 2024",
-                    "end_date": "Déc. 2025",
-                    "responsabilités": [
-                        "..."
-                    ]
-                },
-                {
-                    "Poste": "...",
-                    "Entreprise": "...",
-                    "start_date": "2010",
-                    "end_date": "2023",
-                    "responsabilités": [
-                        "...",
-                        "..."
-                    ]
-                }
-            ],
-            "reconversion": {
-                "is_reconversion": true,
-                "context": "..."
-            },
-            "projets": {
-                "professional": [
-                    {
-                        "title": "...",
-                        "technologies": [
-                            "...",
-                            "..."
-                        ],
-                        "outcomes": [
-                            "...",
-                            "..."
-                        ],
-                        "domaine metier": "..."
-                    },
-                    {
-                        "title": "...",
-                        "technologies": [
-                            "...",
-                            "..."
-                        ],
-                        "outcomes": [
-                            "..."
-                        ],
-                        "domaine metier": "..."
-                    }
-                ],
-                "personal": []
-            },
-            "formations": [
-                {
-                    "degree": "...",
-                    "institution": "...",
-                    "start_date": "Nov. 2024",
-                    "end_date": "Déc. 2025"
-                },
-                {
-                    "degree": "...",
-                    "institution": "...",
-                    "start_date": "Fév. 2024",
-                    "end_date": "Juil. 2024"
-                }
-            ],
-            "etudiant": {
-                "is_etudiant": false,
-                "niveau_etudes": "bac+3",
-                "specialite": "...",
-                "latest_education_end_date": "2025-12-01"
-            },
-            "langues": [
-                {
-                    "langue": "Français"
-                },
-                {
-                    "langue": "Anglais"
-                }
-            ]
-        }
-    },
-    "upload_date": "2026-02-17T13:39:12.984629"
-}

documentation/job_offer_structure.json

@@ -1,15 +0,0 @@
-{
-    "entreprise": "Carrefour",
-    "ville": "Massy",
-    "poste": "Data Scientist Assortiment Personnalisé",
-    "contrat": "Stage",
-    "description_poste": "Nos atouts pour y parvenir ?\n\nUn réseau multi format, multi métiers avec des collaborateurs passionnés, qui s'engagent, pour réussir la transition alimentaire pour tous.\n\nStage Data Scientist - Assortiment Personnalisé (F/H)\n\nL'utilisation de la data et le développement des capacités analytiques sont un axe majeur du plan stratégique du Groupe Carrefour à horizon 2027. Directement rattachée au COMEX France, l'Analytics Factory de Carrefour France est le pilier de cette transformation analytique, au service des clients et de l'ensemble des équipes métier de Carrefour France - Marketing, Marchandises, Exploitation, E-commerce, Supply Chain, Services Financiers, etc...\n\nNous utilisons des approches de machine learning pour résoudre des défis commerciaux et opérationnels comme les ruptures en magasin, la prévision des ventes promotionnelles, l'optimisation de l'assortiment des produits et les recommandations personnalisées sur le site carrefour.fr\n\nVos Missions\n\nAu cours de ces dernières années, l'équipe Assortiment de l'Analytics Factory a développé des solutions robustes pour la gestion de l'assortiment de produits, tant au niveau national pour la gestion des négociations annuelles avec les fournisseurs, qu'au niveau local de façon à décliner de façon optimale l'assortiment de produits proposés par chaque magasin.\n\nCette déclinaison s'opère en termes de nombre de références pour chaque catégorie de produits avec l'objectif de maximiser le chiffre d'affaires des magasins ; elle est réalisée une fois par an.\n\nAujourd'hui, notre réflexion s'oriente vers une personnalisation plus fine de l'assortiment, en cherchant à aligner les préférences clients propres à chaque magasin avec les caractéristiques produits. Nous souhaitons également introduire davantage d'agilité dans la gestion locale de l'offre, en permettant une optimisation continue tout au long de l'année.\n\nLe stage de fin d'études (d'une durée de 4 à 6 mois) que nous proposons consiste à  \nexplorer les modèles de choix discrets, une approche économétrique de la modélisation des choix les plus probables que peuvent faire un ensemble d'individus parmi un nombre fini de possibilités.\n\nCette approche repose sur la définition d'une fonction d'utilité associée à chaque produit, combinant des attributs produits (prix, format, marque, catégorie, etc.) et des variables contextuelles (profil du magasin, saisonnalité, environnement concurrentiel...).\n\nLes paramètres de ces fonctions seront estimés par maximum de vraisemblance,  \npermettant d'interpréter les sensibilités des clients aux différents attributs et d'identifier les leviers de préférence par segment ou par typologie de magasin.\n\nDifférentes spécifications pourront être testées - logit multinomial, nested logit, ou modèles mixtes - afin d'évaluer le compromis entre interprétabilité et performance prédictive.\n\nVous serez intégré·e à une équipe dynamique, innovatrice, aux profils diversifiés et  \ncomplémentaires, fondée sur l'entraide, le partage de connaissances, la prise d'initiatives ; vous serez co-encadré·e par deux data scientists, qui vous guideront tout au long de votre  \nstage.\n\nVotre Profil\n\nÉtudiant en Master 2 Data Science / Intelligence Artificielle / Statistiques, passionné par l'exploitation des données pour la prise de décision et la création de modèles prédictifs. Vous recherchez un stage de fin d'étude de 4 à 6 mois.\n\nÀ l'issue de vos années de formation et à travers vos différents projets, vous avez développé de solides connaissances théoriques et pratiques sur les algorithmes d'apprentissage statistique.\n\nVous aimez aborder de nouveaux défis de machine learning dans différents domaines, lire des publications scientifiques. Et vous appréciez tout autant l'implémentation et l'optimisation des solutions. La qualité et la simplicité du code vous tiennent à coeur.\n\nEnfin, vous appréciez de travailler avec des collaborateurs d'horizons différents, et il est agréable de travailler avec vous au jour le jour !\n\nNotre environnement technique  \nGCP, Python, SQL, BigQuery, dbt, Kubernetes, Terraform, Airflow\n\nVos petits plus  \nAppétence pour l'exploration et l'expérimentation scientifique, rigueur dans les analyses et la modélisation, souci de produire un code optimal tant en termes de performance que de maintenabilité, intérêt pour l'utilisation raisonnée d'un assistant de code.\n\nInformations complémentaires\n\n- Date de début : Mars 2026\n- Durée: 6 mois\n- Localisation: Massy (91) - RER B/RER C Massy-Palaiseau\n- Avantages : 50% du titre de transport pris en charge par Carrefour\n- Autres avantages propres au campus/site : parking, restauration, salle de sport, conciergerie...\n\nChez Carrefour, nous avons à coeur de ne passer à côté d'aucun talent et sommes fiers de compter des équipes représentatives de la société dans son ensemble. Nous encourageons ainsi tous types de profils à postuler à cette offre et garantissons un processus de recrutement dénué de toutes formes de discriminations.",
-    "publication": "23/10/2025",
-    "lien": "https://www.hellowork.com/fr-fr/emplois/71884111.html",
-    "id": "001abed6-0ab6-4a8c-8bf8-bd1dc1d6e862",
-    "description_nettoyee": "Stage de fin d’études (4 à 6 mois) de Data Scientist au sein de l’Analytics Factory de Carrefour France, à Massy (91). Le stagiaire travaillera sur la personnalisation de l’assortiment produit en développant et testant des modèles de choix discrets (logit multinomial, nested logit, modèles mixtes) afin d’estimer les fonctions d’utilité, d’interpréter les sensibilités clients et d’optimiser l’offre magasin tout au long de l’année.",
-    "mission": "- Explorer et implémenter des modèles de choix discrets pour la personnalisation de l’assortiment.\n- Définir les fonctions d’utilité en combinant attributs produits et variables contextuelles.\n- Estimer les paramètres par maximum de vraisemblance et analyser les sensibilités par segment ou typologie de magasin.\n- Tester différentes spécifications (logit multinomial, nested logit, modèles mixtes) et évaluer le compromis interprétabilité/performance.\n- Interpréter les résultats pour identifier les leviers de préférence et proposer des recommandations d’optimisation continue.\n- Collaborer avec deux data scientists et l’équipe Analytics Factory, en partageant connaissances et bonnes pratiques.",
-    "profil_recherche": "- Étudiant(e) en Master 2 Data Science, Intelligence Artificielle ou Statistiques.\n- Solides connaissances théoriques et pratiques des algorithmes d’apprentissage statistique.\n- Intérêt pour le machine learning, la lecture de publications scientifiques et l’expérimentation.\n- Souci de la qualité, de la simplicité et de la maintenabilité du code.\n- Capacité à travailler en équipe avec des profils divers et à prendre des initiatives.",
-    "competences": "- Langages et outils : Python, SQL, GCP, BigQuery, dbt, Kubernetes, Terraform, Airflow.\n- Modélisation : modèles de choix discrets, logit multinomial, nested logit, modèles mixtes, estimation par maximum de vraisemblance.\n- Analyse statistique et machine learning.\n- Rigueur scientifique, expérimentation, optimisation du code.",
-    "pole": "Analytics Factory – pôle d’excellence analytique de Carrefour France, dédié à la transformation data‑driven au service des métiers (marketing, marchandises, e‑commerce, supply chain, etc.)."
-}

knowledge_base/soft_skills_feedback.md

@@ -0,0 +1,87 @@
+# Guide pour le Feedback sur les Soft Skills
+
+Ce guide fournit des observations courantes et des conseils constructifs pour aider les candidats à améliorer leurs soft skills lors des entretiens d'embauche.
+
+## Communication
+
+**Observation** : Le candidat a du mal à structurer ses réponses ou semble décousu.
+
+**Conseil à fournir** : "Pour mieux mettre en valeur votre expérience, essayez de structurer vos réponses avec la méthode STAR (Situation, Tâche, Action, Résultat). Par exemple, lorsque vous parlez d'un projet, commencez par décrire le contexte, puis votre rôle, les actions que vous avez menées, et enfin les résultats que vous avez obtenus. Cela rendra votre discours plus clair et percutant."
+
+**Observation** : Le candidat utilise un langage trop technique ou du jargon.
+
+**Conseil à fournir** : "Votre expertise technique est évidente. Pour vous assurer que tous vos interlocuteurs comprennent bien l'impact de votre travail, pensez à vulgariser certains concepts. Expliquer un projet complexe en des termes simples est une compétence très appréciée. Entraînez-vous à expliquer votre travail à quelqu'un qui n'est pas du même domaine."
+
+**Observation** : Le candidat ne pose pas de questions ou ne montre pas de curiosité.
+
+**Conseil à fournir** : "Un entretien est aussi une opportunité pour vous de poser des questions sur le poste, l'équipe ou la culture d'entreprise. Cela démontre votre intérêt et votre proactivité. Préparez quelques questions en amont pour la fin de l'entretien."
+
+## Esprit d'équipe
+
+**Observation** : Le candidat utilise beaucoup le "je" et mentionne peu ses collaborateurs.
+
+**Conseil à fournir** : "N'hésitez pas à mentionner comment vous avez collaboré avec les autres membres de votre équipe. Parler des succès collectifs et de votre rôle au sein du groupe montre que vous savez travailler en équipe, une qualité essentielle dans la plupart des entreprises. Mettez en avant les synergies et les contributions mutuelles."
+
+**Observation** : Le candidat ne parle pas de situations de conflit ou de désaccord en équipe.
+
+**Conseil à fournir** : "Les désaccords font partie de la vie d'équipe. Expliquer comment vous avez géré une situation de conflit ou de désaccord avec un collègue, et comment vous avez contribué à trouver une solution, peut démontrer votre maturité et vos compétences en résolution de problèmes interpersonnels."
+
+## Proactivité et Prise d'initiative
+
+**Observation** : Le candidat décrit ses tâches de manière passive, sans mentionner de contributions personnelles.
+
+**Conseil à fournir** : "Pensez à des moments où vous avez pris une initiative, même petite. Avez-vous suggéré une amélioration ? Avez-vous identifié un problème avant qu'il ne devienne critique ? Mettre en avant ces situations démontre votre proactivité et votre engagement. Montrez que vous êtes force de proposition."
+
+**Observation** : Le candidat attend d'être sollicité pour agir.
+
+**Conseil à fournir** : "Les recruteurs apprécient les profils qui ne se contentent pas d'exécuter. Décrivez des situations où vous avez anticipé un besoin, proposé une solution avant qu'on ne vous le demande, ou pris des responsabilités supplémentaires. Cela illustre votre autonomie et votre sens des responsabilités."
+
+## Gestion du Stress
+
+**Observation** : Le candidat semble visiblement stressé, ce qui affecte ses réponses.
+
+**Conseil à fournir** : "Il est tout à fait normal de ressentir du stress en entretien. Pour vous aider, n'hésitez pas à prendre une seconde pour respirer avant de répondre. Si une question vous surprend, vous pouvez dire 'C'est une excellente question, laissez-moi un instant pour y réfléchir'. Cela montre que vous prenez le temps de construire une réponse pertinente et que vous gérez la pression."
+
+**Observation** : Le candidat perd ses moyens face à une question inattendue ou difficile.
+
+**Conseil à fournir** : "Face à une question déstabilisante, il est préférable de demander des précisions ou de reformuler la question pour s'assurer de bien la comprendre. Vous pouvez aussi demander un court instant pour organiser vos idées. Cela est perçu positivement et montre votre capacité à gérer l'incertitude."
+
+## Adaptabilité
+
+**Observation** : Le candidat a du mal à parler de changements ou de situations imprévues.
+
+**Conseil à fournir** : "Le monde du travail évolue rapidement. Mettre en avant des situations où vous avez dû vous adapter à de nouvelles technologies, de nouvelles méthodes de travail, ou des changements d'équipe, démontre votre flexibilité. Expliquez comment vous avez géré ces transitions et ce que vous en avez appris."
+
+**Observation** : Le candidat semble rigide dans ses approches ou ses idées.
+
+**Conseil à fournir** : "Montrez que vous êtes ouvert aux nouvelles idées et aux retours. Décrivez une situation où vous avez dû changer d'avis ou modifier votre approche suite à de nouvelles informations ou un feedback. Cela prouve votre capacité à évoluer et à apprendre."
+
+## Pensée Critique / Résolution de Problèmes
+
+**Observation** : Le candidat décrit des problèmes sans détailler sa démarche de résolution.
+
+**Conseil à fournir** : "Lorsque vous parlez d'un problème rencontré, ne vous contentez pas de décrire le problème et la solution. Expliquez votre processus de réflexion : comment avez-vous analysé la situation ? Quelles options avez-vous envisagées ? Pourquoi avez-vous choisi cette solution spécifique ? Quels ont été les résultats ? Cela met en lumière votre pensée critique."
+
+**Observation** : Le candidat ne semble pas analyser les causes profondes des problèmes.
+
+**Conseil à fournir** : "Les recruteurs recherchent des personnes capables d'aller au-delà des symptômes. Lorsque vous décrivez un défi, essayez d'identifier la cause racine du problème et comment votre solution y a remédié durablement. Cela montre une approche plus stratégique."
+
+## Leadership
+
+**Observation** : Le candidat parle de son rôle dans un projet sans mentionner comment il a influencé ou guidé les autres.
+
+**Conseil à fournir** : "Le leadership ne se limite pas à un titre. Pensez à des moments où vous avez inspiré vos collègues, résolu des blocages pour l'équipe, ou pris la responsabilité d'un livrable important. Même sans être manager, vous pouvez démontrer des qualités de leader en montrant comment vous avez contribué à faire avancer le groupe."
+
+**Observation** : Le candidat ne mentionne pas de situations où il a dû prendre des décisions difficiles.
+
+**Conseil à fournir** : "Les leaders sont souvent confrontés à des choix complexes. Décrivez une situation où vous avez dû prendre une décision difficile, expliquez le contexte, les options, votre raisonnement et l'impact de cette décision. Cela met en évidence votre capacité à assumer des responsabilités."
+
+## Gestion du Temps / Organisation
+
+**Observation** : Le candidat semble désorganisé dans ses réponses ou ne mentionne pas de méthodes de travail.
+
+**Conseil à fournir** : "Parlez de la manière dont vous organisez votre travail, gérez vos priorités et respectez les délais. Mentionnez des outils ou des méthodes (ex: to-do lists, gestion de projet agile) que vous utilisez. Cela rassure sur votre capacité à être efficace et autonome."
+
+**Observation** : Le candidat a du mal à gérer plusieurs tâches ou projets simultanément.
+
+**Conseil à fournir** : "Décrivez une situation où vous avez dû jongler avec plusieurs responsabilités. Expliquez comment vous avez priorisé, délégué si possible, et maintenu la qualité de votre travail. Cela démontre votre capacité à gérer la charge de travail et à rester performant sous pression."

main.py

@@ -1,82 +1,270 @@
+import tempfile
+import requests
 import os
 import logging
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.concurrency import run_in_threadpool
 from fastapi.middleware.cors import CORSMiddleware
-from slowapi import Limiter, _rate_limit_exceeded_handler
-from slowapi.util import get_remote_address
-from slowapi.errors import RateLimitExceeded
-from pydantic import BaseModel
-from dotenv import load_dotenv
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
+os.environ['HOME'] = '/tmp'
+# Configuration du logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-load_dotenv()
+# Imports avec gestion d'erreurs robuste
+try:
+    from src.cv_parsing_agents import CvParserAgent, create_fallback_cv_data
+    CV_PARSING_AVAILABLE = True
+    logger.info("✅ CV Parsing disponible")
+except Exception as e:
+    logger.error(f"❌ CV Parsing indisponible: {e}")
+    CV_PARSING_AVAILABLE = False
+    CvParserAgent = None
+    create_fallback_cv_data = None
 
-from src.services.graph_service import GraphInterviewProcessor
+try:
+    from src.interview_simulator.entretient_version_prod import InterviewProcessor
+    INTERVIEW_AVAILABLE = True
+    logger.info("✅ Interview Simulator disponible")
+except Exception as e:
+    logger.error(f"❌ Interview Simulator indisponible: {e}")
+    INTERVIEW_AVAILABLE = False
+    InterviewProcessor = None
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+try:
+    from src.scoring_engine import ContextualScoringEngine
+    SCORING_AVAILABLE = True
+    logger.info("✅ Scoring Engine disponible")
+except Exception as e:
+    logger.error(f"❌ Scoring Engine indisponible: {e}")
+    SCORING_AVAILABLE = False
+    ContextualScoringEngine = None
 
+# Application FastAPI
 app = FastAPI(
-    title="Interview Simulation API",
-    description="API for interview simulations.",
-    version="1.0.0",
+    title="AIrh Interview Assistant",
+    description="API pour l'analyse de CV et la simulation d'entretiens d'embauche",
+    version="1.3.0",
     docs_url="/docs",
-    redoc_url="/redoc",
-    redirect_slashes=True,
+    redoc_url="/redoc"
 )
 
-ALLOWED_ORIGINS = os.getenv("CORS_ORIGINS", "http://localhost:3000,http://localhost:5173,http://localhost:8000").split(",")
-
+# Configuration CORS pour HF Spaces
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=ALLOWED_ORIGINS,
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-limiter = Limiter(key_func=get_remote_address)
-app.state.limiter = limiter
-app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+# Configuration API Celery
+CELERY_API_URL = os.getenv("CELERY_API_URL", "https://celery-7as1.onrender.com")
+
+# Modèles Pydantic
+class InterviewRequest(BaseModel):
+    user_id: str = Field(..., example="user_12345")
+    job_offer_id: str = Field(..., example="job_offer_abcde")
+    cv_document: Dict[str, Any]
+    job_offer: Dict[str, Any]
+    messages: List[Dict[str, Any]]
+    conversation_history: List[Dict[str, Any]]
+
+class AnalysisRequest(BaseModel):
+    conversation_history: List[Dict[str, Any]]
+    job_description_text: str
+    candidate_id: Optional[str] = None
+
+class TaskResponse(BaseModel):
+    task_id: str
+    status: str
+    result: Any = None
+    message: Optional[str] = None
 
 class HealthCheck(BaseModel):
     status: str = "ok"
+    celery_api_status: Optional[str] = None
+    services: Dict[str, bool] = Field(default_factory=dict)
+    message: str = "API AIrh fonctionnelle"
 
+# Endpoints
 @app.get("/", response_model=HealthCheck, tags=["Status"])
 async def health_check():
-    return HealthCheck()
-
-@app.post("/simulate-interview/")
-@limiter.limit("5/minute")
-async def simulate_interview(request: Request):
-    """
-    This endpoint receives the interview data, instantiates the graph processor
-    and starts the conversation.
-    """
+    """Health check de l'API avec test de connectivité Celery."""
+    
+    # Test connexion Celery
+    celery_status = "unknown"
     try:
-        payload = await request.json()
-
-        if not all(k in payload for k in ["user_id", "job_offer_id", "cv_document", "job_offer"]):
-            raise HTTPException(status_code=400, detail="Missing data in payload (user_id, job_offer_id, cv_document, job_offer).")
+        response = requests.get(f"{CELERY_API_URL}/", timeout=5)
+        celery_status = "connected" if response.status_code == 200 else "error"
+    except Exception:
+        celery_status = "disconnected"
+    
+    services = {
+        "cv_parsing": CV_PARSING_AVAILABLE,
+        "interview_simulation": INTERVIEW_AVAILABLE,
+        "scoring_engine": SCORING_AVAILABLE,
+        "celery_api": celery_status == "connected"
+    }
+    
+    return HealthCheck(
+        celery_api_status=celery_status,
+        services=services
+    )
 
-        logger.info(f"Starting simulation for user: {payload['user_id']}")
+@app.post("/parse-cv/", tags=["CV Parsing"])
+async def parse_cv(file: UploadFile = File(...)):
+    """Analyse un CV PDF et extrait les informations structurées."""
+    
+    if not CV_PARSING_AVAILABLE:
+        # Fallback si le parsing n'est pas disponible
+        return create_fallback_cv_data() if create_fallback_cv_data else {
+            "error": "Service de parsing de CV temporairement indisponible",
+            "candidat": {
+                "informations_personnelles": {"nom": "Test User"},
+                "compétences": {"hard_skills": [], "soft_skills": []}
+            }
+        }
+    
+    if file.content_type != "application/pdf":
+        raise HTTPException(status_code=400, detail="Fichier PDF requis")
+    
+    tmp_path = None
+    try:
+        # Sauvegarder le fichier temporairement
+        contents = await file.read()
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+            tmp.write(contents)
+            tmp_path = tmp.name
+        
+        # Traiter le CV
+        cv_agent = CvParserAgent(pdf_path=tmp_path)
+        parsed_data = await run_in_threadpool(cv_agent.process)
+        
+        if not parsed_data and create_fallback_cv_data:
+            parsed_data = create_fallback_cv_data(tmp_path)
+        
+        # Scoring si disponible
+        if SCORING_AVAILABLE and ContextualScoringEngine and parsed_data:
+            try:
+                scoring_engine = ContextualScoringEngine(parsed_data)
+                scored_data = await run_in_threadpool(scoring_engine.calculate_scores)
+                if parsed_data.get("candidat"):
+                    parsed_data["candidat"].update(scored_data)
+            except Exception as e:
+                logger.warning(f"Scoring échoué: {e}")
+        
+        return parsed_data
+        
+    except Exception as e:
+        logger.error(f"Erreur parsing CV: {e}")
+        if create_fallback_cv_data:
+            return create_fallback_cv_data(tmp_path)
+        raise HTTPException(status_code=500, detail=str(e))
+    
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            try:
+                os.remove(tmp_path)
+            except Exception:
+                pass
 
-        processor = GraphInterviewProcessor(payload)
-        result = processor.invoke(payload.get("messages", []), cheat_metrics=payload.get("cheat_metrics"))
+@app.post("/simulate-interview/", tags=["Interview"])
+async def simulate_interview(request: InterviewRequest):
+    """Gère une conversation d'entretien d'embauche."""
+    
+    if not INTERVIEW_AVAILABLE:
+        raise HTTPException(
+            status_code=503, 
+            detail="Service de simulation d'entretien indisponible"
+        )
+    
+    try:
+        processor = InterviewProcessor(
+            cv_document=request.cv_document,
+            job_offer=request.job_offer,
+            conversation_history=request.conversation_history
+        )
+        
+        result = await run_in_threadpool(processor.run, messages=request.messages)
+        return {"response": result["messages"][-1].content}
+        
+    except Exception as e:
+        logger.error(f"Erreur simulation entretien: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-        return JSONResponse(content=result)
+@app.post("/trigger-analysis/", response_model=TaskResponse, status_code=202, tags=["Analysis"])
+async def trigger_analysis(request: AnalysisRequest):
+    """Déclenche une analyse asynchrone via l'API Celery."""
+    
+    try:
+        response = requests.post(
+            f"{CELERY_API_URL}/trigger-analysis",
+            json=request.dict(),
+            headers={"Content-Type": "application/json"},
+            timeout=30
+        )
+        
+        if response.status_code == 202:
+            data = response.json()
+            return TaskResponse(
+                task_id=data["task_id"],
+                status=data["status"],
+                message="Analyse démarrée"
+            )
+        else:
+            raise HTTPException(status_code=503, detail="Service d'analyse indisponible")
+            
+    except requests.RequestException:
+        raise HTTPException(status_code=503, detail="API Celery inaccessible")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
-    except ValueError as ve:
-        logger.error(f"Data validation error: {ve}", exc_info=True)
-        return JSONResponse(content={"error": str(ve)}, status_code=400)
+@app.get("/analysis-status/{task_id}", response_model=TaskResponse, tags=["Analysis"])
+async def get_analysis_status(task_id: str):
+    """Récupère le statut d'une analyse."""
+    
+    try:
+        response = requests.get(f"{CELERY_API_URL}/task-status/{task_id}", timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            return TaskResponse(
+                task_id=task_id,
+                status=data["status"],
+                result=data.get("result"),
+                message=data.get("progress", "Statut récupéré")
+            )
+        else:
+            raise HTTPException(status_code=503, detail="Service d'analyse indisponible")
+            
+    except requests.RequestException:
+        raise HTTPException(status_code=503, detail="API Celery inaccessible")
     except Exception as e:
-        logger.error(f"Internal error in simulate-interview endpoint: {e}", exc_info=True)
-        return JSONResponse(
-            content={"error": "An internal error occurred on the assistant's server."},
-            status_code=500
-        )
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Endpoint de debug pour HF Spaces
+@app.get("/debug", tags=["Debug"])
+async def debug_info():
+    """Informations de debug pour le déploiement."""
+    return {
+        "environment": {
+            "HF_HOME": os.getenv("HF_HOME"),
+            "CELERY_API_URL": CELERY_API_URL,
+            "PYTHONPATH": os.getenv("PYTHONPATH")
+        },
+        "services": {
+            "cv_parsing": CV_PARSING_AVAILABLE,
+            "interview_simulation": INTERVIEW_AVAILABLE,
+            "scoring_engine": SCORING_AVAILABLE
+        },
+        "cache_dirs": {
+            "/tmp/cache": os.path.exists("/tmp/cache"),
+            "/app/cache": os.path.exists("/app/cache")
+        }
+    }
 
 if __name__ == "__main__":
     import uvicorn
-    port = int(os.getenv("PORT", 7860)) 
-    uvicorn.run(app, host="0.0.0.0", port=port)
+    uvicorn.run(app, host="0.0.0.0", port=7860)

prompts/rag_prompt.txt

@@ -0,0 +1,39 @@
+Tu es un assistant RH expert qui aide à l'analyse d'offres d'emploi et à la préparation d'entretiens.
+Ton rôle est de te comporter comme dans un entretien pour un poste.
+
+Tu as accès aux informations suivantes sur le poste actuel :
+    entreprise : {entreprise}
+    poste : {poste}
+    description : {description}
+
+Les informations sur le candidat sont :
+    cv : {cv}
+
+
+Tu as accès au CV d'un candidat appelle-le toujours par son nom et utilise les informations de son CV {cv} pour lui poser des questions
+ou avoir des précisions si nécessaire.
+Identifie clairement experience professionnelle et projet, et ne confond pas les 2.
+Essaye d'evaluer les compétences et skills d'un candidat en fonction de ses projets, si par exemple le candidat a simplement travaillé sur un dashboard
+powerBi ne considére pas cela comme une experience solide.
+À partir des informations de {description}, tu devras élaborer une série de questions pour le candidat.
+Pose exactement les questions une par une.
+Attends la réponse du candidat avant de poser la question suivante.
+
+Commence l'entretien par te présenter avec une formule de politesse.
+Tu devras te présenter avec un nom choisi aléatoirement, présenter l'entreprise et introduire la mission.
+Introduis les besoins de l'entreprise en analysant les informations contenues dans {poste}.
+Évite d'introduire les questions en parlant de 'questions' maintient toujours une conversation le plus naturelle possible.
+Après ta présentation demande toujours dans un premier temps au candidat de se présenter et de présenter son parcours.
+
+Tu dois toujours te mettre dans la situation d'un recruteur et adapter ton langage selon si c'est une femme ou un homme.
+Introduis toujours les informations de {description} comme si tu représentais l'entreprise et tu étais déjà au courant de ces infos.
+N'oublie pas de varier la structure de tes phrases et utilise des expressions comme 'D'accord', 'Je vois', 'C'est intéressant' pour montrer que tu écoutes activement.
+Adopte un ton décontracté et évite le jargon RH trop formel.
+Au lieu de dire 'Pouvez-vous me parler de...', essaye plutôt 'Racontez-moi un peu...' ou 'J'aimerais en savoir plus sur...
+Tu devras poser les questions et communiquer de la manière la plus humaine possible.
+Tu devras adapter l'entretien au profil du candidat.
+
+Quand tu estimes que l'entretien est terminé et que tu as assez d'informations, utilise l'outil `interview_analyser` pour conclure et lancer l'analyse du feedback.
+Termine toujours l'entretien par une phrase de politesse, positive.
+Ne fais pas d'analyse, elle est faite par une équipe d'agents, contente-toi seulement d'occuper ton rôle de recruteur.
+**À la fin de l'entretien, après ta dernière phrase de politesse, conclus toujours par : nous allons maintenant passer a l'analyse **

prompts/rag_prompt_old.txt

@@ -0,0 +1,35 @@
+Tu es un recruteur expert, menant un premier entretien de qualification. Ton ton est professionnel mais engageant. Ta mission est d'évaluer l'adéquation d'un candidat pour un poste.
+
+CONTEXTE DE L'ENTRETIEN
+Tu dois baser ta conversation sur les informations suivantes :
+
+1. Informations à utiliser activement dans la conversation :
+Entreprise : {entreprise}
+Intitulé du poste : {poste}
+Équipe / Pôle : {pole}
+Missions principales : {mission}
+
+2. Informations pour guider tes questions (à ne PAS mentionner directement) :
+Profil recherché : {profil_recherche}
+Compétences clés attendues : {competences}
+(Utilise ces deux points comme une grille d'analyse interne pour formuler des questions pertinentes. Tes questions doivent permettre de vérifier si le candidat possède ces compétences et correspond au profil.)
+3. Informations sur le candidat :
+Les données de son CV sont : {cv}
+
+DIRECTIVES PRÉCISES
+
+1. Déroulement de l'entretien :
+Introduction : Commence par te présenter avec un prénom (ex: Camille, Thomas...). Présente l'entreprise ({entreprise}) et le contexte du recrutement en t'appuyant sur l'intitulé du poste ({poste}) et les missions ({mission}).
+Présentation du candidat : Ta toute première question doit inviter le candidat à se présenter. Par exemple : "Pour commencer, parlez-moi un peu de votre parcours."
+Questions ciblées : En te basant sur les compétences et le profil recherché (que tu gardes en tête), pose des questions ouvertes pour évaluer le candidat. Fais des liens entre ses expériences ({cv}) et les missions du poste ({mission}). Par exemple, si une compétence attendue est "l'analyse de données", demande au candidat de décrire un projet où il a dû analyser un ensemble de données complexe.
+Une question à la fois : Pose une seule question à la fois et attends la réponse complète du candidat avant de poursuivre.
+
+2. Style et Comportement :
+Personnalisation : Appelle toujours le candidat par son nom (présent dans le CV).
+Langage Naturel : Évite le jargon RH. Utilise des formulations fluides comme "J'ai noté dans votre CV que...", "Racontez-moi l'expérience chez...". Montre que tu écoutes avec des relances comme "D'accord, je vois.", "C'est intéressant.".
+Évaluation subtile : Ne dis jamais "la compétence requise est...". À la place, évalue la compétence à travers des questions situationnelles ou comportementales.
+
+3. Conclusion de l'entretien :
+Quand tu estimes avoir assez d'informations, conclus l'échange de manière positive.
+Termine par une phrase de politesse.
+Action finale OBLIGATOIRE : Ta toute dernière phrase, après la politesse, doit être exactement : "nous allons maintenant passer a l'analyse". Juste après, tu dois utiliser l'outil interview_analyser.

requirements.txt

@@ -1,22 +1,25 @@
-langchain
+fastapi
+uvicorn[standard]
+pydantic
+python-multipart
+
+langchain-core
+langchain-community
 langchain-openai
+langchain_groq
+langchain-huggingface
 langgraph
-langchain-core
-pydantic
-fastapi
-uvicorn
-python-dotenv
 crewai
-langtrace-python-sdk
-celery
-redis
-langchain-community
+crewai-tools
+sentence_transformers
+torch
 transformers
-torch --extra-index-url https://download.pytorch.org/whl/cpu
-scikit-learn
-textstat
-chromadb
-sentence-transformers
-numpy
-textblob
-slowapi
+sentencepiece
+accelerate
+pypdf
+python-dotenv
+
+requests
+faiss-cpu
+
+httpx==0.28.1

src/celery_app.py

@@ -1,29 +0,0 @@
-import os
-from celery import Celery
-from dotenv import load_dotenv
-
-load_dotenv()
-
-redis_url = os.getenv("REDIS_URL")
-
-celery_app = Celery(
-    "interview_simulation_api",
-    broker=redis_url,
-    backend=redis_url,
-    include=['src.tasks']
-)
-
-celery_app.conf.update(
-    task_serializer="json",
-    accept_content=["json"],
-    result_serializer="json",
-    timezone="Europe/Paris",
-    enable_utc=True,
-    task_track_started=True,
-    broker_connection_retry_on_startup=True,
-    broker_transport_options={
-        "visibility_timeout": 3600,
-        "socket_timeout": 30,  # Increase socket timeout
-        "socket_connect_timeout": 30
-    }
-)

src/config.py

@@ -1,16 +1,74 @@
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-
-from langchain_openai import ChatOpenAI
-
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-
-def crew_openai():
-    """Returns a ChatOpenAI instance configured for CrewAI feedback analysis."""
-    return ChatOpenAI(
-        model="gpt-4o-mini",
-        temperature=0.1,
-        api_key=OPENAI_API_KEY
-    )
+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/crew/__pycache__/__init__.cpython-312.pycZone.Identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

src/crew/__pycache__/agents.cpython-312.pycZone.Identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

src/crew/__pycache__/analysis_crew.cpython-312.pycZone.Identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

src/crew/__pycache__/crew_pool.cpython-312.pycZone.Identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

src/crew/__pycache__/tasks.cpython-312.pycZone.Identifier

@@ -0,0 +1,2 @@
+[ZoneTransfer]
+ZoneId=3

src/crew/agents.py

@@ -0,0 +1,75 @@
+from crewai import Agent
+from crewai import LLM
+from src.config import crew_openai
+
+LLM_agent = crew_openai()
+
+# Interview Simulation Agents
+report_generator_agent = Agent(
+    role='Rédacteur de Rapports Synthétiques',
+    goal='Générer un feedback pertinent, a partir du deroulement de lentretient',
+    backstory=(
+        "Sepcialisé dans le recrutement et les ressources humaines, capable d'evaluer les candidats"
+        "sur la communication et la pertinences des reponses en fonction des questions posées, redige"
+        "en un rapport clair, un feedback détaillé sur le candidat."
+    ),
+    allow_delegation=False,
+    verbose=False,
+    llm=LLM_agent
+)
+
+# CV Parsing Agents
+skills_extractor_agent = Agent(
+    role="Spécialiste de l'extraction de compétences (hard & soft skills)",
+    goal="Identifier et extraire toutes les compétences pertinentes du CV.",
+    backstory="Vous êtes un spécialiste des compétences techniques et comportementales. Votre mission est de parcourir les CV et de lister de manière exhaustive toutes les compétences mentionnées.",
+    verbose=False,
+    llm=LLM_agent
+)
+experience_extractor_agent = Agent(
+    role="Expert en extraction d'expérience professionnelle",
+    goal="Extraire en détail l'expérience professionnelle du candidat.",
+    backstory="Vous êtes un expert en recrutement spécialisé dans l'analyse des parcours professionnels. Vous devez extraire chaque expérience de manière précise, en notant les rôles, les entreprises, les dates et les responsabilités.",
+    verbose=False,
+    llm=LLM_agent
+)
+project_extractor_agent = Agent(
+    role="Spécialiste de l'identification de projets (pro & perso)",
+    goal="Identifier et décrire les projets significatifs mentionnés.",
+    backstory="Vous êtes passionné par l'innovation et les réalisations. Votre rôle est de repérer et de décrire les projets professionnels et personnels qui mettent en lumière les compétences et l'initiative des candidats.",
+    verbose=False,
+    llm=LLM_agent
+)
+education_extractor_agent = Agent(
+    role="Expert en extraction d'informations sur la formation",
+    goal="Extraire les détails des études et des diplômes obtenus.",
+    backstory="Vous êtes un spécialiste des parcours académiques. Votre tâche est d'extraire avec précision les informations relatives aux études, aux diplômes et aux établissements fréquentés par les candidats.",
+    verbose=False,
+    llm=LLM_agent
+)
+informations_personnelle_agent = Agent(
+    role="Spécialiste de l'extraction des coordonnées",
+    goal="Identifier et extraire précisément les coordonnées du candidat.",
+    backstory="Vous êtes un expert en analyse de CV, particulièrement doué pour localiser et extraire les informations de contact. Votre rôle est de trouver le nom, l'adresse e-mail, le numéro de téléphone et la localisation (ville ou région) du candidat, généralement situés en haut ou à la fin du CV.",
+    verbose=False,
+    llm=LLM_agent
+)
+ProfileBuilderAgent = Agent(
+    role='Constructeur de Profil CV',
+    goal='Créer un profil JSON structuré et valide avec la clé candidat',
+    backstory=(
+        "Tu es un expert en structuration de données JSON. "
+        "Ta mission est de créer un profil candidat parfaitement formaté "
+        "en respectant scrupuleusement la structure JSON demandée."
+    ),
+    verbose=True,
+    llm=LLM_agent
+)
+
+reconversion_detector_agent = Agent(
+    role="Détecteur de Reconversion Professionnelle",
+    goal="Analyser la chronologie des expériences pour identifier les changements de carrière significatifs.",
+    backstory="Vous êtes un conseiller d'orientation expert, capable de repérer les transitions de carrière, d'identifier les compétences transférables et de valoriser les parcours non linéaires. Votre analyse doit mettre en lumière les changements de secteur, de type de poste ou de niveau de responsabilité.",
+    verbose=False,
+    llm=LLM_agent
+)

src/crew/crew_pool.py

@@ -0,0 +1,81 @@
+from crewai import Crew, Process
+from langchain_core.tools import tool
+import json
+from pydantic import BaseModel, Field
+from typing import Dict, List, Any, Type
+from .agents import report_generator_agent, skills_extractor_agent, experience_extractor_agent, project_extractor_agent, education_extractor_agent, ProfileBuilderAgent, informations_personnelle_agent, reconversion_detector_agent
+from .tasks import generate_report_task, task_extract_skills, task_extract_experience, task_extract_projects, task_extract_education, task_build_profile, task_extract_informations, task_detect_reconversion
+from src.deep_learning_analyzer import MultiModelInterviewAnalyzer
+from src.rag_handler import RAGHandler 
+from langchain_core.tools import BaseTool
+
+@tool
+def interview_analyser(conversation_history: list, job_description_text: list) -> str:
+    """
+    Appelle cet outil à la toute fin d'un entretien d'embauche pour analyser
+    l'intégralité de la conversation et générer un rapport de feedback.
+    Ne l'utilise PAS pour répondre à une question normale, mais seulement pour conclure et analyser l'entretien.
+    """
+    # 1. Analyse DL de la conversation
+    analyzer = MultiModelInterviewAnalyzer()
+    structured_analysis = analyzer.run_full_analysis(conversation_history, job_description_text)
+
+    # 2. Enrichissement avec RAG
+    rag_handler = RAGHandler()
+    rag_feedback = []
+    # Extraire les intentions et sentiments pour trouver des conseils pertinents
+    if structured_analysis.get("intent_analysis"):
+        for intent in structured_analysis["intent_analysis"]:
+            # Exemple de requête basée sur l'intention
+            query = f"Conseils pour un candidat qui cherche à {intent['labels'][0]}"
+            rag_feedback.extend(rag_handler.get_relevant_feedback(query))
+    
+    if structured_analysis.get("sentiment_analysis"):
+        for sentiment_group in structured_analysis["sentiment_analysis"]:
+            for sentiment in sentiment_group:
+                if sentiment['label'] == 'stress' and sentiment['score'].item() > 0.6:
+                    rag_feedback.extend(rag_handler.get_relevant_feedback("gestion du stress en entretien"))
+    unique_feedback = list(set(rag_feedback))
+    interview_crew = Crew(
+        agents=[report_generator_agent],
+        tasks=[generate_report_task],
+        process=Process.sequential,
+        verbose=False,
+        telemetry=False
+    )
+
+    final_report = interview_crew.kickoff(inputs={
+        'structured_analysis_data': json.dumps(structured_analysis, indent=2),
+        'rag_contextual_feedback': "\n".join(unique_feedback)
+    })
+    return final_report
+
+def analyse_cv(cv_content: str) -> json:
+    crew = Crew(
+        agents=[            
+            informations_personnelle_agent,
+            skills_extractor_agent,
+            experience_extractor_agent,
+            project_extractor_agent,
+            education_extractor_agent,
+            reconversion_detector_agent,
+
+            ProfileBuilderAgent       
+        ],
+        tasks=[
+            task_extract_informations,
+            task_extract_skills,
+            task_extract_experience,
+            task_extract_projects,
+            task_extract_education,
+            task_detect_reconversion,
+            task_build_profile     
+        ],
+        process=Process.sequential,
+        verbose=False,
+        telemetry=False
+    )
+    result = crew.kickoff(inputs={"cv_content": cv_content})
+    return result
+ 
+    

src/crew/tasks.py

@@ -0,0 +1,184 @@
+from crewai import Task
+from .agents import report_generator_agent, skills_extractor_agent, experience_extractor_agent, project_extractor_agent, education_extractor_agent, ProfileBuilderAgent, informations_personnelle_agent, reconversion_detector_agent
+
+generate_report_task = Task(
+    description=(
+        """Tu es un rédacteur expert en RH. Ta mission est de rédiger un rapport d'évaluation final.
+        Tu dois utiliser deux sources d'information principales :
+        1. Les données d'analyse structurées de l'entretien : '{structured_analysis_data}'.
+        2. Une liste de conseils et de feedback pertinents issus de notre base de connaissances : '{rag_contextual_feedback}'.
+
+        Ta tâche est de synthétiser ces informations en un rapport cohérent et actionnable."""
+    ),
+    expected_output=(
+        """Un rapport final exceptionnel basé sur l'analyse fournie. Le rapport doit être structuré comme suit:
+        1. **Résumé et Score d'Adéquation** : Synthétise le score de similarité sémantique et donne un aperçu global.
+        2. **Analyse Comportementale** : Interprète les résultats de l'analyse de sentiment et d'intention pour décrire le comportement du candidat.
+        3. **Adéquation Sémantique avec le Poste** : Explique ce que signifie le score de similarité.
+        4. **Points Forts & Axes d'Amélioration Personnalisés** : Utilise les données d'analyse pour identifier les points à améliorer. Ensuite, intègre de manière fluide et naturelle les conseils pertinents de '{rag_contextual_feedback}' pour proposer des pistes d'amélioration concrètes et personnalisées. Ne te contente pas de copier-coller le feedback, mais reformule-le pour qu'il s'intègre parfaitement au rapport.
+        5. **Recommandation Finale**."""
+    ),
+    agent=report_generator_agent,
+)
+
+task_extract_skills = Task(
+    description=(
+        "Voici le contenu du CV :\n\n{cv_content}\n\n"
+        "Extraire uniquement les compétences mentionnées explicitement dans le texte du CV. "
+        "Séparer les hard skills (techniques) et les soft skills (comportementales) en analysant les listes ou phrases les contenant. "
+        "Les hards skills doivent comprendre des compétences techniques, outils, langages de programmation, etc. "
+        "Ne rien inventer. Ne pas déduire de compétences à partir d'un poste ou d'une expérience implicite. "
+        "Identifie clairement les compétences, et n'en exclue aucune. "
+        "\n\n**CONTRAINTES JSON STRICTES:**\n"
+        "- Utiliser UNIQUEMENT des guillemets doubles (\") pour les chaînes\n"
+        "- Aucune virgule finale dans les listes ou objets\n"
+        "- Vérifier la syntaxe JSON avant de retourner le résultat\n"
+        "- Échapper correctement les caractères spéciaux (\\, \", \\n, etc.)"
+    ),
+    agent=skills_extractor_agent,
+    input_keys=["cv_content"],
+    expected_output=(
+        "Un dictionnaire JSON VALIDE 'Compétences' avec deux clés : 'hard_skills' et 'soft_skills', "
+        "contenant uniquement des listes de compétences présentes dans le texte. "
+        "FORMAT EXACT: {\"hard_skills\": [\"compétence1\", \"compétence2\"], \"soft_skills\": [\"compétence1\", \"compétence2\"]}"
+    )
+)
+
+task_extract_experience = Task(
+    description=(
+        "Voici le contenu du CV :\n\n{cv_content}\n\n"
+        """
+        Extrais toutes les expériences professionnelles du CV. Pour chaque expérience, tu DOIS fournir les informations suivantes :
+        - Poste: Le titre du poste.
+        - Entreprise: Le nom de l'entreprise.
+        - start_date: La date de début. Si non trouvée, retourne "Non spécifié".
+        - end_date: La date de fin. Si le poste est actuel, utilise "Aujourd'hui". Si non trouvée, retourne "Non spécifié".
+        - responsabilités: Une liste des tâches et missions.
+
+        RÈGLES STRICTES :
+        1.  NE JAMAIS laisser un champ vide (""). Si une information est introuvable, utilise la valeur "Non spécifié".
+        2.  Analyse attentivement les dates. "Depuis 2023" signifie que la date de fin est "Aujourd'hui".
+        """
+    ),
+    agent=experience_extractor_agent,
+    input_keys=["cv_content"],
+    expected_output=(
+        "Un tableau JSON VALIDE d'objets 'Expérience Professionnelle' avec 5 clés par expérience : "
+        "'Poste', 'Entreprise', 'start_date', 'end_date', 'responsabilités'. "
+        "FORMAT EXACT: [{\"Poste\": \"titre\", \"Entreprise\": \"nom\", \"start_date\": \"année\", \"end_date\": \"année\", \"responsabilités\": [\"resp1\", \"resp2\"]}]"
+    )
+)
+
+task_extract_projects = Task(
+    description=(
+        "Voici le contenu du CV :\n\n{cv_content}\n\n"
+        """
+        Identifie et extrais les PROJETS SPÉCIFIQUES mentionnés dans le CV.
+        Un projet est distinct d'une expérience professionnelle générale. Il a un nom ou un objectif clair.
+
+        RÈGLES STRICTES :
+        1.  NE PAS extraire les responsabilités générales d'un poste en tant que projet. Par exemple, si le CV dit "Alternant chez Enedis où j'ai mené le projet 'Simulateur IA'", alors extrais 'Simulateur IA' comme projet. Ne copie pas toutes les tâches de l'alternance.
+        2.  Si un projet est clairement lié à une expérience professionnelle, essaie de le noter, mais le plus important est de décrire le projet lui-même.
+        """
+    ),
+    agent=project_extractor_agent,
+    input_keys=["cv_content"],
+    expected_output=(
+        "Un dictionnaire JSON VALIDE 'Projets' avec deux clés : 'professional' et 'personal'. "
+        "Chaque clé contient une liste de dictionnaires, chaque dictionnaire représentant un projet avec les clés 'title', 'role', 'technologies', et 'outcomes'. "
+        "FORMAT EXACT: {\"professional\": [{\"title\": \"titre\", \"role\": \"rôle\", \"technologies\": [\"tech1\"], \"outcomes\": [\"résultat1\"]}], \"personal\": []}"
+    )
+)
+
+task_extract_education = Task(
+    description=(
+        "Voici le contenu du CV :\n\n{cv_content}\n\n"
+        """
+        Extrais le parcours de formation et les certifications. Fais une distinction claire entre les types de formation.
+        Pour chaque élément, fournis :
+        - degree: Le nom du diplôme, du titre (ex: 'Titre RNCP niveau 6') ou de la certification (ex: 'Core Designer Certification').
+        - institution: L'école, l'université ou la plateforme (ex: 'WILD CODE SCHOOL', 'DataIku', 'DataCamp').
+        - start_date: La date de début. Si non trouvée, retourne "Non spécifié".
+        - end_date: La date de fin. Si non trouvée, retourne "Non spécifié".
+
+        RÈGLES STRICTES :
+        1.  Si tu vois une certification comme "DataIku (core designer)", le diplôme est "Core Designer" et l'institution est "DataIku". NE PAS les mélanger.
+        2.  NE PAS extraire une simple compétence (ex: 'Python') comme une formation.
+        """
+    ),
+    agent=education_extractor_agent,
+    input_keys=["cv_content"],
+    expected_output=(
+        "Un tableau JSON VALIDE d'objets 'Formation' avec les clés : 'degree', 'institution', 'start_date', 'end_date'. "
+        "FORMAT EXACT: [{\"degree\": \"diplôme\", \"institution\": \"établissement\", \"start_date\": \"année\", \"end_date\": \"année\"]}"
+    )
+)
+
+task_extract_informations = Task(
+    description=(
+        "Voici le contenu du CV :\n\n{cv_content}\n\n"
+        "Votre tâche est d'extraire les informations de contact du candidat. Ces informations se trouvent généralement au début ou à la fin du CV, souvent sous une section intitulée 'CONTACT'.\n"
+        "Extrayez précisément :\n"
+        "- Le **Nom complet**.\n"
+        "- L'**Adresse e-mail**.\n"
+        "- Le **Numéro de téléphone**.\n"
+        "- La **Localisation** (ville ou région).\n"
+        "toutes les informations devront être normalisées, principalement le nom si il est en majuscule en titre. "
+    ),
+    agent=informations_personnelle_agent,
+    input_keys=["cv_content"],
+    expected_output=(
+        "Un dictionnaire JSON VALIDE 'informations_personnelles' contenant le nom, l'email, le numéro de téléphone et la localisation du candidat. "
+        "FORMAT EXACT: {\"nom\": \"nom\", \"email\": \"email\", \"numero_de_telephone\": \"tel\", \"localisation\": \"lieu\"}"
+    )
+)
+
+task_detect_reconversion = Task(
+    description=(
+        "En te basant sur les données extraites de la tâche `task_extract_experience`, analyse la chronologie des expériences professionnelles. "
+        "Ton objectif est de déterminer si le candidat est en reconversion professionnelle. "
+        "Cherche des changements de secteur d'activité (ex: de la restauration à la tech), des changements de type de poste (ex: de commercial à développeur), ou des sauts de carrière importants. "
+        "Si une reconversion est détectée, identifie les compétences qui semblent avoir été transférées."
+    ),
+    agent=reconversion_detector_agent,
+    context=[task_extract_experience],
+    expected_output=(
+        "Un dictionnaire JSON VALIDE avec une clé 'reconversion_analysis'. "
+        "Ce dictionnaire doit contenir deux clés : 'is_reconversion' (un booléen) et 'analysis' (une chaîne de caractères expliquant pourquoi, ou pourquoi pas, et listant les compétences transférables si applicable). "
+        "FORMAT EXACT: {\"reconversion_analysis\": {\"is_reconversion\": true, \"analysis\": \"Le candidat a changé de secteur...\"}}"
+    )
+)
+
+task_build_profile = Task(
+    description=(
+        "Ta mission est d'agir comme un architecte de données. En utilisant les extractions des tâches précédentes, "
+        "assemble un profil de candidat complet. "
+        "Le résultat final doit être un unique objet JSON, parfaitement valide."
+    ),
+    agent=ProfileBuilderAgent,
+    context=[
+        task_extract_informations,
+        task_extract_skills,
+        task_extract_experience,
+        task_extract_projects,
+        task_extract_education,
+        task_detect_reconversion
+    ],
+    expected_output=(
+        "Retourner un unique objet JSON valide. Cet objet doit avoir une seule clé à la racine : 'candidat'. "
+        "La valeur de cette clé sera un autre objet contenant toutes les informations assemblées. "
+        "Assure-toi que la syntaxe est parfaite, que tous les guillemets sont des guillemets doubles et qu'il n'y a aucune virgule finale. "
+        "Le JSON doit être immédiatement parsable par un programme.\n\n"
+        "FORMAT EXACT:\n"
+        "{\n"
+        "    \"candidat\": {\n"
+        "        \"informations_personnelles\": {\"nom\": \"...\", \"email\": \"...\", ...},\n"
+        "        \"compétences\": {\"hard_skills\": [...], \"soft_skills\": [...]},\n"
+        "        \"expériences\": [{\"Poste\": \"...\", ...}],\n"
+        "        \"projets\": {\"professional\": [...], \"personal\": [...]},\n"
+        "        \"formations\": [{\"degree\": \"...\", ...}],\n"
+        "        \"reconversion\": {\"is_reconversion\": true, \"analysis\": \"...\"}\n"
+        "    }\n"
+        "}"
+    )
+)

src/cv_parsing_agents.py

@@ -0,0 +1,291 @@
+"""
+Module pour le parsing de CV avec CrewAI
+"""
+import os
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Gestion des imports avec fallback
+try:
+    from src.crew.crew_pool import analyse_cv
+    CREW_POOL_AVAILABLE = True
+    logger.info("✅ crew_pool importé avec succès")
+except ImportError as e:
+    logger.error(f"❌ Erreur import crew_pool: {e}")
+    CREW_POOL_AVAILABLE = False
+    analyse_cv = None
+
+try:
+    from src.config import load_pdf
+    CONFIG_AVAILABLE = True
+    logger.info("✅ config importé avec succès")
+except ImportError as e:
+    logger.error(f"❌ Erreur import config: {e}")
+    CONFIG_AVAILABLE = False
+    load_pdf = None
+
+def clean_dict_keys(data):
+    """
+    Nettoie les clés d'un dictionnaire en les convertissant en string.
+    
+    Args:
+        data: Données à nettoyer (dict, list, ou autre)
+        
+    Returns:
+        Données nettoyées avec des clés string
+    """
+    if isinstance(data, dict):
+        return {str(key): clean_dict_keys(value) for key, value in data.items()}
+    elif isinstance(data, list):
+        return [clean_dict_keys(element) for element in data]
+    else:
+        return data
+
+class CvParserAgent:
+    """
+    Agent de parsing de CV utilisant CrewAI.
+    
+    Cette classe traite un fichier PDF de CV et en extrait les informations
+    structurées (compétences, expériences, formations, etc.)
+    """
+    
+    def __init__(self, pdf_path: str):
+        """
+        Initialise l'agent de parsing de CV.
+        
+        Args:
+            pdf_path (str): Chemin vers le fichier PDF à traiter
+            
+        Raises:
+            ValueError: Si le chemin du fichier est invalide
+            ImportError: Si les dépendances nécessaires ne sont pas disponibles
+        """
+        if not pdf_path or not isinstance(pdf_path, str):
+            raise ValueError("Le chemin du fichier PDF doit être une chaîne non vide")
+            
+        self.pdf_path = pdf_path
+        
+        # Vérifier que les dépendances sont disponibles
+        if not CREW_POOL_AVAILABLE:
+            logger.warning("CrewAI crew_pool non disponible - mode dégradé")
+        if not CONFIG_AVAILABLE:
+            logger.warning("Module config non disponible - mode dégradé")
+
+    def process(self) -> dict:
+        """
+        Traite le fichier PDF pour en extraire le contenu sous forme de JSON.
+        
+        Returns:
+            dict: Dictionnaire contenant les données extraites du CV, 
+                  ou données de fallback en cas d'erreur
+        """
+        logger.info(f"Début du traitement du CV : {self.pdf_path}")
+        
+        # Vérifier que le fichier existe
+        if not os.path.exists(self.pdf_path):
+            logger.error(f"Fichier PDF non trouvé: {self.pdf_path}")
+            return self._create_fallback_data()
+        
+        # Vérifier les dépendances
+        if not CREW_POOL_AVAILABLE or not CONFIG_AVAILABLE:
+            logger.error("Dépendances manquantes pour le traitement complet")
+            return self._create_fallback_data()
+        
+        try:
+            # Charger le contenu du PDF
+            cv_text_content = load_pdf(self.pdf_path)
+            if not cv_text_content or not cv_text_content.strip():
+                logger.error("Le PDF semble vide ou illisible")
+                return self._create_fallback_data()
+            
+            logger.info(f"PDF chargé, {len(cv_text_content)} caractères extraits")
+            
+            # Analyser avec CrewAI
+            crew_output = analyse_cv(cv_text_content)
+
+            if not crew_output or not hasattr(crew_output, 'raw') or not crew_output.raw.strip():
+                logger.error("L'analyse par le crew n'a pas retourné de résultat.")
+                return self._create_fallback_data()
+                
+            raw_string = crew_output.raw
+            logger.info(f"Résultat brut du crew: {raw_string[:200]}...")
+            
+            # Nettoyer le JSON si nécessaire
+            json_string_cleaned = self._clean_json_string(raw_string)
+            
+            # Parser le JSON
+            profile_data = json.loads(json_string_cleaned)
+            logger.info("Parsing JSON réussi")
+            
+            return clean_dict_keys(profile_data)
+
+        except json.JSONDecodeError as e:
+            logger.error(f"Erreur de décodage JSON : {e}")
+            if 'crew_output' in locals():
+                logger.error(f"Données brutes reçues : {crew_output.raw}")
+            return self._create_fallback_data()
+            
+        except Exception as e:
+            logger.error(f"Erreur inattendue dans CvParserAgent : {e}", exc_info=True)
+            return self._create_fallback_data()
+
+    def _clean_json_string(self, raw_string: str) -> str:
+        """
+        Nettoie une chaîne JSON brute en supprimant les blocs de code markdown.
+        
+        Args:
+            raw_string (str): Chaîne brute à nettoyer
+            
+        Returns:
+            str: Chaîne JSON nettoyée
+        """
+        json_string_cleaned = raw_string.strip()
+        
+        # Supprimer les blocs de code markdown si présents
+        if '```' in raw_string:
+            try:
+                # Chercher le bloc json
+                if '```json' in raw_string:
+                    json_part = raw_string.split('```json')[1].split('```')[0]
+                    json_string_cleaned = json_part.strip()
+                else:
+                    # Prendre le premier bloc de code
+                    parts = raw_string.split('```')
+                    if len(parts) >= 3:
+                        json_string_cleaned = parts[1].strip()
+            except IndexError:
+                logger.warning("Format de code block détecté mais mal formé")
+        
+        return json_string_cleaned
+
+    def _create_fallback_data(self) -> dict:
+        """
+        Crée des données de CV de fallback en cas d'erreur de traitement.
+        
+        Returns:
+            dict: Structure de données de CV par défaut
+        """
+        logger.info("Création de données de fallback pour le CV")
+        return {
+            "candidat": {
+                "informations_personnelles": {
+                    "nom": "Candidat Test",
+                    "email": "test@example.com",
+                    "numero_de_telephone": "Non spécifié",
+                    "localisation": "Non spécifiée"
+                },
+                "compétences": {
+                    "hard_skills": ["Python", "FastAPI", "Data Analysis"],
+                    "soft_skills": ["Communication", "Travail d'équipe", "Adaptabilité"]
+                },
+                "expériences": [
+                    {
+                        "Poste": "Développeur",
+                        "Entreprise": "Entreprise Test",
+                        "start_date": "2022",
+                        "end_date": "Aujourd'hui",
+                        "responsabilités": ["Développement d'applications", "Maintenance du code"]
+                    }
+                ],
+                "projets": {
+                    "professional": [
+                        {
+                            "title": "Projet Test",
+                            "role": "Développeur principal",
+                            "technologies": ["Python", "FastAPI"],
+                            "outcomes": ["Application fonctionnelle"]
+                        }
+                    ],
+                    "personal": []
+                },
+                "formations": [
+                    {
+                        "degree": "Formation en Informatique",
+                        "institution": "École Test",
+                        "start_date": "2020",
+                        "end_date": "2022"
+                    }
+                ],
+                "reconversion": {
+                    "is_reconversion": False,
+                    "analysis": "Pas de reconversion détectée - données de test"
+                }
+            }
+        }
+
+# Fonction utilitaire pour créer des données de fallback
+def create_fallback_cv_data(pdf_path: str = None) -> dict:
+    """
+    Fonction utilitaire pour créer des données de CV de fallback.
+    
+    Args:
+        pdf_path (str, optional): Chemin du fichier PDF (non utilisé dans le fallback)
+        
+    Returns:
+        dict: Structure de données de CV par défaut
+    """
+    return {
+        "candidat": {
+            "informations_personnelles": {
+                "nom": "Candidat Test",
+                "email": "test@example.com",
+                "numero_de_telephone": "Non spécifié",
+                "localisation": "Non spécifiée"
+            },
+            "compétences": {
+                "hard_skills": ["Python", "FastAPI", "Data Analysis"],
+                "soft_skills": ["Communication", "Travail d'équipe", "Adaptabilité"]
+            },
+            "expériences": [
+                {
+                    "Poste": "Développeur",
+                    "Entreprise": "Entreprise Test",
+                    "start_date": "2022",
+                    "end_date": "Aujourd'hui",
+                    "responsabilités": ["Développement d'applications", "Maintenance du code"]
+                }
+            ],
+            "projets": {
+                "professional": [
+                    {
+                        "title": "Projet Test",
+                        "role": "Développeur principal",
+                        "technologies": ["Python", "FastAPI"],
+                        "outcomes": ["Application fonctionnelle"]
+                    }
+                ],
+                "personal": []
+            },
+            "formations": [
+                {
+                    "degree": "Formation en Informatique",
+                    "institution": "École Test",
+                    "start_date": "2020",
+                    "end_date": "2022"
+                }
+            ],
+            "reconversion": {
+                "is_reconversion": False,
+                "analysis": "Pas de reconversion détectée - données de test"
+            }
+        }
+    }
+
+# Test des imports au chargement du module
+if __name__ == "__main__":
+    logger.info("Test du module cv_parsing_agents")
+    logger.info(f"CREW_POOL_AVAILABLE: {CREW_POOL_AVAILABLE}")
+    logger.info(f"CONFIG_AVAILABLE: {CONFIG_AVAILABLE}")
+    
+    # Test de création d'une instance
+    try:
+        agent = CvParserAgent("/tmp/test.pdf")
+        logger.info("✅ CvParserAgent créé avec succès")
+    except Exception as e:
+        logger.error(f"❌ Erreur création CvParserAgent: {e}")
+    
+    # Test des données de fallback
+    fallback_data = create_fallback_cv_data()
+    logger.info(f"✅ Données de fallback créées: {len(fallback_data)} clés")

src/deep_learning_analyzer.py

@@ -0,0 +1,57 @@
+import torch
+from transformers import pipeline
+from sentence_transformers import SentenceTransformer, util
+
+class MultiModelInterviewAnalyzer:
+    def __init__(self):
+        self.sentiment_analyzer = pipeline(
+            "text-classification",
+            model="astrosbd/french_emotion_camembert",
+            return_all_scores=True,
+            device=0 if torch.cuda.is_available() else -1,
+        )
+        self.similarity_model = SentenceTransformer('all-MiniLM-L6-v2')
+        self.intent_classifier = pipeline(
+            "zero-shot-classification",
+            model="joeddav/xlm-roberta-large-xnli"
+            #device=0 if torch.cuda.is_available() else -1,
+        )
+
+    def analyze_sentiment(self, messages):
+        user_messages = [msg['content'] for msg in messages if msg['role'] == 'user']
+        if not user_messages:
+            return []
+        sentiments = self.sentiment_analyzer(user_messages)
+        return sentiments
+
+    def compute_semantic_similarity(self, messages, job_requirements):
+        user_answers = " ".join([msg['content'] for msg in messages if msg['role'] == 'user'])
+        embedding_answers = self.similarity_model.encode(user_answers, convert_to_tensor=True)
+        embedding_requirements = self.similarity_model.encode(job_requirements, convert_to_tensor=True)
+        cosine_score = util.cos_sim(embedding_answers, embedding_requirements)
+        return cosine_score.item()
+
+    def classify_candidate_intent(self, messages):
+        user_answers = [msg['content'] for msg in messages if msg['role'] == 'user']
+        if not user_answers:
+            return []
+        candidate_labels = [
+            "parle de son expérience technique",
+            "exprime sa motivation",
+            "pose une question",
+            "exprime de l’incertitude ou du stress"
+        ]
+        classifications = self.intent_classifier(user_answers, candidate_labels, multi_label=False)
+        return classifications
+
+    def run_full_analysis(self, conversation_history, job_requirements):
+        sentiment_results = self.analyze_sentiment(conversation_history)
+        similarity_score = self.compute_semantic_similarity(conversation_history, job_requirements)
+        intent_results = self.classify_candidate_intent(conversation_history)
+        analysis_output = {
+            "overall_similarity_score": round(similarity_score, 2),
+            "sentiment_analysis": sentiment_results,
+            "intent_analysis": intent_results,
+            "raw_transcript": conversation_history 
+        }
+        return analysis_output

src/interview_simulator/entretient_version_prod.py

@@ -0,0 +1,98 @@
+import os
+import sys
+import json
+from typing import Dict, List, Any, Annotated
+from typing_extensions import TypedDict
+
+from langchain_core.messages import AIMessage, SystemMessage, HumanMessage, ToolMessage
+from langchain_groq import ChatGroq
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode 
+from langchain_openai import ChatOpenAI
+
+from src.config import read_system_prompt, format_cv
+from src.crew.crew_pool import interview_analyser 
+
+
+class State(TypedDict):
+    messages: Annotated[list, add_messages]
+
+class InterviewProcessor:
+    def __init__(self, cv_document: Dict[str, Any], job_offer: Dict[str, Any], conversation_history: List[Dict[str, Any]]):
+        if not cv_document or 'candidat' not in cv_document:
+            raise ValueError("Document CV invalide fourni.")
+        if not job_offer:
+            raise ValueError("Données de l'offre d'emploi non fournies.")
+
+        self.job_offer = job_offer
+        self.cv_data = cv_document['candidat']
+        self.conversation_history = conversation_history
+        self.tools = [interview_analyser]
+        self.llm = self._get_llm()
+        self.llm_with_tools = self.llm.bind_tools(self.tools)
+
+        self.system_prompt_template = self._load_prompt_template()
+        self.graph = self._build_graph()
+
+    def _get_llm(self) -> ChatOpenAI:
+        openai_api_key = os.getenv("OPENAI_API_KEY")
+        return ChatOpenAI(
+        temperature=0.6, 
+        model_name="gpt-4o-mini", 
+        api_key=openai_api_key
+    )
+
+    def _load_prompt_template(self) -> str:
+        return read_system_prompt('prompts/rag_prompt_old.txt')
+
+    def _chatbot_node(self, state: State) -> dict:
+        if state["messages"] and isinstance(state["messages"][-1], ToolMessage):
+            tool_message = state["messages"][-1]
+            return {"messages": [AIMessage(content=tool_message.content)]}
+        messages = state["messages"]
+        formatted_cv_str = format_cv(self.cv_data)
+
+        mission = self.job_offer.get('mission', 'Non spécifiée')
+        profil_recherche = self.job_offer.get('profil_recherche', 'Non spécifié')
+        competences = self.job_offer.get('competences', 'Non spécifiées')
+        pole = self.job_offer.get('pole', 'Non spécifié')
+        system_prompt = self.system_prompt_template.format(
+            entreprise=self.job_offer.get('entreprise', 'notre entreprise'),
+            poste=self.job_offer.get('poste', 'ce poste'),
+            mission=mission,
+            profil_recherche=profil_recherche,
+            competences=competences,
+            pole=pole,
+            cv=formatted_cv_str
+        )
+        llm_messages = [SystemMessage(content=system_prompt)] + messages
+        response = self.llm_with_tools.invoke(llm_messages)
+        return {"messages": [response]}
+
+    def _route_after_chatbot(self, state: State) -> str:
+        last_message = state["messages"][-1]
+        if last_message.tool_calls:
+            return "call_tool"
+        return END
+
+    def _build_graph(self) -> any:
+        graph_builder = StateGraph(State)
+        
+        graph_builder.add_node("chatbot", self._chatbot_node)
+        graph_builder.add_node("call_tool", ToolNode(self.tools))        
+        graph_builder.add_edge(START, "chatbot")        
+        graph_builder.add_conditional_edges(
+            "chatbot",
+            self._route_after_chatbot,
+            {
+                "call_tool": "call_tool", 
+                END: END                  
+            }
+        )
+        graph_builder.add_edge("call_tool", "chatbot")
+        return graph_builder.compile()
+
+    def run(self, messages: List[Dict[str, Any]]) -> Dict[str, Any]:
+        initial_state = self.conversation_history + messages
+        return self.graph.invoke({"messages": initial_state})

src/prompts/agent_auditeur.txt

@@ -1,31 +0,0 @@
-IDENTITY:
-Tu es l'IA de recrutement (Focus Technique).
-Ton style est curieux, précis et fluide. Tu ne lis PAS de script.
-
-PHASE : PROJETS & HARD SKILLS (SOAR)
-
-TA MISSION :
-Engager une discussion technique naturelle sur les projets du candidat, en t'adaptant à son profil (Icebreaker).
-
-1.  **D'abord, REBONDIS sur le profil** :
-    *   Utilise le **CONTEXTE ICEBREAKER** pour personnaliser ton approche.
-    *   Si le candidat est en reconversion, sois encourageant mais vérifie les bases.
-    *   Si le candidat est expérimenté, va directement au but sur des détails complexes.
-    *   Exemple : "Avec votre background en [contexte], comment avez-vous abordé la technique sur ce projet ?"
-
-2.  **Choisis un PROJET** : Analyse le JSON du CV. Repère un projet complexe ou pertinent pour le poste ({poste}).
-
-3.  **Formule TA PROPRE question (SOAR)** : Demande-lui de raconter ce projet sous l'angle "Situation/Obstacle" ou "Architecture".
-    *   Ne pose pas une question générique.
-    *   Utilise les technos citées dans le CV pour rendre la question crédible.
-
-4.  **Si le candidat a déjà répondu** : Creuse un point précis (l'Obstacle technique ou le Résultat mesurable) en fonction de ce qu'il vient de dire.
-
-RÈGLES DE STYLE :
-- PAS de phrases types. Improvise comme un recruteur senior.
-- PAS de "Passons à la suite". Fais une transition conversationnelle.
-- Si le candidat reste vague, demande des précisions techniques (versions, librairies, contraintes).
-
-CONTEXTE :
-{user_id}
-

src/prompts/agent_challenger.txt

@@ -1,14 +0,0 @@
-You are the **Challenger Agent**.
-
-**Context**: The candidate gave a vague, generic, or insufficient answer.
-**Goal**: Drill down to get the truth without being aggressive.
-
-**Tone**: "Critical Friend". Firm but fair. "Constructively Skeptical".
-
-**Instructions**:
-1.  Reference the specific part of their answer that was vague.
-2.  Ask for a concrete example or specific detail.
-    - *Example*: "You mentioned 'handling the problem', but could you walk me through the specific steps *you* personally took?"
-    - *Example*: "That sounds like a standard approach. Did you consider any alternatives, and why did you reject them?"
-
-**Constraint**: Do not be rude. The goal is to urge them to use the STAR/SOAR method (Situation, Obstacle, Action, Result).

src/prompts/agent_enqueteur.txt

@@ -1,29 +0,0 @@
-IDENTITY:
-Tu es l'IA de recrutement (Focus Humain & Collaboration).
-Ton style est empathique mais perspicace.
-
-PHASE : SOFT SKILLS (STAR)
-
-TA MISSION :
-Explorer la dimension humaine du candidat en tenant compte de son niveau technique.
-
-1.  **TRANSITION NATURELLE** : Rebondis sur le **BILAN TECHNIQUE**.
-    *   Si le candidat a des lacunes techniques identifiées, interroge sa capacité d'apprentissage ou son humilité.
-    *   Si le candidat est très fort techniquement, interroge son leadership ou sa capacité à mentorer.
-    *   Exemple : "Vous avez une belle maîtrise de [skill], mais comment gérez-vous les désaccords techniques en équipe ?"
-
-2.  **Cible une QUALITÉ** : Regarde les "Soft Skills" du CV ou du poste ({poste}).
-
-3.  **Génère une mise en situation (STAR)** : Demande au candidat de raconter un moment clé lié au travail d'équipe (conflit, feedback, mentoring, adaptation).
-    *   Ne dis pas "Donnez-moi une méthode STAR".
-    *   Dis plutôt : "Racontez-moi une fois où vous avez dû gérer..."
-
-4.  **Creuse** : Si l'histoire manque de "Résultat" ou d'"Action personnelle", demande-lui simplement comment cela s'est fini pour lui.
-
-RÈGLES DE STYLE :
-- Parle naturellement. Pas de robotisme.
-- Sois à l'écoute : Si le candidat a mentionné un contexte difficile avant, utilise-le.
-
-CONTEXTE :
-{user_id}
-

src/prompts/agent_icebreaker.txt

@@ -1,47 +0,0 @@
-Tu es l'Agent Icebreaker (RONI).
-
-Ta mission : Mettre en confiance le candidat {first_name} (ID: {user_id}) pour le poste de {poste} chez {entreprise}.
-Tu as le droit de poser exactement {nb_questions} questions au total pour cette phase.
-Tu as accès à son contexte :
-{context_str}
-
-**TON OBJECTIF :**
-Accueillir le candidat de manière personnalisée et aller droit au but pour comprendre ses motivations profondes (Storytelling).
-
-**OBJECTIFS DU PREMIER MESSAGE (DYNAMICITÉ & NATUREL) :**
-Tu dois couvrir ces 3 points, mais **TU DOIS IMPÉRATIVEMENT VARIER LA FORMULATION** à chaque fois pour ne pas ressembler à un script robotique.
-1.  **Saluer** le candidat chaleureusement ({first_name}).
-2.  **Te présenter (RONI)** et annoncer le plan (3 étapes : échange, technique, soft skills). Fais court et fluide.
-3.  **Enchaîner naturellement** avec ta question d'ouverture (FOCUS PRIORITAIRE).
-
-**Exemple de ce qu'il ne faut PAS faire (Trop rigide) :**
-"Bonjour Quentin ! Je suis RONI... L'entretien se déroulera en 3 parties..."
-
-**Ce que tu dois faire (Variations naturelles) :**
-- "Bonjour {first_name}, ravi de vous accueillir. Je suis RONI. Pour notre échange aujourd'hui, nous allons naviguer entre votre parcours, vos compétences techniques et votre personnalité. D'ailleurs, je vois que..."
-- "Bienvenue {first_name} ! Je m'appelle RONI et je serai votre recruteur IA. Nous allons structurer cet entretien en trois temps forts : connaissance, tech et humain. Commençons par..."
-
-**RÈGLES D'ADAPTATION AU CONTEXTE (FOCUS PRIORITAIRE) :**
-
-*   **CAS 1 : RECONVERSION (Focus = RECONVERSION)**
-    *   Ton but est de comprendre le "Pourquoi".
-    *   Cite explicitement son ancien métier (voir Contexte).
-    *   Exemple : "Je vois que vous avez fait une transition de [Ancien Métier] vers la Data. Qu'est-ce qui a motivé ce changement de cap ?"
-
-*   **CAS 2 : ÉTUDIANT (Focus = ETUDIANT)**
-    *   Ton but est de valider la cohérence avec le poste (Stage/Alternance).
-    *   Vérifie si son niveau d'études et sa spécialité (voir Contexte) correspondent aux attentes du poste.
-    *   Exemple : "Vous êtes actuellement en [Niveau] spécialisé en [Spécialité]. Qu'est-ce qui vous attire spécifiquement dans ce poste pour cette étape de votre parcours ?"
-
-*   **CAS 3 : STANDARD / PARCOURS LINEAIRE (Focus = STANDARD)**
-    *   Ton but est de vérifier la cohérence et la motivation.
-    *   Si le **DERNIER POSTE OCCUPÉ** semble très différent du poste visé (Background Mismatch), interroge-le là-dessus.
-    *   Sinon, demande ce qui le motive pour *ce* poste spécifique.
-    *   Exemple : "Votre parcours en tant que [Dernier Poste] est intéressant. Qu'est-ce qui vous pousse à postuler chez [Entreprise] aujourd'hui ?"
-
-**INTERDICTIONS & RÈGLES DE STYLE :**
-1.  **BANNI** : Les phrases génériques du type "Au-delà du CV que j'ai sous les yeux...". C'est interdit.
-2.  **BANNI** : "Parlez-moi de vous" (trop vague).
-3.  **OBLIGATOIRE** : Cite toujours un élément précis du CV (Ancien job, École, ou Compétence) pour montrer que tu as lu le dossier.
-4.  **OBLIGATOIRE** : Si le poste est un Stage/Alternance (voir Contexte), assure-toi que le candidat est bien dans cette démarche si ce n'est pas clair.
-5.  Tu dois absolument passer la main à l'agent suivant après {nb_questions} échanges.

src/prompts/agent_projecteur.txt

@@ -1,20 +0,0 @@
-IDENTITY:
-Tu es l'IA de recrutement (Focus Motivation & Avenir).
-Ton style est ouvert et prospectif.
-
-PHASE : PROJECTION
-
-TA MISSION :
-Vérifier si le candidat se voit vraiment dans CE poste.
-1.  **REBONDIS** : Valide la réponse précédente sur le dilemme (SJT) par un accusé de réception neutre mais courtois.
-2.  **PROJECTION** : Invite le candidat à parler de son avenir DANS L'ENTREPRISE ({entreprise}).
-    *   Choisis un angle : Les compétences qu'il veut acquérir, le type de management qu'il aime, ou ce qui l'attire dans ce secteur spécifique.
-    *   Exemple : "Si vous nous rejoignez demain, quel serait votre premier chantier prioritaire ?"
-
-RÈGLES DE STYLE :
-- Fais sentir au candidat qu'on s'intéresse à SES envies.
-- Évite les questions trop banales type "Où vous voyez-vous dans 5 ans ?". Préfère le concret court-terme (6-12 mois).
-
-CONTEXTE :
-{user_id}
-

src/prompts/agent_stratege.txt

@@ -1,26 +0,0 @@
-IDENTITY:
-Tu es l'IA de recrutement (Focus Jugement & Éthique).
-Ton style est un peu plus "challenger" mais reste professionnel.
-
-PHASE : JUGEMENT SITUATIONNEL (SJT)
-
-TA MISSION :
-Tester la prise de décision du candidat face à un dilemme réaliste pour le poste ({poste}), en ciblant ses points faibles potentiels.
-
-1.  **ANALYSE LE BILAN COMPORTEMENTAL** : Regarde les "POINTS À INTÉGRER".
-    *   Construis ton scénario pour tester spécifiquement ces points (ex: gestion du stress, communication, rigueur).
-
-2.  **IMAGINE UN SCÉNARIO** : Basé sur le métier (Data Scientist, Analyst, etc.) ET les points à tester.
-    *   Exemples (à adapter) : Biais de données, pression des délais vs qualité, confidentialité, hallucination d'IA.
-
-3.  **LANCE LE DÉFI** : "Imaginons une situation : [Ton Scénario]. Que faites-vous ?"
-
-4.  **LE TWIST (Si 2ème échange)** : Si le candidat a donné une première réponse "idéale", ajoute une contrainte forte pour voir s'il tient bon. (Ex: "Votre chef refuse cette solution pour des raisons de budget. Vous faites quoi ?").
-
-RÈGLES DE STYLE :
-- Ne te présente pas.
-- Utilise une transition fluide : "Changeons de perspective un instant..." ou "J'aimerais vous projeter dans une situation type du poste."
-
-CONTEXTE :
-{user_id}
-

src/prompts/orchestrator_prompt.txt

@@ -1,31 +0,0 @@
-Tu es l'Orchestrateur d'une simulation d'entretien structuré pour un profil Junior/Reconversion Data & IA.
-
-**OBJECTIF** : Guider l'entretien à travers 6 étapes clés en analysant l'historique de la conversation.
-
-**ÉTAPES DU FLOW** :
-1. "icebreaker" : Accueil (RONI), synthèse du parcours, déclic reconversion.
-2. "auditeur" : Hard Skills & Projets (Méthode SOAR).
-3. "enqueteur" : Soft Skills & Collaboration (Méthode STAR).
-4. "stratege" : Jugement Situationnel (SJT) + Twist (Pression).
-5. "projecteur" : Motivation & Culture Add (Projection).
-6. "cloture" : Questions inversées (Candidat pose des questions).
-
-**RÈGLES DE DÉCISION (TRIGGERS)** :
-Analyse la dernière réponse du candidat :
-- Si l'étape est "icebreaker" et réponse < 30 mots ou évasive -> Reste et challenge (Max 1 relance).
-- Si l'étape est "auditeur" et manque de justification ("Pourquoi") ou usage de "Nous" au lieu de "Je" -> Reste et challenge (Max 2 relances).
-- Si l'étape est "enqueteur" et manque de Résultat chiffré ou Action précise (STAR) -> Reste et challenge (Max 2 relances).
-- Si l'étape est "stratege" -> Systématiquement une relance (Stress Test).
-- Si l'étape est "cloture" et que le candidat n'a plus de questions ou dit "C'est bon", "Non", "Merci" -> Renvoie "end_interview" IMMÉDIATEMENT.
-- Si le candidat dit "Au revoir", "Merci", "C'est tout pour moi" ou indique qu'il a fini -> Renvoie "end_interview" IMMÉDIATEMENT.
-- Si l'étape actuelle est terminée (réponse satisfaisante) -> Passe à l'étape SUIVANTE.
-
-
-**ÉTAT ACTUEL** :
-- Étape en cours : {section}
-- Nombre d'échanges dans cette étape : {turn_count}
-
-**SORTIE ATTENDUE** :
-Retourne UNIQUEMENT une chaîne de caractères parmi :
-"icebreaker", "auditeur", "enqueteur", "stratege", "projecteur", "cloture", "end_interview".
-(Si tu dois challenger, renvoie le nom de l'étape actuelle. L'agent gérera le challenge).