v01

.env

@@ -0,0 +1 @@
+GOOGLE_API_KEY="AIzaSyAh7rO3dujgrY-y3_lOdrskYfUAivKBbL4"

app.py

@@ -0,0 +1,1592 @@
+import os
+import gradio as gr
+import google.generativeai as genai 
+from PyPDF2 import PdfReader
+from docx import Document
+from dotenv import load_dotenv
+import speech_recognition as sr
+import time
+from gtts import gTTS
+import tempfile
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.lib.units import inch
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.table import Table as RichTable
+from rich import box
+import re
+import json
+from typing import List 
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.tools import tool
+
+
+load_dotenv()
+
+
+GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
+
+llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash", google_api_key=GOOGLE_API_KEY)
+
+# Définition des outils
+@tool
+def read_document_tool(file_path: str) -> str:
+    """Lit le contenu d'un fichier PDF ou DOCX situé à file_path et le retourne sous forme de texte."""
+    print(f"Outil : Lecture du document depuis {file_path}")
+    if not file_path:
+        return "Erreur : Aucun chemin de fichier fourni."
+    try:
+        if file_path.lower().endswith('.pdf'):
+            reader = PdfReader(file_path)
+            text = ""
+            for page in reader.pages:
+                text += page.extract_text() or ""
+            print("Outil : PDF lu avec succès.")
+            return text
+        elif file_path.lower().endswith('.docx'):
+            doc = Document(file_path)
+            text = ""
+            for paragraph in doc.paragraphs:
+                text += paragraph.text + "\n"
+            print("Outil : DOCX lu avec succès.")
+            return text
+        else:
+            print("Outil : Format de fichier non supporté.")
+            return "Format de fichier non supporté. Veuillez fournir un fichier PDF ou DOCX."
+    except Exception as e:
+        print(f"Outil : Erreur lors de la lecture du fichier - {e}")
+        return f"Erreur lors de la lecture du fichier : {e}"
+
+@tool
+def analyze_cv_with_llm_tool(cv_text: str, job_description: str) -> str:
+    """Analyse le texte du CV fourni par rapport à la description du poste en utilisant un LLM et retourne l'analyse structurée."""
+    print("Outil : Analyse du CV avec le LLM...")
+    if not cv_text or not job_description:
+        return "Erreur : Texte du CV ou description du poste manquant."
+        
+    prompt = f"""
+    Analysez le CV suivant par rapport à la description du poste.
+    
+    Description du poste :
+    {job_description}
+    
+    CV :
+    {cv_text}
+    
+    Fournissez une analyse structurée en Markdown incluant :
+    Nom du Candidat : [Nom et Prénom du candidat ici]
+    Poste Visé : [Intitulé du poste ici]
+    
+    ## Analyse du Candidat
+    
+    ### Points forts
+    Liste des points forts pertinents pour le poste.
+    
+    ### Points faibles
+    Liste des points faibles ou des domaines nécessitant un développement.
+    
+    ### Score de pertinence
+    Un score global sur 100 évaluant l'adéquation du candidat avec le poste.
+    
+    ### Résumé du profil
+    Un résumé concis du profil du candidat et de son expérience.
+    """
+    
+    try:
+        response = llm.invoke(prompt)
+        analysis_text = response.content if response and response.content else "Analyse non disponible."
+        print("Outil : Analyse du CV par le LLM terminée.")
+        return analysis_text
+    except Exception as e:
+        print(f"Outil : Erreur lors de l'analyse par le LLM - {e}")
+        return f"Erreur lors de l'analyse par le LLM : {e}"
+
+@tool
+def analyze_sentiment_tool(text: str) -> str:
+    """Analyse le sentiment du texte donné dans le contexte d'un entretien d'embauche (ex: positif, négatif, neutre, hésitant, confiant, stressé, enthousiaste) et retourne un terme unique ou une courte phrase décrivant le sentiment."""
+    print("Outil : Analyse du sentiment...")
+    if not text or text in ["Je n'ai pas compris votre réponse", "Erreur de service de reconnaissance vocale", "Je n'ai pas détecté de parole", "Erreur lors de l'enregistrement vocal"]:
+        return "Non analysable"
+
+    prompt = f"""
+    Analysez le sentiment principal de la réponse suivante du candidat dans le contexte d'un entretien d'embauche. Est-il positif, négatif, neutre, hésitant, confiant, stressé, enthousiaste ? Choisissez le terme qui décrit le mieux le sentiment général.
+    
+    Réponse du candidat : {text}
+    
+    Répondez uniquement avec un terme unique ou une courte phrase décrivant le sentiment.
+    """
+    try:
+        response = llm.invoke(prompt)
+        sentiment = response.content.strip() if response and response.content else "Analyse impossible"
+        print(f"Outil : Analyse du sentiment terminée : {sentiment}")
+        return sentiment
+    except Exception as e:
+        print(f"Outil : Erreur lors de l'analyse du sentiment - {e}")
+        return f"Erreur lors de l'analyse du sentiment : {e}"
+
+@tool
+def generate_next_interview_question_tool(cv_analysis: str, interview_transcript: List[dict], interview_goals: List[str], achieved_goals: List[str]) -> str:
+    """Génère la prochaine question d'entretien pertinente et ouverte basée sur l'analyse du CV, la transcription de l'entretien, les objectifs et les objectifs déjà atteints."""
+    print("Outil : Génération de la prochaine question d'entretien...")
+    
+    prompt = f"""
+    Vous êtes un recruteur professionnel menant un entretien d'embauche.
+    Sur la base de l'analyse du CV, de la transcription de l'entretien, des objectifs et des objectifs déjà atteints :
+    
+    Analyse du CV : {cv_analysis}
+    
+    Objectifs de l'entretien : {interview_goals}
+    Objectifs atteints : {achieved_goals}
+    Questions et réponses précédentes :
+    {interview_transcript}
+    
+    En considérant les objectifs qui n'ont PAS ENCORE été suffisamment couverts, formulez une question d'entretien pertinente et ouverte pour continuer à évaluer le candidat.
+    La question doit être directe, professionnelle et s'appuyer sur la conversation précédente.
+    IMPORTANT : Répondez UNIQUEMENT avec la question, sans explications ni commentaires.
+    """
+    
+    try:
+        response = llm.invoke(prompt)
+        question = response.content.strip() if response and response.content else "Pouvez-vous me parler de votre expérience professionnelle la plus significative ?"
+        print(f"Outil : Prochaine question d'entretien générée : '{question}'")
+        return question
+    except Exception as e:
+        print(f"Outil : Erreur lors de la génération de la question - {e}")
+        return f"Erreur lors de la génération de la question : {e}"
+
+@tool
+def evaluate_interview_progress_tool(interview_transcript: List[dict], interview_goals: List[str], achieved_goals: List[str]) -> str:
+    """Évalue la progression de l'entretien sur la base de la transcription, des objectifs et des objectifs atteints. Retourne 'CONTINUER' si l'entretien doit continuer pour couvrir les objectifs restants, ou 'FIN' si les objectifs sont suffisamment couverts ou si le nombre maximum de questions est atteint."""
+    print("Outil : Évaluation de la progression de l'entretien...")
+
+    if len(achieved_goals) >= len(interview_goals) and len(interview_goals) > 0:
+        print("Outil : Tous les objectifs semblent atteints. Recommandation : FIN.")
+        return "FIN"
+
+    prompt = f"""
+    Sur la base de la transcription de l'entretien, des objectifs et des objectifs atteints :
+
+    Objectifs de l'entretien : {interview_goals}
+    Objectifs atteints : {achieved_goals}
+    Transcription de l'entretien :
+    {interview_transcript}
+
+    Compte tenu de la progression et des informations obtenues, est-il judicieux de continuer l'entretien pour mieux évaluer le candidat sur les objectifs non encore couverts ?
+    Répondez UNIQUEMENT avec 'CONTINUER' ou 'FIN'.
+    """
+
+    try:
+        response = llm.invoke(prompt)
+        decision = response.content.strip().upper() if response and response.content else "CONTINUER"
+        print(f"Outil : Résultat de l'évaluation de la progression : {decision}")
+        return decision
+    except Exception as e:
+        print(f"Outil : Erreur lors de l'évaluation de la progression - {e}")
+        return "CONTINUER" # Continuer par défaut en cas d'erreur
+
+@tool
+def generate_final_report_content_tool(cv_analysis: str, interview_transcript: List[dict], interview_goals: List[str]) -> str:
+    """Analyse l'analyse du CV, la transcription de l'entretien et les objectifs pour générer le contenu complet du rapport de recrutement final. Retourne une chaîne JSON contenant les sections structurées du rapport."""
+    print("Outil : Génération du contenu du rapport final...")
+
+    if not cv_analysis or not interview_transcript or not interview_goals:
+        return "Erreur : Données manquantes (analyse du CV, transcription ou objectifs) pour générer le rapport final."
+
+    prompt = f"""
+    En tant qu'expert en recrutement, analysez l'entretien et générez un rapport détaillé au format JSON.
+    Basez-vous sur l'analyse du CV, la transcription de l'entretien et les objectifs définis.
+
+    Analyse du CV :
+    {cv_analysis}
+
+    Objectifs de l'entretien :
+    {interview_goals}
+
+    Transcription de l'entretien :
+    {interview_transcript}
+
+    Générez un rapport JSON structuré avec les sections suivantes :
+    {{
+        "overall_evaluation": "Une évaluation globale détaillée de la performance du candidat pendant l'entretien, en se basant sur ses réponses et son comportement",
+        "demonstrated_strengths": [
+            "Liste des points forts démontrés pendant l'entretien, avec des exemples concrets tirés des réponses"
+        ],
+        "areas_for_improvement": [
+            "Liste des points à améliorer identifiés pendant l'entretien, avec des exemples concrets"
+        ],
+        "interview_score": "Un score sur 100 avec justification détaillée",
+        "final_recommendation": "Une recommandation claire (ex: 'Recommandé pour un second entretien', 'Refusé', 'À considérer pour un autre poste') avec justification",
+        "goals_achievement": {{
+            "achieved_goals": [
+                "Liste des objectifs qui ont été suffisamment évalués pendant l'entretien"
+            ],
+            "unachieved_goals": [
+                "Liste des objectifs qui n'ont pas été suffisamment couverts"
+            ]
+        }}
+    }}
+
+    IMPORTANT :
+    - Basez votre analyse uniquement sur les réponses données pendant l'entretien
+    - Soyez spécifique et citez des exemples concrets des réponses du candidat
+    - Évitez les généralités et les clichés
+    - Assurez-vous que chaque section est détaillée et justifiée
+    - Le format de sortie doit être un JSON valide
+    """
+
+    try:
+        response = llm.invoke(prompt)
+        report_content = response.content.strip() if response and response.content else "Impossible de générer le contenu du rapport final."
+        print("Outil : Contenu du rapport final généré par le LLM.")
+        
+        # Nettoyer la réponse pour s'assurer qu'elle est en JSON valide
+        report_content = re.sub(r'^```json\n', '', report_content)
+        report_content = re.sub(r'\n```$', '', report_content)
+        report_content = report_content.strip()
+        
+        try:
+            json.loads(report_content)
+            return report_content
+        except json.JSONDecodeError:
+            default_report = {
+                "overall_evaluation": "Évaluation non disponible - Format de réponse invalide",
+                "demonstrated_strengths": ["Données insuffisantes"],
+                "areas_for_improvement": ["Données insuffisantes"],
+                "interview_score": "Non évalué",
+                "final_recommendation": "Recommandation non disponible",
+                "goals_achievement": {
+                    "achieved_goals": [],
+                    "unachieved_goals": interview_goals
+                }
+            }
+            return json.dumps(default_report, ensure_ascii=False)
+            
+    except Exception as e:
+        print(f"Outil : Erreur lors de la génération du contenu du rapport final - {e}")
+        return json.dumps({
+            "overall_evaluation": f"Erreur lors de la génération du rapport : {str(e)}",
+            "demonstrated_strengths": ["Données insuffisantes"],
+            "areas_for_improvement": ["Données insuffisantes"],
+            "interview_score": "Non évalué",
+            "final_recommendation": "Recommandation non disponible",
+            "goals_achievement": {
+                "achieved_goals": [],
+                "unachieved_goals": interview_goals
+            }
+        }, ensure_ascii=False)
+
+@tool
+def determine_interview_goals_tool(cv_analysis: str, job_description: str) -> List[str]:
+    """Détermine les objectifs clés de l'entretien basés sur l'analyse du CV et la description du poste. Retourne une liste d'objectifs d'évaluation spécifiques."""
+    print("Outil : Détermination des objectifs de l'entretien...")
+    if not cv_analysis or not job_description:
+        return ["Erreur : Analyse du CV ou description du poste manquante pour déterminer les objectifs."]
+        
+    prompt = f"""
+    Sur la base de l'analyse du CV et de la description du poste fournies, identifiez 3 à 5 objectifs clés que l'entretien doit viser pour évaluer correctement le candidat.
+    Ces objectifs doivent être spécifiques et axés sur l'évaluation des compétences et de l'adéquation au poste.
+    Formatez votre réponse comme une liste JSON de chaînes, où chaque chaîne est un objectif.
+    Exemple : ["Évaluer l'expérience en gestion de projet", "Vérifier les compétences techniques en Python", "Comprendre la motivation pour le poste"]
+
+    Analyse du CV :
+    {cv_analysis}
+
+    Description du poste :
+    {job_description}
+    """
+    
+    try:
+        response = llm.invoke(prompt)
+        goals_raw = response.content.strip() if response and response.content else "[]"
+        print(f"Outil : Réponse brute des objectifs : {goals_raw}")
+        
+        goals_cleaned = re.sub(r'^```json\n', '', goals_raw)
+        goals_cleaned = re.sub(r'\n```$', '', goals_cleaned)
+        goals_cleaned = goals_cleaned.strip()
+        print(f"Outil : Réponse nettoyée des objectifs : {goals_cleaned}")
+
+        try:
+            goals_list = json.loads(goals_cleaned)
+            if not isinstance(goals_list, list):
+                 print("Outil : Attention - Le LLM n'a pas retourné une liste JSON après nettoyage.")
+                 return ["Impossible de parser les objectifs de la réponse du LLM (pas une liste)."]
+            return goals_list if goals_list else ["Aucun objectif spécifique déterminé."]
+        except json.JSONDecodeError:
+             print("Outil : Erreur lors du décodage du JSON des objectifs après nettoyage.")
+             return ["Erreur lors du décodage des objectifs de la réponse du LLM. Réponse : '" + goals_cleaned[:100] + "...'"]
+             
+    except Exception as e:
+        print(f"Outil : Erreur lors de la détermination des objectifs - {e}")
+        return [f"Erreur lors de la détermination des objectifs : {e}"]
+
+# Liste de tous les outils disponibles
+tools = [
+    read_document_tool,
+    analyze_cv_with_llm_tool,
+    analyze_sentiment_tool,
+    generate_next_interview_question_tool,
+    evaluate_interview_progress_tool,
+    generate_final_report_content_tool,
+    determine_interview_goals_tool,
+]
+
+
+# Définition de l'agent Analyseur de CV
+def create_cv_analyzer_agent(llm, tools):
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "Vous êtes un expert en analyse de CV. Votre rôle est d'analyser le CV d'un candidat par rapport à une description de poste et de fournir un rapport structuré."),
+        ("human", "Analysez le CV suivant en fonction de la description du poste. Utilisez les outils disponibles si nécessaire.\nDescription du poste: {job_description}\nTexte du CV: {cv_text}"),
+        ("placeholder", "{agent_scratchpad}"),
+    ])
+    
+    agent = create_tool_calling_agent(llm, tools, prompt)
+    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+    
+    return agent_executor
+
+# Définition de l'agent Simulateur d'Entretien
+def create_interview_agent(llm, tools):
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", """Vous êtes un recruteur professionnel IA. Votre rôle est de mener un entretien structuré basé sur l'analyse du CV du candidat et les objectifs définis.
+        IMPORTANT: Vous devez TOUJOURS répondre avec soit :
+        1. Une question d'entretien claire et professionnelle qui s'appuie sur la conversation précédente et aide à évaluer les objectifs restants
+        2. Le mot "FIN" si vous déterminez que l'entretien doit se conclure
+        
+        Ne répondez jamais avec une chaîne vide ou un autre format."""),
+        ("human", """
+État actuel de l'entretien :
+Analyse du CV : {cv_analysis}
+Objectifs de l'entretien : {interview_goals}
+Transcription de l'entretien : {interview_transcript}
+Dernière réponse du candidat : {candidate_response}
+
+Sur la base de ces informations, veuillez générer la prochaine question d'entretien ou déterminer si l'entretien doit se terminer.
+Rappelez-vous : Vous devez répondre soit avec une question claire, soit avec "FIN".
+"""),
+         ("placeholder", "{agent_scratchpad}"), # Pour le processus de réflexion de l'agent
+    ])
+    
+    # Filtrer les outils pour n'inclure que ceux pertinents pour l'entretien
+    interview_tools = [tool for tool in tools if tool.name in ["generate_next_interview_question_tool", "analyze_sentiment_tool", "evaluate_interview_progress_tool"]]
+
+    agent = create_tool_calling_agent(llm, interview_tools, prompt)
+    agent_executor = AgentExecutor(agent=agent, tools=interview_tools, verbose=True)
+    
+    return agent_executor
+
+# Définition de l'agent Analyste Post-Entretien
+def create_post_interview_analyzer_agent(llm, tools):
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "Vous êtes un expert en analyse post-entretien. Votre rôle est d'analyser l'analyse du CV, la transcription de l'entretien et les objectifs pour générer un rapport de recrutement final complet."),
+        ("human", "Générez le rapport de recrutement final sur la base du contexte suivant.\nAnalyse du CV : {cv_analysis}\nObjectifs de l'entretien : {interview_goals}\nTranscription de l'entretien : {interview_transcript}"),
+        ("placeholder", "{agent_scratchpad}"), 
+    ])
+    
+    # Filtrer les outils pour n'inclure que ceux pertinents pour l'analyse post-entretien
+    post_interview_tools = [tool for tool in tools if tool.name in ["generate_final_report_content_tool"]]
+
+    agent = create_tool_calling_agent(llm, post_interview_tools, prompt)
+    agent_executor = AgentExecutor(agent=agent, tools=post_interview_tools, verbose=True)
+    
+    return agent_executor
+
+class SecretaireAgent:
+    def __init__(self):
+        self.console = Console()
+        self.styles = getSampleStyleSheet()
+        self._setup_styles()
+
+    def _setup_styles(self):
+        """Configure les styles personnalisés pour le PDF"""
+        # Style pour le titre principal
+        self.styles.add(ParagraphStyle(
+            name='CVMainTitle',
+            parent=self.styles['Heading1'],
+            fontSize=24,
+            spaceAfter=30,
+            textColor=colors.HexColor('#1A237E'),
+            alignment=1,  # Centré
+            fontName='Helvetica-Bold'
+        ))
+
+        # Style pour les sous-titres principaux
+        self.styles.add(ParagraphStyle(
+            name='CVSectionTitle',
+            parent=self.styles['Heading2'],
+            fontSize=18,
+            spaceAfter=20,
+            textColor=colors.HexColor('#283593'),
+            fontName='Helvetica-Bold',
+            leftIndent=20
+        ))
+
+        # Style pour les sous-sections
+        self.styles.add(ParagraphStyle(
+            name='CVSubSection',
+            parent=self.styles['Heading3'],
+            fontSize=14,
+            spaceAfter=15,
+            textColor=colors.HexColor('#303F9F'),
+            fontName='Helvetica-Bold',
+            leftIndent=40
+        ))
+
+        # Style pour le texte normal
+        self.styles.add(ParagraphStyle(
+            name='CVNormal',
+            parent=self.styles['Normal'],
+            fontSize=11,
+            spaceAfter=12,
+            textColor=colors.HexColor('#212121'),
+            fontName='Helvetica',
+            leftIndent=40,
+            rightIndent=40
+        ))
+
+        # Style pour les listes à puces
+        self.styles.add(ParagraphStyle(
+            name='CVBullet',
+            parent=self.styles['Normal'],
+            fontSize=11,
+            spaceAfter=8,
+            textColor=colors.HexColor('#212121'),
+            fontName='Helvetica',
+            leftIndent=60,
+            rightIndent=40,
+            bulletIndent=40
+        ))
+
+        # Style pour les informations de candidat
+        self.styles.add(ParagraphStyle(
+            name='CVCandidateInfo',
+            parent=self.styles['Normal'],
+            fontSize=12,
+            spaceAfter=15,
+            textColor=colors.HexColor('#424242'),
+            fontName='Helvetica-Bold',
+            alignment=1  # Centré
+        ))
+
+        # Nouveaux styles pour le rapport final
+        self.styles.add(ParagraphStyle(
+            name='ReportTitle',
+            parent=self.styles['Title'],
+            fontSize=28,
+            spaceAfter=40,
+            textColor=colors.HexColor('#0D47A1'), # Bleu plus foncé
+            alignment=1, # Centré
+            fontName='Helvetica-Bold'
+        ))
+
+        self.styles.add(ParagraphStyle(
+            name='ReportSection',
+            parent=self.styles['Heading1'],
+            fontSize=20,
+            spaceAfter=25,
+            spaceBefore=20,
+            textColor=colors.HexColor('#1565C0'), # Bleu moyen
+            fontName='Helvetica-Bold',
+            leftIndent=0
+        ))
+
+        self.styles.add(ParagraphStyle(
+            name='ReportSubSection',
+            parent=self.styles['Heading2'],
+            fontSize=16,
+            spaceAfter=15,
+            spaceBefore=15,
+            textColor=colors.HexColor('#1976D2'), # Bleu un peu plus clair
+            fontName='Helvetica-Bold',
+            leftIndent=20
+        ))
+
+        self.styles.add(ParagraphStyle(
+            name='ReportBody',
+            parent=self.styles['Normal'],
+            fontSize=10,
+            spaceAfter=8,
+            textColor=colors.HexColor('#212121'),
+            fontName='Helvetica',
+            leftIndent=20,
+            rightIndent=20
+        ))
+
+        self.styles.add(ParagraphStyle(
+            name='ReportQuestion',
+            parent=self.styles['ReportBody'],
+            fontName='Helvetica-BoldOblique',
+            textColor=colors.HexColor('#303F9F'), # Indigo
+        ))
+
+        self.styles.add(ParagraphStyle(
+            name='ReportAnswer',
+            parent=self.styles['ReportBody'],
+            spaceAfter=15,
+            textColor=colors.HexColor('#424242'), # Gris foncé
+        ))
+
+        self.styles.add(ParagraphStyle(
+            name='ReportSentiment',
+            parent=self.styles['ReportBody'],
+            fontName='Helvetica-Oblique',
+            textColor=colors.HexColor('#546E7A'), # Gris bleuâtre
+            spaceBefore=5,
+            spaceAfter=15,
+        ))
+
+    def create_pdf_report(self, cv_analysis, output_path):
+        """Crée un rapport PDF professionnel formaté selon le template."""
+        doc = SimpleDocTemplate(
+            output_path,
+            pagesize=letter,
+            rightMargin=72,
+            leftMargin=72,
+            topMargin=72,
+            bottomMargin=72
+        )
+
+        story = []
+        styles = self.styles # Utiliser les styles configurés
+
+        # --- Titre Principal ---
+        story.append(Paragraph("Rapport d'Analyse de Candidature", styles['CVMainTitle']))
+        story.append(Spacer(1, 30))
+
+        # --- Table d'Informations ---
+        # Extraire Nom du Candidat et Poste Visé du début de l'analyse
+        candidat_match = re.search(r'Nom du Candidat : (.*?)\n', cv_analysis)
+        nom_candidat = candidat_match.group(1).strip() if candidat_match else "Non spécifié"
+
+        poste_match = re.search(r'Poste Visé : (.*?)\n', cv_analysis)
+        nom_poste = poste_match.group(1).strip() if poste_match else "Non spécifié"
+
+        # Obtenir la date du jour
+        from datetime import date
+        date_analyse = date.today().strftime("%d/%m/%Y")
+
+        data = [
+            ['Nom du Candidat :', nom_candidat],
+            ['Poste Visé :', nom_poste],
+            ["Date de l'analyse :", date_analyse],
+            ['Analysé par :', 'AIRHTech'],
+        ]
+        table_style = TableStyle([
+            ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+            ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, 0), 10),
+            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+            ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+            ('GRID', (0, 0), (-1, -1), 1, colors.black),
+            ('BOX', (0, 0), (-1, -1), 1, colors.black),
+        ])
+        info_table = Table(data)
+        info_table.setStyle(table_style)
+        story.append(info_table)
+        story.append(Spacer(1, 20))
+
+        # --- Résumé du Profil ---
+        story.append(Paragraph("Résumé du Profil", styles['CVSectionTitle']))
+        story.append(Spacer(1, 10))
+        resume_match = re.search(r'### Résumé du profil\n(.*?)(?:\n###|$)', cv_analysis, re.DOTALL)
+        resume_text = resume_match.group(1).strip() if resume_match else "Résumé non trouvé."
+        story.append(Paragraph(resume_text, styles['CVNormal']))
+        story.append(Spacer(1, 20))
+
+        # --- Points Forts ---
+        story.append(Paragraph("Points Forts", styles['CVSectionTitle']))
+        story.append(Spacer(1, 10))
+        forts_match = re.search(r'### Points forts\n(.*?)(?:\n###|$)', cv_analysis, re.DOTALL)
+        forts_text = forts_match.group(1).strip() if forts_match else "Points forts non trouvés."
+        # Ajouter les points forts comme une liste à puces avec gras après la puce
+        for point in forts_text.split('\n'):
+            if point.strip():
+                 # Retirer le marqueur de liste Markdown (*)
+                 clean_point = point.strip().lstrip('* ').strip()
+                 # Retirer les marqueurs Markdown de gras (**) du début et de la fin
+                 clean_point = clean_point.lstrip('**').rstrip('**').strip()
+                 # Séparer le texte en une partie à mettre en gras et le reste
+                 parts = clean_point.split(':', 1)
+                 if len(parts) > 1:
+                     bold_part = parts[0].strip() + ":"
+                     rest_part = parts[1].strip()
+                     # Utiliser des balises HTML pour le gras dans le Paragraph
+                     story.append(Paragraph(f"• <b>{bold_part}</b> {rest_part}", styles['CVBullet']))
+                 else:
+                     # Si pas de :, juste mettre le point en gras
+                      story.append(Paragraph(f"• <b>{clean_point}</b>", styles['CVBullet']))
+
+        story.append(Spacer(1, 20))
+
+        # --- Points Faibles ---
+        story.append(Paragraph("Points Faibles", styles['CVSectionTitle']))
+        story.append(Spacer(1, 10))
+        faibles_match = re.search(r'### Points faibles\n(.*?)(?:\n###|$)', cv_analysis, re.DOTALL)
+        faibles_text = faibles_match.group(1).strip() if faibles_match else "Points faibles non trouvés."
+         # Ajouter les points faibles comme une liste à puces avec gras après la puce
+        for point in faibles_text.split('\n'):
+            if point.strip():
+                 # Retirer le marqueur de liste Markdown (*)
+                 clean_point = point.strip().lstrip('* ').strip()
+                 # Retirer les marqueurs Markdown de gras (**) du début et de la fin
+                 clean_point = clean_point.lstrip('**').rstrip('**').strip()
+                 # Séparer le texte en une partie à mettre en gras et le reste
+                 parts = clean_point.split(':', 1)
+                 if len(parts) > 1:
+                     bold_part = parts[0].strip() + ":"
+                     rest_part = parts[1].strip()
+                     # Utiliser des balises HTML pour le gras dans le Paragraph
+                     story.append(Paragraph(f"• <b>{bold_part}</b> {rest_part}", styles['CVBullet']))
+                 else:
+                      # Si pas de :, juste mettre le point en gras
+                      story.append(Paragraph(f"• <b>{clean_point}</b>", styles['CVBullet']))
+
+        story.append(Spacer(1, 20))
+
+        # --- Score de Pertinence ---
+        story.append(Paragraph("Score de Pertinence", styles['CVSectionTitle']))
+        story.append(Spacer(1, 10))
+        score_match = re.search(r'### Score de pertinence\n(.*?)(?:\n###|$)', cv_analysis, re.DOTALL)
+        score_content = score_match.group(1).strip() if score_match else "Score non trouvé."
+        
+        score_lines = score_content.split('\n', 1)
+        score_value = score_lines[0].strip() if score_lines else "N/A"
+        score_justification = score_lines[1].strip() if len(score_lines) > 1 else "Justification non disponible."
+
+        story.append(Paragraph(score_value, styles['CVSubSection']))
+        story.append(Spacer(1, 5))
+        story.append(Paragraph(score_justification, styles['CVNormal']))
+        story.append(Spacer(1, 20))
+
+        # Génération du PDF
+        doc.build(story)
+
+    def display_analysis(self, cv_analysis):
+        """Affiche l'analyse de manière élégante dans la console"""
+        # Création d'une table pour l'affichage
+        table = RichTable(box=box.ROUNDED, show_header=False, padding=(0, 1))
+        
+        # Traitement de l'analyse
+        sections = cv_analysis.split('##')
+        for section in sections:
+            if not section.strip():
+                continue
+                
+            lines = section.strip().split('\n')
+            title = lines[0].strip()
+            content = '\n'.join(lines[1:]).strip()
+            
+            # Ajout du titre
+            table.add_row(
+                Text(title, style="bold cyan"),
+                style="on rgb(40,44,52)"
+            )
+            
+            # Traitement du contenu
+            paragraphs = content.split('\n\n')
+            for para in paragraphs:
+                if para.strip():
+                    if para.strip().startswith('* '):
+                        # Traitement des listes à puces
+                        items = para.split('\n')
+                        for item in items:
+                            if item.strip():
+                                clean_item = item.strip().lstrip('* ').strip()
+                                table.add_row(
+                                    Text(f"• {clean_item}", style="white"),
+                                    style="on rgb(40,44,52)"
+                                )
+                    else:
+                        table.add_row(
+                            Text(para.strip(), style="white"),
+                            style="on rgb(40,44,52)"
+                        )
+        
+        # Affichage dans un panel
+        self.console.print(Panel(table, title="Analyse de CV", border_style="cyan"))
+
+    # Nouvelle méthode pour créer le rapport final PDF
+    def create_final_report_pdf(self, cv_analysis_text, interview_transcript_list, evaluation_json):
+        """Crée le rapport final PDF avec l'analyse CV, la transcription et l'évaluation."""
+        try:
+            # Assurer que les entrées sont du bon type
+            cv_analysis_text = str(cv_analysis_text) if cv_analysis_text is not None else ""
+            if not isinstance(interview_transcript_list, list):
+                print(f"Avertissement : interview_transcript_list n'est pas une liste (type: {type(interview_transcript_list)}). Initialisation à une liste vide.")
+                interview_transcript_list = []
+            evaluation_json = str(evaluation_json) if evaluation_json is not None else "{}"
+
+            # Créer un fichier temporaire pour le PDF
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+            temp_file.close()
+            pdf_path = temp_file.name
+
+            doc = SimpleDocTemplate(
+                pdf_path,
+                pagesize=letter,
+                rightMargin=72,
+                leftMargin=72,
+                topMargin=72,
+                bottomMargin=72
+            )
+
+            story = []
+            styles = self.styles
+
+            # --- Titre Principal du Rapport ---
+            story.append(Paragraph("Rapport de Recrutement Final", styles['ReportTitle']))
+            story.append(Spacer(1, 40))
+
+            # --- Résumé de l'Analyse de CV ---
+            story.append(Paragraph("1. Analyse de CV - Résumé", styles['ReportSection']))
+            story.append(Spacer(1, 10))
+            
+            # Extraire le résumé du profil de l'analyse CV
+            resume_match = re.search(r'### Résumé du profil\n(.*?)(?:\n###|$)', cv_analysis_text, re.DOTALL)
+            resume_text = resume_match.group(1).strip() if resume_match else "Résumé non trouvé."
+            story.append(Paragraph(resume_text, styles['ReportBody']))
+            story.append(Spacer(1, 20))
+
+            # --- Transcription de l'Entretien ---
+            story.append(Paragraph("2. Transcription de l'Entretien", styles['ReportSection']))
+            story.append(Spacer(1, 10))
+
+            if not interview_transcript_list:
+                story.append(Paragraph("Aucune transcription disponible.", styles['ReportBody']))
+            else:
+                for i, turn in enumerate(interview_transcript_list):
+                    # Assurer que les éléments du tour sont des dictionnaires et que les valeurs sont des chaînes
+                    if isinstance(turn, dict):
+                        question = str(turn.get('question', 'Question non disponible'))
+                        reponse = str(turn.get('reponse', 'Réponse non disponible'))
+                        sentiment = str(turn.get('sentiment', 'Sentiment non analysé'))
+
+                        story.append(Paragraph(f"**Tour {i+1}**", styles['ReportSubSection']))
+                        story.append(Paragraph(f"**Recruteur :** {question}", styles['ReportQuestion']))
+                        story.append(Paragraph(f"**Candidat :** {reponse}", styles['ReportAnswer']))
+                        story.append(Paragraph(f"_Sentiment : {sentiment}_", styles['ReportSentiment']))
+                    else:
+                        print(f"Avertissement : Élément inattendu dans interview_transcript_list (type: {type(turn)}). Ignoré.")
+
+            story.append(Spacer(1, 20))
+
+            # --- Évaluation de l'Entretien ---
+            story.append(Paragraph("3. Évaluation de l'Entretien", styles['ReportSection']))
+            story.append(Spacer(1, 10))
+            
+            try:
+                # Parser le JSON d'évaluation. Utilisez evaluation_json qui est déjà converti en str.
+                evaluation_data = json.loads(evaluation_json)
+                
+                # Évaluation Globale
+                story.append(Paragraph("Évaluation Globale", styles['ReportSubSection']))
+                story.append(Paragraph(str(evaluation_data.get('overall_evaluation', 'Évaluation non disponible')), styles['ReportBody']))
+                story.append(Spacer(1, 10))
+
+                # Points Forts
+                story.append(Paragraph("Points Forts Démontrés", styles['ReportSubSection']))
+                for strength in evaluation_data.get('demonstrated_strengths', []):
+                     story.append(Paragraph(f"• {str(strength)}", styles['ReportBody'])) # Convertir en str
+                story.append(Spacer(1, 10))
+
+                # Points à Améliorer
+                story.append(Paragraph("Points à Améliorer", styles['ReportSubSection']))
+                for area in evaluation_data.get('areas_for_improvement', []):
+                     story.append(Paragraph(f"• {str(area)}", styles['ReportBody'])) # Convertir en str
+                story.append(Spacer(1, 10))
+
+                # Score
+                story.append(Paragraph("Score de l'Entretien", styles['ReportSubSection']))
+                story.append(Paragraph(str(evaluation_data.get('interview_score', 'Score non disponible')), styles['ReportBody']))
+                story.append(Spacer(1, 10))
+
+                # Objectifs Atteints/Non Atteints
+                story.append(Paragraph("Objectifs de l'Entretien", styles['ReportSubSection']))
+                goals_achievement = evaluation_data.get('goals_achievement', {})
+                
+                story.append(Paragraph("Objectifs Atteints :", styles['ReportBody']))
+                for goal in goals_achievement.get('achieved_goals', []):
+                     story.append(Paragraph(f"✓ {str(goal)}", styles['ReportBody'])) # Convertir en str
+                
+                story.append(Paragraph("Objectifs Non Atteints :", styles['ReportBody']))
+                for goal in goals_achievement.get('unachieved_goals', []):
+                     story.append(Paragraph(f"✗ {str(goal)}", styles['ReportBody'])) # Convertir en str
+                story.append(Spacer(1, 10))
+
+                # Recommandation Finale
+                story.append(Paragraph("Recommandation Finale", styles['ReportSubSection']))
+                story.append(Paragraph(str(evaluation_data.get('final_recommendation', 'Recommandation non disponible')), styles['ReportBody']))
+
+            except json.JSONDecodeError as e:
+                print(f"Erreur lors du parsing du JSON d'évaluation dans create_final_report_pdf : {e}")
+                story.append(Paragraph(f"Erreur lors de l'analyse de l'évaluation : {e}.", styles['ReportBody']))
+            except Exception as e:
+                print(f"Erreur inattendue lors du traitement de l'évaluation JSON dans create_final_report_pdf : {e}")
+                story.append(Paragraph(f"Erreur inattendue lors du traitement de l'évaluation : {e}.", styles['ReportBody']))
+
+            # Génération du PDF
+            doc.build(story)
+            print(f"PDF final généré avec succès : {pdf_path}")
+            return pdf_path
+
+        except Exception as e:
+            print(f"Erreur inattendue lors de la création du rapport PDF : {e}")
+            return None
+
+class RecrutementApp:
+    def __init__(self, llm, tools):
+        self.model = genai.GenerativeModel('gemini-1.5-flash') # Modèle utilisé pour certaines tâches comme la correction de transcription
+        self.llm = llm # Le LLM configuré avec LangChain pour les agents
+        self.tools = tools # Les outils disponibles pour les agents
+        self.cv_text = ""
+        self.job_description = ""
+        self.interview_transcript = [] # Stocke la transcription de l'entretien [{"role": ..., "content": ...}, ...]
+        self.cv_analysis = None
+        self.recognizer = sr.Recognizer()
+        self.current_question = None
+        self.interview_started = False
+        self.question_count = 0
+        self.interview_goals = [] # Objectifs déterminés pour l'entretien
+        self.achieved_goals = set() # Objectifs jugés suffisamment couverts
+        self.conversation_history = [] # Historique complet de la conversation pour le chatbot Gradio
+        self.secretaire = SecretaireAgent()
+        # Créer l'agent Analyseur de CV
+        self.cv_analyzer_agent = create_cv_analyzer_agent(self.llm, self.tools)
+        # Créer l'agent Interviewer
+        self.interview_agent = create_interview_agent(self.llm, self.tools)
+        # Créer l'agent Analyste Post-Entretien
+        self.post_interview_analyzer_agent = create_post_interview_analyzer_agent(self.llm, self.tools)
+
+    def transcribe_audio(self, audio_filepath):
+        """Transcrit un fichier audio en texte."""
+        print(f"Tentative de transcription du fichier audio : {audio_filepath}")
+        if audio_filepath is None:
+            print("Chemin du fichier audio est None. Retour de 'Aucun enregistrement.'")
+            return "Aucun enregistrement."
+
+        recognizer = sr.Recognizer()
+        try:
+            with sr.AudioFile(audio_filepath) as source:
+                print("Lecture du fichier audio...")
+                audio = recognizer.record(source)  # lire le fichier audio entier
+            
+            print("Transcription de l'audio...")
+            # Utiliser la reconnaissance Google pour le français
+            text = recognizer.recognize_google(audio, language='fr-FR')
+            print(f"Transcription réussie : {text}")
+            # Appliquer la correction de transcription si nécessaire
+            corrected_text = self.correct_transcription(text)
+            print(f"Transcription corrigée : {corrected_text}")
+            return corrected_text
+        except sr.UnknownValueError:
+            print("La reconnaissance vocale n'a pas pu comprendre l'audio")
+            return "La reconnaissance vocale n'a pas compris l'audio."
+        except sr.RequestError as e:
+            print(f"Impossible d'obtenir les résultats du service de reconnaissance vocale Google ; {e}")
+            return f"Erreur de service de reconnaissance vocale ; {e}"
+        except Exception as e:
+             print(f"Une erreur inattendue s'est produite lors de la transcription : {e}")
+             return f"Une erreur inattendue s'est produite lors de la transcription : {e}"
+
+    def speak(self, text):
+        """Convertit le texte en parole en utilisant gTTS et retourne le chemin du fichier audio."""
+        if not text:
+            # Rien à dire si le texte est vide
+            return None
+        try:
+            tts = gTTS(text=text, lang='fr')
+            # Utiliser un fichier temporaire pour sauvegarder l'audio généré
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+            temp_file.close()
+            tts.save(temp_file.name)
+            # Retourner le chemin du fichier temporaire
+            return temp_file.name
+        except Exception as e:
+            print(f"Erreur lors de la synthèse vocale : {e}")
+            return None # Retourner None en cas d'erreur
+
+    def correct_transcription(self, text):
+        """Corrige les erreurs de transcription tout en préservant le sens."""
+        # Ne pas essayer de corriger les messages d'erreur ou les non-transcriptions
+        if text in ["La reconnaissance vocale n'a pas compris l'audio.", "Erreur de service de reconnaissance vocale", "Aucun enregistrement.", "Une erreur inattendue s'est produite lors de la transcription"]:
+            return text
+
+        print("Tentative de correction de transcription...")
+        prompt = f"""
+        Corrigez les erreurs de transcription évidentes dans le texte suivant tout en préservant strictement le sens, le style et le contenu original.
+        Ignorez les bruits de fond transcrits ou les hésitations si possible.
+        Contexte (question précédente posée par le recruteur) : {self.current_question}
+        
+        Texte à corriger : {text}
+        
+        Fournissez uniquement la version corrigée, sans explications.
+        """
+        
+        try:
+            # Utiliser le modèle Gemini pour la correction
+            correction_response = self.model.generate_content(prompt)
+            # Vérifier si la réponse contient du texte avant de la retourner
+            corrected_text = correction_response.text.strip() if correction_response and correction_response.text else text
+            print(f"Correction de transcription terminée : {corrected_text}")
+            return corrected_text
+        except Exception as e:
+            print(f"Erreur lors de la correction de transcription : {e}")
+            return text # Retourner le texte original en cas d'erreur
+
+    def extract_text_from_pdf(self, file):
+        # Docstring déjà en français
+        # print(f"Attempting to extract text from file: {file}") # Commenté car le paramètre file n'est pas un chemin ici, mais un objet _io.BufferedReader
+        if file is None:
+            print("Fichier fourni est None. Retour de chaîne vide.")
+            return ""
+        try:
+            # Vérifier l'extension du fichier
+            if file.name.lower().endswith('.pdf'):
+                print("Extraction de texte à partir d'un fichier PDF...")
+                reader = PdfReader(file)
+                text = ""
+                for page in reader.pages:
+                    text += page.extract_text() or ""
+                print("Extraction PDF terminée.")
+                return text
+            elif file.name.lower().endswith('.docx'):
+                print("Extraction de texte à partir d'un fichier DOCX...")
+                doc = Document(file)
+                text = ""
+                for paragraph in doc.paragraphs:
+                    text += paragraph.text + "\n"
+                print("Extraction DOCX terminée.")
+                return text
+            else:
+                print("Format de fichier non supporté.")
+            return "Format de fichier non supporté"
+        except Exception as e:
+             print(f"Erreur lors de l'extraction de texte : {e}")
+             return "Erreur lors de la lecture du fichier."
+
+    def analyze_cv(self, cv_file, job_description):
+        """Analyse le CV et la description du poste en utilisant l'agent LangChain, retourne une analyse formatée et le texte brut du CV."""
+        self.cv_text = ""
+        self.job_description = job_description
+        self.cv_analysis = None # Réinitialiser l'analyse au début
+
+        if cv_file is None:
+            return "Veuillez télécharger un CV.", "", None
+            
+        try:
+            # Assurez-vous que cv_file est un chemin de fichier accessible par l'outil read_document_tool
+            # Si Gradio fournit un objet fichier, vous devrez peut-être l'enregistrer temporairement
+            # Pour l'instant, supposons que cv_file.name est le chemin
+            file_path = cv_file.name
+            print(f"Tentative de lecture du fichier CV : {file_path}")
+            
+            # Utiliser l'outil read_document_tool DIRECTEMENT pour lire le fichier
+            cv_text = read_document_tool.invoke({"file_path": file_path})
+            self.cv_text = cv_text
+
+            if "Error" in self.cv_text or "Unsupported" in self.cv_text:
+                 print(f"Erreur ou format non supporté lors de la lecture du CV : {self.cv_text}")
+                 return self.cv_text, "", None # Retourner le message d'erreur si la lecture échoue et pas d'analyse
+            
+            print("Lecture du CV réussie. Texte extrait.")
+
+        except Exception as e:
+            print(f"Erreur lors de la lecture du fichier CV avec l'outil : {e}")
+            return f"Erreur lors de la lecture du fichier CV ou de l'appel de l'outil de lecture : {e}", "", None # Retourner None pour l'analyse
+
+        if not self.cv_text:
+             print("Le texte extrait du CV est vide.")
+             return "Impossible d'extraire le texte du CV.", "", None # Retourner None pour l'analyse
+             
+        try:
+            print("Utilisation de l'outil d'analyse de CV pour analyser le texte...")
+            # Appeler DIRECTEMENT l'outil analyze_cv_with_llm_tool
+            analysis_text = analyze_cv_with_llm_tool.invoke({"job_description": job_description, "cv_text": self.cv_text})
+            self.cv_analysis = analysis_text # Récupérer la sortie de l'outil
+            
+            print("Analyse du CV par l'outil terminée.")
+            
+            # Affichage de l'analyse dans la console
+            self.secretaire.display_analysis(self.cv_analysis)
+            
+            # Retourner l'analyse et le texte du CV
+            return self.cv_analysis, self.cv_text, self.cv_analysis # Retourner l'analyse pour l'affichage ET pour l'état
+        except Exception as e:
+            print(f"Erreur lors de l'analyse du CV par l'outil IA : {e}")
+            self.cv_analysis = f"Erreur lors de l'analyse du CV par l'outil IA : {e}"
+            # Retourner le message d'erreur pour l'analyse et le texte du CV, et None pour l'état de l'analyse
+            return self.cv_analysis, self.cv_text, None
+
+    def determine_interview_goals(self):
+        """Détermine les objectifs de l'entretien basés sur le CV et la description du poste"""
+        prompt = f"""
+        Basé sur cette analyse de CV:
+        {self.cv_analysis}
+        
+        Identifie 3 à 5 objectifs clés que l'entretien doit atteindre pour évaluer correctement le candidat.
+        Ces objectifs doivent être spécifiques et axés sur l'évaluation des compétences et de l'adéquation au poste.
+        Format: Liste simple d'objectifs, un par ligne.
+        Exemples: Évaluer l'expérience en gestion de projet, Vérifier les compétences techniques en Python, Comprendre la motivation pour le poste.
+        """
+        
+        try:
+            response = self.model.generate_content(prompt)
+            # Filtrer les lignes vides et s'assurer qu'il y a des objectifs
+            goals = [goal.strip() for goal in response.text.split('\n') if goal.strip()]
+            self.interview_goals = goals if goals else ["Évaluer l'adéquation générale du candidat."]
+            return self.interview_goals
+        except Exception as e:
+            print(f"Erreur lors de la détermination des objectifs de l'entretien : {e}")
+            self.interview_goals = ["Impossible de déterminer les objectifs. Évaluation générale."]
+            return self.interview_goals
+
+
+    def evaluate_goal_achievement(self, question, response):
+        """Évalue si un objectif a été atteint par la question/réponse actuelle."""
+        # Cette logique d'évaluation doit être plus fine. Au lieu de simplement vérifier si *un* objectif
+        # a été atteint, l'IA devrait identifier *quel(s)* objectif(s) ont été potentiellement couverts.
+        # Cependant, pour une implémentation simplifiée avec l'outil generate_content, nous allons
+        # demander à l'IA si cette interaction a permis de progresser significativement vers un ou plusieurs objectifs.
+        
+        if not self.interview_goals:
+            return False # Pas d'objectifs définis
+
+        prompt = f"""
+        En se basant sur la question et la réponse suivantes, et les objectifs de l'entretien:
+        
+        Objectifs de l'entretien: {self.interview_goals}
+        Objectifs déjà considérés comme partiellement ou totalement atteints (basé sur les questions précédentes): {list(self.achieved_goals)}
+        
+        Question actuelle: {question}
+        Réponse du candidat: {response}
+        
+        Cette interaction (question + réponse) a-t-elle significativement contribué à évaluer le candidat sur un ou plusieurs des objectifs NON ENCORE ATTEINTS ?
+        Réponds uniquement par "OUI" ou "NON".
+        """
+        
+        try:
+            evaluation_response = self.model.generate_content(prompt)
+            # Vérifier si la réponse est valide avant de la comparer
+            if evaluation_response and evaluation_response.text:
+                return evaluation_response.text.strip().upper() == "OUI"
+            return False # Considérer non atteint si l'évaluation échoue
+        except Exception as e:
+            print(f"Erreur lors de l'évaluation de l'objectif : {e}")
+            return False # En cas d'erreur, ne pas considérer l'objectif comme atteint
+
+
+    def should_continue_interview(self):
+        """Détermine si l'entretien doit continuer en se basant sur les objectifs et la progression."""
+        # L'entretien devrait continuer si tous les objectifs n'ont pas été évalués de manière satisfaisante
+        # ET si l'IA pense qu'il est encore possible d'obtenir des informations utiles.
+
+        if not self.interview_goals:
+             # Si pas d'objectifs, se baser sur un nombre max de questions ou un signal de l'IA
+             return self.question_count < 5 # Limite arbitraire si pas d'objectifs clairs
+             
+        # Si tous les objectifs considérés comme atteints (simplifié ici) et qu'il y a des objectifs définis
+        if len(self.achieved_goals) >= len(self.interview_goals) and len(self.interview_goals) > 0:
+             return False
+             
+        if self.question_count >= 15: # Limite maximale de questions pour éviter une boucle infinie
+             return False
+             
+        # Demander à l'IA si continuer l'entretien est pertinent pour atteindre les objectifs restants
+        prompt = f"""
+        Objectifs de l'entretien: {self.interview_goals}
+        Objectifs considérés comme atteints (basé sur l'évaluation simplifiée): {list(self.achieved_goals)}
+        Transcription actuelle de l'entretien:
+        {self.interview_transcript}
+
+        Compte tenu de la progression et des informations obtenues, est-il judicieux de poser une autre question pour mieux évaluer le candidat sur les objectifs non encore couverts?
+        Réponds uniquement par "OUI" ou "NON".
+        """
+
+        try:
+            continuation_response = self.model.generate_content(prompt)
+            if continuation_response and continuation_response.text:
+                 return continuation_response.text.strip().upper() == "OUI"
+            return True # Continuer par défaut si l'évaluation de continuation échoue
+        except Exception as e:
+            print(f"Erreur lors de l'évaluation de la continuation : {e}")
+            return True # Continuer par défaut en cas d'erreur
+
+
+    def generate_next_question(self):
+        """Génère la prochaine question basée sur le contexte de l'entretien et les objectifs restants."""
+        print("Début de la génération de la prochaine question...")
+        print(f"CV Analysis: {self.cv_analysis}")
+        print(f"Interview Goals: {self.interview_goals}")
+        print(f"Achieved Goals: {self.achieved_goals}")
+        print(f"Interview Transcript: {self.interview_transcript}")
+
+        prompt = f"""
+        Tu es un recruteur professionnel qui mène un entretien d'embauche.
+        Basé sur cette analyse de CV et l'historique de l'entretien:
+        {self.cv_analysis}
+        
+        Objectifs de l'entretien: {self.interview_goals}
+        Objectifs considérés comme atteints: {list(self.achieved_goals)}
+        Questions et réponses précédentes:
+        {self.interview_transcript}
+        
+        En gardant à l'esprit les objectifs NON ENCORE SUFFISAMMENT COUVERTS, formule une question d'entretien pertinente et ouverte pour continuer d'évaluer le candidat.
+        La question doit être directe, professionnelle et s'appuyer sur la conversation précédente.
+        IMPORTANT: Réponds UNIQUEMENT avec la question, sans explications ni commentaires.
+        """
+        
+        try:
+            print("Envoi de la requête à l'API Gemini...")
+            response = self.model.generate_content(prompt)
+            print(f"Réponse reçue de l'API: {response.text if response and response.text else 'Pas de réponse'}")
+            
+            if not response or not response.text:
+                print("Pas de réponse de l'API, utilisation d'une question par défaut")
+                return "Pouvez-vous me parler de votre expérience professionnelle la plus significative ?"
+                
+            return response.text.strip()
+        except Exception as e:
+            print(f"Erreur lors de la génération de la question suivante : {e}")
+            return "Pouvez-vous me parler de votre expérience professionnelle la plus significative ?"
+
+    def format_conversation_for_display(self, history):
+        """Formate l'historique de conversation (liste de dict) en une chaîne Markdown pour l'affichage."""
+        formatted_text = ""
+        for message in history:
+            role = message.get('role', 'Inconnu')
+            content = message.get('content', '')
+            
+            if role == 'Recruteur':
+                # Pour le recruteur, le contenu est juste la question texte
+                formatted_text += f"**Recruteur :** {content}\n\n"
+            elif role == 'Candidat':
+                # Pour le candidat, le contenu est la réponse transcrite
+                formatted_text += f"**Candidat :** {content}\n\n"
+            # Ignorer les autres rôles ou formats si nécessaire
+            
+        return formatted_text
+
+    def start_interview(self, cv_analysis_state):
+        """Démarre l'entretien en utilisant l'agent LangChain pour la première question."""
+        print("\n--- Démarrage de l'entretien (Mode LangChain Agent) ---")
+        # Utiliser la valeur de l'état Gradio pour la vérification
+        if not cv_analysis_state:
+            print("Pas d'analyse de CV disponible dans l'état Gradio. Impossible de démarrer l'entretien.")
+            # Retourner les états pour désactiver les contrôles et afficher un message
+            return [], "", "Veuillez d'abord analyser un CV.", "", gr.update(interactive=False), gr.update(interactive=False)
+        
+        self.interview_started = True
+        self.question_count = 0
+        self.interview_transcript = []
+        self.achieved_goals = set()
+        self.conversation_history = [] # Réinitialiser l'historique au début
+        print("État de l'entretien initialisé.")
+        
+        print("Détermination des objectifs de l'entretien...")
+        # La détermination des objectifs peut aussi être un rôle pour l'agent Interviewer ou un outil spécifique.
+        # Pour l'instant, gardons-la séparée ou intégrons-la comme une étape initiale de l'agent.
+        # self.determine_interview_goals() # On réutilise la méthode existante pour l'instant
+        
+        # Utiliser l'agent Interviewer pour déterminer les objectifs via le nouvel outil
+        try:
+            print("Appel de l'outil determine_interview_goals_tool pour déterminer les objectifs...")
+            # Appeler DIRECTEMENT l'outil determine_interview_goals_tool
+            goals_list = determine_interview_goals_tool.invoke({
+                "cv_analysis": cv_analysis_state, # Utiliser l'analyse du CV de l'état
+                "job_description": self.job_description # Utiliser la description du poste stockée
+            })
+            
+            self.interview_goals = goals_list
+            print(f"Objectifs déterminés par l'outil : {self.interview_goals}")
+            
+            if not isinstance(self.interview_goals, list) or not self.interview_goals:
+                 print("Outil n'a pas retourné une liste d'objectifs valide ou la liste est vide. Utilisation des objectifs par défaut.")
+                 self.interview_goals = ["Impossible de déterminer les objectifs. Évaluation générale."]
+
+        except Exception as e:
+            print(f"Erreur lors de l'appel de l'outil determine_interview_goals_tool : {e}")
+            self.interview_goals = [f"Erreur lors de la détermination des objectifs : {e}"] # Objectifs d'erreur
+
+        # Assurer que les objectifs sont formatés avec des tirets pour l'affichage
+        cleaned_goals = [goal.lstrip('* -').strip() for goal in self.interview_goals]
+        goals_text = "Objectifs :\n" + "\n".join([f"- {goal}" for goal in cleaned_goals])
+        print(f"Objectifs déterminés (nettoyés et formatés): \n{goals_text}")
+        
+        print("Génération de la première question via l'agent LangChain...")
+        # L'agent doit générer la première question sans réponse précédente
+        try:
+            # L'agent décide quoi faire en fonction du prompt initial et des outils.
+            # L'input est le contexte pour l'agent au début de l'entretien.
+            agent_response = self.interview_agent.invoke({
+                "cv_analysis": self.cv_analysis,
+                "interview_goals": self.interview_goals,
+                "interview_transcript": self.interview_transcript, # Vide au début
+                "candidate_response": "" # Vide au début
+            })
+            question = agent_response['output'].strip()
+            print(f"Première question générée par l'agent: '{question}'")
+            self.current_question = question
+            
+            if not question:
+                print("Agent n'a pas généré de question. Utilisation par défaut.")
+                question = "Pouvez-vous me parler de votre expérience professionnelle la plus significative ?"
+                self.current_question = question
+
+        except Exception as e:
+            print(f"Erreur lors de l'appel de l'agent Interviewer pour la première question : {e}")
+            question = "Pouvez-vous me parler de votre expérience professionnelle la plus significative ?" # Question par défaut en cas d'erreur
+            self.current_question = question
+
+        # Le contenu pour l'historique interne est simplement la question texte
+        chat_message_content = question
+        
+        # Ajouter le premier message à l'historique interne
+        first_message_for_history = {'role': 'Recruteur', 'content': chat_message_content}
+        self.conversation_history.append(first_message_for_history)
+        print(f"Premier message ajouté à l'historique interne: {self.conversation_history}")
+
+        # --- Nouveau : Formater l'historique interne pour l'affichage ---
+        formatted_conversation = self.format_conversation_for_display(self.conversation_history)
+        print(f"Conversation formatée pour l'affichage initial: \n{formatted_conversation}")
+        # --- Fin Nouveau ---
+
+        # Ajouter un petit délai pour permettre à Gradio de traiter la mise à jour de l'état
+        time.sleep(0.5)
+
+        print("\n--- Fin de start_interview ---")
+
+        # Retourner l'historique interne et la chaîne formatée pour l'affichage, plus les autres outputs
+        # Outputs: [conversation_history_state, conversation_display, goals_display, response_input, audio_input, submit_btn]
+        # On active l'input audio et on désactive le bouton submit initialement
+        return self.conversation_history, formatted_conversation, goals_text, "", gr.update(interactive=True), gr.update(interactive=False)
+
+    def get_recorded_response(self, audio_file):
+         """Utilise le fichier audio enregistré par Gradio pour transcrire la réponse."""
+         print(f"Fichier audio reçu de Gradio : {audio_file}")
+         if audio_file is None:
+             print("Aucun fichier audio reçu.")
+             # Retourner une chaîne vide, désactiver le bouton soumettre et None pour le chemin du fichier
+             return "Aucun enregistrement fourni.", gr.update(interactive=False), None
+             
+         # Stocker le chemin du fichier audio dans l'état pour une utilisation ultérieure
+         # Le chemin est nécessaire pour process_candidate_response
+         audio_filepath_for_state = audio_file # Stocker le chemin reçu
+
+         response_text = self.transcribe_audio(audio_file)
+         # Après la transcription, le bouton Soumettre doit être actif (il sera géré dans process_candidate_response)
+         # Le bouton Enregistrer redevient interactif ici si nécessaire
+         return response_text, gr.update(interactive=True), audio_filepath_for_state
+
+    def process_candidate_response(self, conversation_history, audio_file):
+        """Traite la réponse du candidat (via fichier audio) en utilisant l'agent LangChain."""
+        print("\n--- Traitement de la réponse du candidat par l'agent LangChain ---")
+
+        # Assurez-vous que conversation_history est une liste
+        if not isinstance(conversation_history, list):
+            print(f"Attention: conversation_history n'est pas une liste, type reçu: {type(conversation_history)}. Initialisation à une liste vide.")
+            conversation_history = []
+            self.conversation_history = conversation_history[:] # Synchroniser l'historique interne
+        else:
+            # Utiliser l'historique passé en input qui est géré par Gradio State
+            self.conversation_history = conversation_history[:] # Synchroniser l'historique interne
+
+        if not self.interview_started or self.current_question is None:
+            print("Entretien non démarré ou question actuelle manquante. Arrêt du traitement.")
+            formatted_conversation = self.format_conversation_for_display(self.conversation_history)
+            # Retourner les sorties nécessaires, désactiver les contrôles
+            return self.conversation_history, formatted_conversation, gr.update(value=""), gr.update(value=None, interactive=False), gr.update(interactive=False)
+
+        # L'audio a déjà été transcrit dans get_recorded_response, audio_file est le chemin stocké
+        # Nous devons récupérer la réponse transcrite. Elle est déjà dans response_input.
+        # Nous allons donc simplement utiliser le chemin du fichier ici pour l'analyse sentiment/ajout à la transcription si nécessaire
+        # La transcription réelle est gérée par get_recorded_response et mise à jour dans response_input.
+
+        # Nous devons récupérer la transcription qui a été mise à jour par get_recorded_response dans response_input
+        # Cependant, la logique actuelle ne passe pas response_input ici. Il faut la passer comme input.
+        # Pour l'instant, je vais refaire la transcription ici en utilisant le chemin du fichier.
+        # TODO: Passer response_input comme input à cette fonction pour éviter la double transcription.
+
+        # 1. Transcrire l'audio (ou utiliser la transcription déjà faite si disponible et passée en input)
+        # Pour l'instant, refaisons la transcription car response_input n'est pas un input ici
+        response = self.transcribe_audio(audio_file)
+        print(f"Réponse du candidat transcrite (dans process_candidate_response): '{response}'")
+
+        # 2. Mettre à jour l'historique interne et la transcription détaillée
+        candidate_message_for_history = {'role': 'Candidat', 'content': response}
+        self.conversation_history.append(candidate_message_for_history)
+        print(f"Réponse du candidat ajoutée à l'historique interne. Historique interne actuel: {self.conversation_history}")
+        
+        # Ajouter la question précédente, la réponse actuelle et l'analyse à la transcription
+        if self.current_question: # S'assurer qu'une question a été posée
+            # Effectuer l'analyse de sentiment ici pour la transcription détaillée
+            sentiment = self.analyze_sentiment(response)
+            self.interview_transcript.append({
+                'question': self.current_question,
+                'reponse': response,
+                'sentiment': sentiment # Ajouter le sentiment analysé
+            })
+            print(f"Transcription de l'entretien détaillée mise à jour: {self.interview_transcript}")
+        else:
+            print("Avertissement: self.current_question est None lors de l'ajout à la transcription détaillée.")
+
+        self.question_count += 1
+        print(f"Compteur de questions: {self.question_count}")
+        
+        # 3. Appeler l'agent Simulateur d'Entretien avec le contexte mis à jour
+        print("Appel de l'agent Simulateur d'Entretien pour la prochaine étape...")
+        try:
+            agent_response = self.interview_agent.invoke({
+                "cv_analysis": self.cv_analysis,
+                "interview_goals": self.interview_goals,
+                "interview_transcript": self.interview_transcript,
+                "candidate_response": response # Passer la réponse du candidat à l'agent
+            })
+            agent_output = agent_response['output'].strip()
+            print(f"Sortie brute de l'agent Interviewer: '{agent_output}'")
+
+            # Validation et interprétation de la sortie de l'agent
+            if not agent_output or agent_output.upper() == "FIN":
+                print("Agent a signalé la fin de l'entretien ou a retourné une sortie vide.")
+                self.interview_started = False
+                final_message = "L'entretien est terminé. Vous pouvez maintenant générer le rapport final." # Message de fin
+                final_message_for_history = {'role': 'Recruteur', 'content': final_message}
+                self.conversation_history.append(final_message_for_history)
+                print(f"Message de fin ajouté à l'historique interne. Historique interne actuel: {self.conversation_history}")
+                
+                formatted_conversation = self.format_conversation_for_display(self.conversation_history)
+
+                # Désactiver les contrôles d'entretien et retourner les états finaux
+                return (self.conversation_history, 
+                        formatted_conversation, 
+                        gr.update(value="", interactive=False), # Désactiver la zone de réponse
+                        gr.update(value=None, interactive=False), # Désactiver l'enregistrement audio
+                        gr.update(interactive=False)) # Désactiver le bouton soumettre
+
+            # L'agent a généré une nouvelle question
+            next_question = agent_output
+            print(f"Prochaine question déterminée : '{next_question}'")
+            self.current_question = next_question # Mettre à jour la question actuelle
+
+            # Ajouter la question suivante à l'historique interne
+            next_question_for_history = {'role': 'Recruteur', 'content': next_question}
+            self.conversation_history.append(next_question_for_history)
+            print(f"Prochaine question ajoutée à l'historique interne. Historique interne actuel: {self.conversation_history}")
+            
+            # Mettre à jour l'affichage et réactiver les contrôles pour le prochain tour
+            formatted_conversation = self.format_conversation_for_display(self.conversation_history)
+            print(f"Conversation formatée pour l'affichage : \n{formatted_conversation}")
+
+            # Retourner les états mis à jour pour le prochain tour de conversation
+            return (self.conversation_history, 
+                    formatted_conversation, 
+                    gr.update(value="", interactive=True), # Réactiver la zone de réponse
+                    gr.update(value=None, interactive=True), # Réactiver l'enregistrement audio
+                    gr.update(interactive=False)) # Désactiver le bouton soumettre jusqu'à nouvel enregistrement/saisie
+
+        except Exception as e:
+            print(f"Erreur lors de l'appel de l'agent Interviewer pour traiter la réponse : {e}")
+            error_message = f"Une erreur est survenue lors de la génération de la prochaine question : {e}. L'entretien est terminé."
+            self.interview_started = False # Marquer la fin de l'entretien en cas d'erreur
+            error_message_for_history = {'role': 'Recruteur', 'content': error_message}
+            self.conversation_history.append(error_message_for_history)
+            formatted_conversation = self.format_conversation_for_display(self.conversation_history)
+            # Retourner les états finaux, désactiver les contrôles
+            return self.conversation_history, formatted_conversation, gr.update(value="", interactive=False), gr.update(value=None, interactive=False), gr.update(interactive=False)
+
+    def analyze_sentiment(self, text):
+        """Analyse le sentiment du texte donné en utilisant le modèle Gemini via LangChain."""
+        # Vérifier les messages spéciaux qui ne doivent pas être analysés pour le sentiment
+        if text in ["La reconnaissance vocale n'a pas compris l'audio.", "Erreur de service de reconnaissance vocale", "Aucun enregistrement.", "Une erreur inattendue s'est produite lors de la transcription"]:
+            return "Non analysable"
+
+        prompt = f"""
+        Analyse le sentiment principal de la réponse suivante du candidat dans le contexte d'un entretien d'embauche. Est-il positif, négatif, neutre, hésitant, confiant, stressé, enthousiaste ? Choisis le terme qui décrit le mieux le sentiment général.
+        
+        Réponse du candidat: {text}
+        
+        Réponds uniquement avec un seul terme ou une courte phrase décrivant le sentiment.
+        """
+        try:
+            # Utiliser self.llm (le modèle LangChain) pour l'analyse de sentiment
+            response = self.llm.invoke(prompt)
+            # S'assurer qu'il y a du texte dans la réponse avant de la strip
+            sentiment = response.content.strip() if response and response.content else "Analyse impossible"
+            print(f"Analyse de sentiment via LLM terminée : {sentiment}") # Message de debug
+            return sentiment
+        except Exception as e:
+            print(f"Erreur lors de l'analyse de sentiment via LLM : {e}")
+            return f"Erreur lors de l'analyse de sentiment : {e}"
+
+    def save_analysis(self, analysis_text):
+        """Sauvegarde l'analyse dans un fichier PDF professionnel."""
+        print("Attempting to save analysis to PDF...") # Message de debug
+        if not analysis_text or analysis_text.startswith("Erreur") or analysis_text.startswith("Impossible"):
+            print("Pas d'analyse valide à sauvegarder.") # Message de debug
+            return None # Retourner None si l'analyse est vide ou contient une erreur
+        try:
+            # Créer un fichier PDF temporaire
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+            temp_file.close()
+            pdf_path = temp_file.name
+            print(f"Fichier temporaire créé pour l'analyse PDF : {pdf_path}") # Message de debug
+            
+            # Utiliser l'agent secrétaire pour créer le PDF
+            self.secretaire.create_pdf_report(analysis_text, pdf_path)
+            print(f"PDF d'analyse créé à : {pdf_path}") # Message de debug
+            # Vérifier si le fichier a été créé et n'est pas vide
+            if os.path.exists(pdf_path) and os.path.getsize(pdf_path) > 0:
+                 return pdf_path
+            else:
+                 print("Erreur : Fichier PDF d'analyse créé est vide ou inexistant.") # Message de debug
+            return None
+        except Exception as e:
+            print(f"Erreur lors de la sauvegarde de l'analyse en PDF : {e}") # Message de debug
+            return None # Retourner None en cas d'erreur
+            
+    def generate_report(self):
+        """Génère le rapport final de l'entretien."""
+        print("Attempting to generate final report...") # Message de debug
+        if not self.cv_analysis or not self.interview_transcript or not self.interview_goals:
+            print("Données insuffisantes pour le rapport final.") # Message de debug
+            # Retourner None car le composant File attend un chemin ou None
+            return None
+            
+        try:
+            print("Appel de l'outil generate_final_report_content_tool...") # Message de debug
+            # Appeler DIRECTEMENT l'outil generate_final_report_content_tool
+            evaluation_json_string = generate_final_report_content_tool.invoke({
+                "cv_analysis": self.cv_analysis,
+                "interview_transcript": self.interview_transcript,
+                "interview_goals": self.interview_goals
+            })
+            print("Outil generate_final_report_content_tool terminé.") # Message de debug
+
+            # S'assurer que l'évaluation est une chaîne JSON valide
+            print(f"Sortie brute de l'outil : {evaluation_json_string[:500]}...") # Message de debug
+
+            # create_final_report_pdf a déjà une logique pour gérer le JSON potentiellement invalide en retournant un rapport par défaut
+
+            # Créer le rapport PDF avec l'évaluation JSON
+            print("Création du rapport PDF final...") # Message de debug
+            pdf_path = self.secretaire.create_final_report_pdf(
+                self.cv_analysis,
+                self.interview_transcript,
+                evaluation_json_string # Passer la chaîne JSON (même si potentiellement invalide, gérée par create_final_report_pdf)
+            )
+
+            if pdf_path and os.path.exists(pdf_path) and os.path.getsize(pdf_path) > 0:
+                print(f"Rapport PDF final généré avec succès : {pdf_path}") # Message de debug
+                return pdf_path
+            else:
+                print("Erreur lors de la création du fichier PDF final ou fichier vide.") # Message de debug
+                return None # Retourner None si la création échoue ou fichier vide
+
+        except Exception as e:
+            print(f"Erreur inattendue lors de la génération du rapport final : {e}") # Message de debug
+            return None # Retourner None en cas d'erreur
+
+def create_interface():
+    app = RecrutementApp(llm, tools)
+    
+    with gr.Blocks(title="Tomouhi") as interface:
+        gr.Markdown("Toumouhi")
+        
+        with gr.Tab("Analyse de CV"):
+            cv_analysis_state = gr.State(None)
+            
+            with gr.Column():
+                cv_file = gr.File(label="Télécharger le CV (PDF ou DOCX)")
+                job_desc = gr.Textbox(label="Description du poste", lines=5)
+                analyze_btn = gr.Button("Analyser le CV")
+                
+                cv_analysis_display = gr.Textbox(label="Analyse du CV", lines=15, interactive=False, render="markdown")
+                
+                download_analysis_btn = gr.Button("Télécharger l'analyse", interactive=False)
+                analysis_download_file = gr.File(label="Fichier d'analyse", interactive=False)
+            
+            analyze_btn.click(
+                app.analyze_cv,
+                inputs=[cv_file, job_desc],
+                outputs=[cv_analysis_display, gr.State(app.cv_text), cv_analysis_state]
+            ).success(
+                lambda analysis_result: [gr.update(interactive=bool(analysis_result)), None] if analysis_result else [gr.update(interactive=False), None],
+                inputs=cv_analysis_display,
+                outputs=[download_analysis_btn, analysis_download_file]
+            )
+            
+            download_analysis_btn.click(
+                app.save_analysis,
+                inputs=cv_analysis_display,
+                outputs=analysis_download_file
+            )
+            
+        
+        with gr.Tab("Simulation d'Entretien"):
+            conversation_history_state = gr.State([])
+            conversation_display = gr.Markdown("", label="Conversation de l'entretien")
+            
+            last_audio_file_state = gr.State(None)
+            
+            goals_display = gr.Textbox(label="Objectifs de l'entretien", lines=5, interactive=False)
+            start_interview_btn = gr.Button("Démarrer l'entretien")
+            
+            with gr.Row():
+                response_input = gr.Textbox(label="Votre réponse", lines=3, scale=3, interactive=False)
+                with gr.Column(scale=1):
+                    audio_input = gr.Audio(sources="microphone", type="filepath", label="Enregistrer votre réponse")
+                    submit_btn = gr.Button("Soumettre réponse", interactive=False)
+
+            start_interview_event = start_interview_btn.click(
+                app.start_interview,
+                inputs=[cv_analysis_state],
+                outputs=[
+                    conversation_history_state,
+                    conversation_display,
+                    goals_display, 
+                    response_input, 
+                    audio_input,
+                    submit_btn
+                ]
+            )
+
+            audio_input.change(
+                 app.get_recorded_response,
+                 inputs=audio_input,
+                 outputs=[response_input, submit_btn, last_audio_file_state]
+            )
+            
+            submit_btn.click(
+                app.process_candidate_response,
+                inputs=[conversation_history_state, last_audio_file_state],
+                outputs=[
+                     conversation_history_state,
+                     conversation_display,
+                     response_input,
+                     audio_input,
+                     submit_btn
+                ]
+            )
+            
+        
+        with gr.Tab("Rapport Final"):
+            generate_report_btn = gr.Button("Générer le rapport")
+            report_output = gr.File(label="Télécharger le rapport")
+            
+            generate_report_btn.click(
+                app.generate_report,
+                outputs=report_output
+            )
+    
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    # Pour le déploiement sur Hugging Face Spaces
+    interface.launch() 

requirements.txt

@@ -0,0 +1,12 @@
+gradio>=4.0.0
+google-generativeai>=0.3.0
+PyPDF2>=3.0.0
+python-docx>=0.8.11
+fpdf>=1.7.2
+python-dotenv>=1.0.0
+SpeechRecognition>=3.10.0
+gTTS>=2.3.2
+reportlab>=4.0.0
+rich>=13.0.0
+langchain>=0.2.0
+langchain-google-genai>=1.0.0