Initial commit for Hugging Face Space

.gitignore

@@ -0,0 +1,49 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+
+# Virtual environments
+.env/
+venv/
+ENV/
+env/
+.venv/
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+
+# Pytest
+.cache/
+.pytest_cache/
+
+# Data and outputs
+data/
+output/
+logs/
+docs/
+
+#file
+prompt.md
+
+# Database files
+*.db
+
+# IDEs
+.vscode/
+.idea/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# dotenv
+.env
+.env.*
+.specstory
+
+# Optional: ignore local config
+config/*.local

app.py

@@ -0,0 +1,63 @@
+import gradio as gr
+from langgraphe_app import app  # importe ton graphe déjà compilé
+
+
+
+def print_stream(stream):
+    """Affiche le flux de messages de manière lisible"""
+    print("\n" + "="*60)
+    for s in stream:
+        message = s["messages"][-1]
+        if hasattr(message, 'pretty_print'):
+            message.pretty_print()
+        else:
+            print(message)
+        print("-"*60)
+
+# def run_research(user_query: str):
+#     """Fonction helper pour lancer une recherche"""
+#     inputs = {"messages": [("user", user_query)]}
+#     print_stream(app.stream(inputs, stream_mode="values"))
+
+def run_research(user_query: str) -> str:
+    """Exécute le graphe et renvoie le texte final pour Gradio."""
+    
+    inputs = {"messages": [("user", user_query)]}
+    stream = app.stream(inputs, stream_mode="values")
+
+    last_state = None
+
+    # on lit le stream mais on n'affiche pas dans le terminal
+    for s in stream:
+        last_state = s
+
+    # le message final
+    final_message = last_state["messages"][-1]
+
+    # Retourne le texte pour l’UI Gradio
+    try:
+        return final_message.content
+    except:
+        return str(final_message)
+
+
+with gr.Blocks(title="AI Research Assistant") as demo:
+    gr.Markdown("# 🔍 AI Research Assistant\nPipeline LangGraph pour la recherche automatisée")
+    
+    input_box = gr.Textbox(
+        label="Votre sujet de recherche",
+        placeholder="Ex : Impact de l'IA sur le marché du travail"
+    )
+    
+    output_box = gr.TextArea(
+        label="Rapport généré",
+        lines=20
+    )
+    
+    run_button = gr.Button("Lancer la recherche")
+    run_button.click(run_research, inputs=input_box, outputs=output_box)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=8000)
+
+# p-:8P^AduGVf2hU

config/prompts.py

@@ -0,0 +1,466 @@
+# Configuration des prompts pour chaque agent du système
+
+# Agent Researcher - Prompt de base
+RESEARCHER_PROMPT = """
+Tu es un agent de recherche expert. Ta mission est de trouver des informations pertinentes sur internet
+concernant le sujet suivant: {topic}.
+
+Recherche des sources fiables et récentes. Analyse le sujet et décompose-le en sous-sujets pertinents 
+si nécessaire. Pour chaque source, récupère les informations suivantes:
+- L'URL complète
+- Le titre
+- Un résumé court du contenu
+- La date de publication (si disponible)
+- L'auteur ou la source (si disponible)
+
+Concentre-toi sur les informations factuelles et évite les sources d'opinion non fondée.
+Retourne une liste structurée des meilleures sources que tu trouves.
+"""
+
+# Prompt pour l'extraction de mots-clés
+KEYWORD_EXTRACTION_PROMPT = """
+Tu es un expert en analyse sémantique. Analyse le sujet de recherche suivant et extrais 3-7 mots-clés pertinents qui amélioreront la recherche web.
+
+Sujet: {topic}
+
+Règles:
+1. Extrais des mots-clés spécifiques et techniques liés au sujet
+2. Évite les mots trop génériques (comme "analyse", "étude", "recherche")
+3. Privilégie les synonymes et termes alternatifs qui enrichiront la recherche
+4. Inclus des termes en français et leurs équivalents anglais si pertinents
+5. Évite de répéter les mots déjà présents dans le sujet principal
+
+Format de réponse: Retourne uniquement une liste de mots-clés séparés par des virgules, sans numérotation.
+Exemple: intelligence artificielle, machine learning, automatisation, emploi, marché du travail
+
+Mots-clés pour "{topic}":"""
+
+# Agent Reader/Summarizer - Prompt de base
+READER_PROMPT = """
+Tu es un expert en analyse et synthèse de documents. Tu dois lire et résumer le contenu suivant:
+
+{document_content}
+
+Source: {source_url}
+Titre: {title}
+Date: {date}
+Auteur: {author}
+
+Crée un résumé structuré qui:
+1. Identifie les points clés et arguments principaux (max 5)
+2. Extrait les données et statistiques importantes
+3. Note les méthodologies utilisées (si pertinent)
+4. Identifie les limitations ou biais potentiels
+5. Inclut les citations importantes (avec guillemets)
+
+Format ton résumé de manière claire avec des sections et des puces pour faciliter la lecture.
+Limite-toi à l'essentiel, le résumé ne doit pas dépasser 30% de la longueur du texte original.
+"""
+
+# Agent Writer/Reporter - Prompt de base
+WRITER_PROMPT = """
+Tu es un rédacteur expert. Ta mission est de créer un rapport de recherche structuré et professionnel
+sur le sujet: {topic}.
+
+Utilise les résumés de sources suivants pour rédiger ton rapport:
+
+{source_summaries}
+
+Ton rapport doit:
+1. Commencer par une introduction claire qui présente le sujet et son importance
+2. Organiser le contenu en sections logiques avec des titres et sous-titres
+3. Synthétiser les informations de toutes les sources de manière cohérente
+4. Présenter différentes perspectives sur le sujet quand elles existent
+5. Inclure des citations directes importantes (avec guillemets et références)
+6. Se terminer par une conclusion qui résume les points clés
+7. Inclure une bibliographie complète des sources utilisées
+
+Format du rapport: {format} (Markdown ou PDF)
+Utilise un ton professionnel et objectif. Assure-toi que toutes les informations sont correctement citées.
+"""
+
+# Prompts pour l'agent Summarizer/Reader
+SUMMARIZER_PROMPTS = {
+    "executive_summary": """
+Tu es un expert en synthèse de documents. Crée un résumé exécutif concis et percutant du document suivant.
+
+DOCUMENT:
+Titre: {title}
+Auteur: {author}
+URL: {url}
+
+CONTENU:
+{content}
+
+INSTRUCTIONS:
+1. Rédige un résumé exécutif de 2-3 phrases maximum
+2. Capture l'essence et les points les plus importants du document
+3. Utilise un langage clair et professionnel
+4. Évite les détails techniques superflus
+5. Focus sur les conclusions et impacts principaux
+
+RÉSUMÉ EXÉCUTIF:""",
+
+    "detailed_analysis": """
+Tu es un analyste expert. Effectue une analyse détaillée du document suivant.
+
+DOCUMENT:
+Titre: {title}
+Auteur: {author}
+URL: {url}
+
+CONTENU:
+{content}
+
+ANALYSE DEMANDÉE:
+1. **RÉSUMÉ DÉTAILLÉ** (2-3 paragraphes): Synthèse approfondie du contenu
+2. **POINTS CLÉS** (3-5 points): Arguments et idées principales (format: - Point clé)
+3. **ARGUMENTS PRINCIPAUX**: Thèses soutenues par l'auteur
+4. **DONNÉES ET STATISTIQUES**: Chiffres importants mentionnés
+5. **MÉTHODOLOGIE**: Approche utilisée (si applicable)
+6. **LIMITATIONS**: Biais ou limites identifiés
+
+Structure ta réponse avec des sections claires et des listes à puces.
+
+ANALYSE DÉTAILLÉE:""",
+
+    "sentiment_analysis": """
+Tu es un expert en analyse de sentiment et crédibilité. Évalue le document suivant.
+
+DOCUMENT:
+Titre: {title}
+Contenu: {content}
+
+ÉVALUATION DEMANDÉE:
+1. **SENTIMENT GÉNÉRAL**: Positif, Neutre, ou Négatif (justifie brièvement)
+2. **CRÉDIBILITÉ**: Score sur 10 (justifie ton évaluation)
+3. **BIAIS POTENTIELS**: Identifie les biais éventuels
+4. **QUALITÉ DES SOURCES**: Évalue la fiabilité des références
+
+Critères de crédibilité:
+- Qualité des sources citées
+- Objectivité du ton
+- Présence de données factuelles
+- Expertise apparente de l'auteur
+- Cohérence argumentative
+
+Format de réponse:
+SENTIMENT: [Positif/Neutre/Négatif] - [Justification]
+CRÉDIBILITÉ: [Score]/10 - [Justification]
+BIAIS: [Description des biais identifiés]
+
+ÉVALUATION:""",
+
+    "key_points_extraction": """
+Tu es un expert en extraction d'informations clés. Identifie les points les plus importants du document.
+
+DOCUMENT:
+{content}
+
+INSTRUCTIONS:
+1. Extrais 3-7 points clés maximum
+2. Chaque point doit être autonome et informatif
+3. Priorise par ordre d'importance
+4. Utilise des phrases courtes et claires
+5. Évite la redondance
+
+Format souhaité:
+- Point clé 1 (le plus important)
+- Point clé 2
+- Point clé 3
+etc.
+
+POINTS CLÉS:""",
+
+    "citations_extraction": """
+Tu es un expert en extraction de citations importantes. Identifie les citations les plus significatives du document.
+
+DOCUMENT:
+{content}
+
+INSTRUCTIONS:
+1. Extrais 2-5 citations maximum
+2. Privilégie les citations d'experts ou d'autorités
+3. Sélectionne les phrases les plus impactantes
+4. Inclus le contexte si nécessaire
+5. Évite les citations trop longues
+
+Format souhaité:
+"Citation exacte" - [Contexte/Auteur si mentionné]
+
+CITATIONS IMPORTANTES:""",
+
+   "chunked_summary": """
+Tu es un expert en synthèse de texte. Résume le chunk suivant du document.
+
+CHUNK {chunk_index}/{total_chunks} du document \"{title}\" :
+
+{chunk_content}
+
+INSTRUCTIONS:
+1. Résume ce chunk en 5-7 phrases claires et informatives
+2. Garde uniquement les informations essentielles
+3. Ne fais pas de répétition avec les autres chunks
+4. Utilise un style neutre et professionnel
+
+RÉSUMÉ DU CHUNK:
+""",
+
+    "synthesis": """
+Tu es un expert en synthèse documentaire. Crée un résumé unifié à partir des analyses partielles suivantes.
+
+ANALYSES PARTIELLES:
+{partial_summaries}
+
+DOCUMENT ORIGINAL:
+Titre: {title}
+URL: {url}
+
+INSTRUCTIONS:
+1. Synthétise toutes les analyses partielles en un résumé cohérent
+2. Élimine les redondances
+3. Préserve les informations essentielles
+4. Maintiens la logique et la continuité
+5. Assure-toi que le résumé final est compréhensible de manière autonome
+
+Structure attendue:
+- Résumé exécutif (2-3 phrases)
+- Analyse détaillée (2-3 paragraphes)
+- Points clés principaux
+- Sentiment et crédibilité globale
+
+SYNTHÈSE FINALE:""",
+
+    "global_analysis": """
+Tu es un expert en analyse comparative de documents. Analyse l'ensemble des résumés suivants pour identifier les patterns globaux.
+
+RÉSUMÉS DE DOCUMENTS:
+{all_summaries}
+
+ANALYSE GLOBALE DEMANDÉE:
+1. **THÈMES COMMUNS**: Sujets récurrents dans plusieurs documents
+2. **POINTS DE CONSENSUS**: Idées sur lesquelles les sources s'accordent  
+3. **POINTS CONFLICTUELS**: Contradictions ou désaccords entre sources
+4. **TENDANCES**: Évolutions ou patterns identifiés
+5. **LACUNES**: Aspects peu couverts ou manquants
+
+Format ta réponse avec des sections claires et des listes à puces.
+Sois objectif et factuel dans ton analyse.
+
+ANALYSE COMPARATIVE:"""
+}
+
+# Prompts pour l'agent Global Synthesizer
+GLOBAL_SYNTHESIZER_PROMPTS = {
+    "final_synthesis": """
+Tu es un expert en synthèse de recherche et rédaction de rapports. Crée un rapport final complet basé sur les résumés de documents suivants.
+
+SUJET DE RECHERCHE: {topic}
+
+RÉSUMÉS DE DOCUMENTS ANALYSÉS:
+{document_summaries}
+
+ANALYSE GLOBALE EXISTANTE:
+- Thèmes communs: {common_themes}
+- Points de consensus: {consensus_points}  
+- Points conflictuels: {conflicting_views}
+
+INSTRUCTIONS POUR LE RAPPORT FINAL:
+
+1. **INTRODUCTION** (1-2 paragraphes):
+   - Présente le sujet et son importance
+   - Contextualise l'analyse menée
+   - Annonce la structure du rapport
+
+2. **SYNTHÈSE EXÉCUTIVE** (3-5 points clés):
+   - Identifie les 3-5 conclusions principales
+   - Présente les insights les plus importants
+   - Formule des recommandations concrètes
+
+3. **ANALYSE DÉTAILLÉE** (sections thématiques):
+   - Organise le contenu par thèmes principaux
+   - Synthétise les informations de manière cohérente
+   - Présente différentes perspectives quand elles existent
+   - Utilise des données et citations pertinentes
+
+4. **TENDANCES ET IMPLICATIONS**:
+   - Identifie les tendances émergentes
+   - Analyse les implications futures
+   - Discute les défis et opportunités
+
+5. **CONCLUSION**:
+   - Résume les points essentiels
+   - Propose des pistes d'action ou réflexion
+
+STYLE ET FORMAT:
+- Utilise un ton professionnel et objectif
+- Structure claire avec titres et sous-titres
+- Citations avec références aux sources
+- Format Markdown avec mise en forme appropriée
+
+RAPPORT FINAL:""",
+
+    "executive_summary": """
+Tu es un expert en communication exécutive. Crée un résumé ex��cutif percutant basé sur les analyses suivantes.
+
+SUJET: {topic}
+
+DONNÉES D'ANALYSE:
+{analysis_data}
+
+INSTRUCTIONS:
+1. **CONCLUSIONS PRINCIPALES** (3-5 points maximum):
+   - Identifie les découvertes les plus importantes
+   - Utilise des données concrètes quand disponibles
+   - Sois concis et impactant
+
+2. **INSIGHTS CLÉS**:
+   - Révèle les patterns et tendances importantes
+   - Connecte les informations de différentes sources
+   - Identifie ce qui est nouveau ou surprenant
+
+3. **RECOMMANDATIONS**:
+   - Propose 2-4 actions concrètes
+   - Base-toi sur l'analyse réalisée
+   - Sois pragmatique et réalisable
+
+4. **SYNTHÈSE NARRATIVE** (2-3 paragraphes):
+   - Raconte l'histoire principale qui émerge des données
+   - Connecte logiquement les différents éléments
+   - Termine par l'implication la plus importante
+
+Format: Structure claire avec sections distinctes.
+Ton: Professionnel, confiant, basé sur les faits.
+
+RÉSUMÉ EXÉCUTIF:""",
+
+    "thematic_analysis": """
+Tu es un analyste expert. Organise et analyse les informations suivantes par thèmes cohérents.
+
+SUJET: {topic}
+RÉSUMÉS: {summaries}
+
+INSTRUCTIONS:
+1. **IDENTIFICATION DES THÈMES**:
+   - Identifie 3-6 thèmes principaux qui émergent des résumés
+   - Chaque thème doit être substantiel et distinct
+   - Nomme chaque thème de manière claire et descriptive
+
+2. **ANALYSE THÉMATIQUE**:
+   Pour chaque thème identifié:
+   - Synthétise les informations pertinentes de toutes les sources
+   - Identifie les points de convergence et divergence
+   - Présente les données et exemples les plus significatifs
+   - Note les implications et enjeux associés
+
+3. **HIÉRARCHISATION**:
+   - Classe les thèmes par ordre d'importance/impact
+   - Explique brièvement pourquoi chaque thème est important
+   - Identifie les liens entre les différents thèmes
+
+FORMAT:
+```
+## THÈME 1: [Nom du thème]
+### Synthèse
+[Analyse détaillée]
+### Points clés
+- Point 1
+- Point 2
+### Implications
+[Discussion]
+
+## THÈME 2: [Nom du thème]
+[etc.]
+```
+
+ANALYSE THÉMATIQUE:""",
+
+    "methodology_description": """
+Tu es un méthodologue expert. Décris la méthodologie utilisée pour cette recherche de manière claire et professionnelle.
+
+PARAMÈTRES DE RECHERCHE:
+- Sujet original: {topic}
+- Nombre de sources analysées: {sources_count}
+- Méthodes d'extraction: {extraction_methods}
+- Critères de sélection: {selection_criteria}
+
+PROCESSUS D'ANALYSE:
+{analysis_process}
+
+INSTRUCTIONS:
+1. **APPROCHE DE RECHERCHE**:
+   - Décris la stratégie de recherche adoptée
+   - Explique les critères de sélection des sources
+   - Justifie les choix méthodologiques
+
+2. **MÉTHODES D'ANALYSE**:
+   - Détaille les techniques d'analyse utilisées
+   - Explique le processus de synthèse
+   - Décris l'approche d'évaluation de la crédibilité
+
+3. **LIMITATIONS**:
+   - Identifie les limites de la méthodologie
+   - Reconnaît les biais potentiels
+   - Suggère des améliorations possibles
+
+4. **QUALITÉ DES DONNÉES**:
+   - Évalue la qualité globale des sources
+   - Discute la représentativité de l'échantillon
+   - Commente la fiabilité des conclusions
+
+Style: Académique mais accessible, précis et honnête.
+
+DESCRIPTION MÉTHODOLOGIQUE:""",
+
+    "quality_assessment": """
+Tu es un expert en évaluation de la qualité de recherche. Évalue la qualité et la fiabilité de cette analyse.
+
+DONNÉES D'ÉVALUATION:
+- Résumés analysés: {summaries_count}
+- Sources utilisées: {sources_info}
+- Scores de crédibilité: {credibility_scores}
+- Couverture thématique: {thematic_coverage}
+
+CRITÈRES D'ÉVALUATION:
+1. **COMPLÉTUDE**: L'analyse couvre-t-elle tous les aspects importants du sujet?
+2. **FIABILITÉ**: Les sources sont-elles crédibles et diversifiées?
+3. **COHÉRENCE**: Les conclusions sont-elles logiques et bien étayées?
+4. **OBJECTIVITÉ**: L'analyse évite-t-elle les biais évidents?
+5. **ACTUALITÉ**: Les informations sont-elles récentes et pertinentes?
+
+INSTRUCTIONS:
+- Attribue un score de 0 à 1 pour chaque critère
+- Justifie chaque score avec des éléments concrets
+- Identifie les points forts et les points faibles
+- Calcule un score de confiance global
+- Propose des recommandations d'amélioration
+
+Format:
+```
+## ÉVALUATION DE QUALITÉ
+
+### Complétude: X.X/1.0
+[Justification]
+
+### Fiabilité: X.X/1.0
+[Justification]
+
+[etc.]
+
+### SCORE GLOBAL: X.X/1.0
+### RECOMMANDATIONS:
+- [Recommandation 1]
+- [Recommandation 2]
+```
+
+ÉVALUATION QUALITÉ:"""
+}
+
+# Prompts système pour définir le comportement général des agents
+SYSTEM_PROMPTS = {
+    "researcher": "Tu es un agent de recherche IA spécialisé dans la recherche d'information pertinente et fiable.",
+    "reader": "Tu es un agent d'analyse IA spécialisé dans la lecture et la synthèse de documents complexes.",
+    "writer": "Tu es un agent rédacteur IA spécialisé dans la création de rapports de recherche structurés et professionnels.",
+    "summarizer": "Tu es un agent d'analyse IA expert en synthèse de documents, extraction de points clés et évaluation de crédibilité.",
+    "global_synthesizer": "Tu es un expert en synthèse de recherche et rédaction de rapports finaux. Tu excelles dans la création de documents structurés, professionnels et basés sur des analyses multiples."
+}

config/settings.py

@@ -0,0 +1,127 @@
+"""
+Configuration du projet AI Research Assistant.
+Ce fichier contient les configurations par défaut qui peuvent être surchargées
+par les variables d'environnement.
+"""
+
+from pydantic_settings import BaseSettings
+from typing import Dict, Optional, List
+
+
+class APIConfig(BaseSettings):
+    """Configuration des clés API et des paramètres associés"""
+    # LLM API (REQUIS)
+    GROQ_API_KEY: str = ""
+    
+    # APIs de Recherche (Au moins une REQUISE)
+    SERPER_API_KEY: str = ""
+    TAVILY_API_KEY: str = ""
+    BRAVE_API_KEY: str = ""
+    
+    # Configuration des modèles
+    LLM_MODEL: str = "llama-3.1-8b-instant"
+    LLM_TEMPERATURE: float = 0.1
+    LLM_MAX_TOKENS: int = 4000
+    EMBEDDING_MODEL: str = "all-MiniLM-L6-v2"
+    
+    # Limites de recherche
+    MAX_SOURCES: int = 20
+    MAX_SUMMARY_LENGTH: int = 500
+    SEARCH_TIMEOUT: int = 30
+    
+    # Performance et sécurité
+    API_RATE_LIMIT: int = 100
+    MAX_CONCURRENT_REQUESTS: int = 10
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
+class DatabaseConfig(BaseSettings):
+    """Configuration de la base de données"""
+    DATABASE_URL: str = "sqlite:///data/research.db"
+    CHROMA_PERSIST_DIRECTORY: str = "data/chroma"
+    CHROMA_COLLECTION_NAME: str = "research_documents"
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
+class PathConfig(BaseSettings):
+    """Configuration des chemins et répertoires"""
+    DATA_DIR: str = "data"
+    REPORTS_DIR: str = "data/reports"
+    CACHE_DIR: str = "data/cache"
+    LOGS_DIR: str = "logs"
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
+class FeatureConfig(BaseSettings):
+    """Configuration des fonctionnalités"""
+    ENABLE_CACHING: bool = True
+    ENABLE_VECTOR_STORE: bool = True
+    ENABLE_RATE_LIMITING: bool = True
+    CACHE_TTL: int = 3600
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
+class LoggingConfig(BaseSettings):
+    """Configuration du logging"""
+    LOG_LEVEL: str = "INFO"
+    ENABLE_FILE_LOGGING: bool = True
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
+class ExportConfig(BaseSettings):
+    """Configuration d'export et rapports"""
+    DEFAULT_EXPORT_FORMAT: str = "markdown"
+    PDF_PAGE_SIZE: str = "A4"
+    INCLUDE_CITATIONS: bool = True
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
+class DevelopmentConfig(BaseSettings):
+    """Configuration de développement"""
+    DEBUG: bool = False
+    DEVELOPMENT_MODE: bool = False
+    WORKER_THREADS: int = 4
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
+# Instanciation des configurations
+try:
+    api_config = APIConfig()
+    database_config = DatabaseConfig()
+    path_config = PathConfig()
+    feature_config = FeatureConfig()
+    logging_config = LoggingConfig()
+    export_config = ExportConfig()
+    development_config = DevelopmentConfig()
+except Exception as e:
+    print(f"Erreur lors du chargement de la configuration: {e}")
+    # Configuration par défaut en cas d'erreur
+    api_config = None

langgraphe_app.py

@@ -0,0 +1,219 @@
+from langchain_groq import ChatGroq
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langgraph.graph import StateGraph, END
+from typing import TypedDict, Sequence, Annotated, Union
+from langchain_core.messages import BaseMessage
+from dotenv import load_dotenv
+from langchain_core.tools import tool
+import os
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode
+import asyncio
+
+from src.agents.researcher_agent import ResearcherAgent
+from src.agents.content_extractor_agent import ContentExtractorAgent
+from src.agents.summarizer_agent import SummarizerAgent
+from src.agents.global_synthesizer_agent import GlobalSynthesizerAgent
+from src.models.research_models import ResearchQuery
+
+# ============================================================================
+# VOS AGENTS EXISTANTS (ne pas modifier)
+# ============================================================================
+researcher_agent = ResearcherAgent()
+content_extractor_agent = ContentExtractorAgent()
+summarizer_agent = SummarizerAgent()
+global_synthesizer_agent = GlobalSynthesizerAgent()
+
+# ============================================================================
+# OUTIL QUI ENCAPSULE VOTRE PIPELINE COMPLET
+# ============================================================================
+@tool
+def research_complete_pipeline(topic: str, max_results: Union[int, str] = 2) -> str:
+    """Exécute un pipeline de recherche complet sur un sujet donné.
+    
+    Ce tool encapsule 4 agents qui travaillent ensemble :
+    1. ResearcherAgent : recherche web et extraction de mots-clés
+    2. ContentExtractorAgent : extraction du contenu des pages
+    3. SummarizerAgent : création de résumés détaillés
+    4. GlobalSynthesizerAgent : synthèse globale finale
+    
+    Args:
+        topic: Le sujet de recherche (ex: "impact de l'IA sur l'emploi")
+        max_results: Nombre de sources à analyser (2-10, défaut: 2)
+    
+    Returns:
+        Un rapport complet au format texte avec résumé exécutif et analyse détaillée
+    """
+    # Conversion et validation
+    if isinstance(max_results, str):
+        try:
+            max_results = int(max_results)
+        except ValueError:
+            max_results = 2
+    max_results = max(2, min(max_results, 10))
+    
+    async def run_pipeline():
+        print(f"\n{'='*60}")
+        print(f"🚀 DÉMARRAGE DU PIPELINE DE RECHERCHE")
+        print(f"📋 Sujet: {topic}")
+        print(f"📊 Sources à analyser: {max_results}")
+        print(f"{'='*60}\n")
+        
+        # ÉTAPE 1: Recherche
+        print("🔍 [1/4] Recherche web en cours...")
+        query = ResearchQuery(
+            topic=topic,
+            keywords=await researcher_agent.extract_keywords_with_llm(topic),
+            max_results=max_results,
+            search_depth="basic"
+        )
+        research_data = await researcher_agent.process(query)
+        print(f"✅ Trouvé {research_data.total_found} sources")
+        
+        # ÉTAPE 2: Extraction
+        print("\n📄 [2/4] Extraction du contenu...")
+        extraction_data = await content_extractor_agent.process_from_research_output(
+            research_output=research_data
+        )
+        print(f"✅ Extrait {extraction_data.successful_extractions} documents")
+        
+        # ÉTAPE 3: Résumés
+        print("\n📝 [3/4] Création des résumés...")
+        summarization_data = await summarizer_agent.process_from_extraction_result(
+            extraction_result=extraction_data
+        )
+        print(f"✅ Généré {summarization_data.total_documents} résumés")
+        
+        # ÉTAPE 4: Synthèse globale
+        print("\n🎯 [4/4] Synthèse globale...")
+        global_synthesis = await global_synthesizer_agent.process_from_summarization_output(
+            summarization_output=summarization_data
+        )
+        print(f"✅ Rapport final généré ({global_synthesis.final_report.word_count} mots)")
+        
+        print(f"\n{'='*60}")
+        print("✨ PIPELINE TERMINÉ AVEC SUCCÈS")
+        print(f"{'='*60}\n")
+        
+        # Retourner le rapport en format markdown
+        return global_synthesis.formatted_outputs.get('markdown', 
+                                                        global_synthesis.formatted_outputs.get('text', 
+                                                        str(global_synthesis))
+                                                        )
+    
+    return asyncio.run(run_pipeline())
+
+# ============================================================================
+# CONFIGURATION DU LLM ET DU GRAPHE
+# ============================================================================
+
+# État du graphe
+class AgentState(TypedDict):
+    messages: Annotated[Sequence[BaseMessage], add_messages]
+
+# Chargement des variables d'environnement
+load_dotenv()
+api_key = os.getenv("GROQ_API_KEY")
+if not api_key:
+    raise ValueError("GROQ_API_KEY non définie dans .env")
+
+# Configuration du modèle avec l'outil
+tools = [research_complete_pipeline]
+model = ChatGroq(
+    model="llama-3.1-8b-instant",
+    temperature=0.3,  # Bas pour plus de cohérence
+    max_tokens=2048*2,
+    api_key=api_key
+).bind_tools(tools)
+
+# ============================================================================
+# NŒUDS DU GRAPHE
+# ============================================================================
+
+def model_call(state: AgentState) -> AgentState:
+    """Nœud qui appelle le LLM pour décider quoi faire"""
+    
+    system_prompt = SystemMessage(content="""Tu es un assistant de recherche intelligent.
+
+        🎯 TON RÔLE:
+        Tu aides les utilisateurs à obtenir des résumés et analyses sur n'importe quel sujet.
+
+        🔧 TON OUTIL:
+        Tu as accès à un outil puissant appelé 'research_complete_pipeline' qui :
+        - Effectue des recherches web automatiques
+        - Extrait et analyse le contenu
+        - Génère des résumés détaillés
+        - Produit une synthèse globale complète
+
+        📋 QUAND L'UTILISER:
+        Utilise cet outil quand l'utilisateur demande :
+        - Un résumé sur un sujet
+        - Des informations sur un topic
+        - Une analyse d'un domaine
+        - Une recherche documentée
+
+        💡 COMMENT L'UTILISER:
+        - Identifie le sujet principal de la demande
+        - Appelle research_complete_pipeline avec le sujet en français clair
+        - Utilise max_results=2 pour une recherche standard
+
+        ✅ EXEMPLES:
+        User: "Résume l'impact de l'IA sur l'emploi"
+        → Appelle: research_complete_pipeline(topic="impact de l'intelligence artificielle sur le marché de l'emploi", max_results=2)
+        User: "Fais-moi une analyse complète sur le changement climatique"
+        → Appelle: research_complete_pipeline(topic="changement climatique", max_results=3)
+
+        ⚠️ IMPORTANT:
+        - N'essaie PAS de faire la recherche toi-même
+        - Utilise TOUJOURS l'outil pour les demandes de recherche
+        - Le résultat de l'outil est déjà un rapport complet formaté
+        - Tu peux présenter le résultat directement à l'utilisateur
+    """
+                                  
+            )
+    
+    messages = state["messages"]
+    response = model.invoke([system_prompt] + messages)
+    return {"messages": [response]}
+
+def should_continue(state: AgentState) -> str:
+    """Décide si on continue avec des outils ou si on termine"""
+    messages = state["messages"]
+    last_message = messages[-1]
+    
+    # Si le dernier message a des appels d'outils, continuer
+    if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
+        return "continue"
+    else:
+        return "end"
+
+# ============================================================================
+# CONSTRUCTION DU GRAPHE LANGGRAPH
+# ============================================================================
+
+# Créer le graphe
+graph = StateGraph(AgentState)
+
+# Ajouter les nœuds
+graph.add_node("llm", model_call)
+tool_node = ToolNode(tools=tools)
+graph.add_node("tools", tool_node)
+
+# Définir le point d'entrée
+graph.set_entry_point("llm")
+
+# Ajouter les transitions conditionnelles
+graph.add_conditional_edges(
+    "llm",
+    should_continue,
+    {
+        "continue": "tools",
+        "end": END,
+    },
+)
+
+# Après l'exécution des outils, retourner au LLM pour présenter les résultats
+graph.add_edge("tools", "llm")
+
+# Compiler le graphe
+app = graph.compile()

requirements.txt

@@ -0,0 +1,36 @@
+# AI Research Assistant - Configuration requise
+
+# Python
+# python>=3.10
+
+# LangGraph
+langgraph>=0.0.20
+
+# LangChain
+langchain>=0.0.310
+langchain-core>=0.1.4
+langchain-groq>=0.1.0
+langchain-text-splitters>=0.0.1
+
+# ChromaDB
+# chromadb>=0.4.18
+
+# API Clients
+tavily-python>=0.2.6
+serper-python>=0.1.3
+
+# Utilitaires
+python-dotenv>=1.0.0
+requests>=2.31.0
+aiohttp>=3.8.0
+pydantic>=2.5.0
+pydantic-settings>=2.0.0
+markdown>=3.5.1
+fpdf2>=2.7.5
+
+# Streamlit (optionnel, pour l'interface utilisateur)
+# streamlit>=1.28.0
+
+# Tests
+pytest>=7.0.0
+pytest-asyncio>=0.21.0

src/__init__.py

@@ -0,0 +1,14 @@
+"""
+Fichier d'initialisation du package principal.
+"""
+
+# Vide pour l'instant, sera complété plus tard avec les imports et exports nécessaires
+
+from src.utils import *
+
+
+__all__ = [
+    "memory_system",
+    "tools_with_memory",
+    "create_enhanced_model_call",
+]

src/agents/__init__.py

@@ -0,0 +1,14 @@
+"""
+Package des agents du système multi-agents.
+"""
+
+from .base_agent import BaseAgent, AgentError, AgentTimeoutError, AgentValidationError
+from .researcher_agent import ResearcherAgent
+
+__all__ = [
+    "BaseAgent",
+    "AgentError", 
+    "AgentTimeoutError",
+    "AgentValidationError",
+    "ResearcherAgent"
+]

src/agents/base_agent.py

@@ -0,0 +1,235 @@
+"""
+Classe de base pour tous les agents du système.
+Définit l'interface commune et les fonctionnalités partagées.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional, TypeVar, Generic
+from datetime import datetime
+import asyncio
+import uuid
+
+from src.core.logging import setup_logger
+from src.models.state_models import AgentState, AgentStatus, AgentType
+
+
+# Type générique pour les inputs et outputs des agents
+InputType = TypeVar('InputType')
+OutputType = TypeVar('OutputType')
+
+
+class BaseAgent(ABC, Generic[InputType, OutputType]):
+    """
+    Classe de base abstraite pour tous les agents du système.
+    
+    Fournit les fonctionnalités communes :
+    - Gestion de l'état
+    - Logging
+    - Gestion des erreurs et retry
+    - Métriques de performance
+    """
+    
+    def __init__(
+        self,
+        agent_type: AgentType,
+        name: Optional[str] = None,
+        max_retries: int = 3,
+        timeout: float = 300.0  # 5 minutes par défaut
+    ):
+        """
+        Initialise l'agent de base.
+        
+        Args:
+            agent_type: Type de l'agent
+            name: Nom personnalisé de l'agent
+            max_retries: Nombre maximum de tentatives en cas d'erreur
+            timeout: Timeout en secondes pour l'exécution
+        """
+        self.agent_type = agent_type
+        self.name = name or f"{agent_type.value}_agent"
+        self.agent_id = str(uuid.uuid4())
+        
+        # Configuration
+        self.max_retries = max_retries
+        self.timeout = timeout
+        
+        # État de l'agent
+        self.state = AgentState(
+            agent_type=agent_type,
+            max_retries=max_retries
+        )
+        
+        # Logger spécifique à l'agent
+        self.logger = setup_logger(f"agent_{self.name}")
+        
+        # Métriques
+        self.metrics = {
+            "total_executions": 0,
+            "successful_executions": 0,
+            "failed_executions": 0,
+            "total_processing_time": 0.0,
+            "average_processing_time": 0.0
+        }
+        
+        self.logger.info(f"Agent {self.name} initialisé (ID: {self.agent_id})")
+    
+    @abstractmethod
+    async def process(self, input_data: InputType) -> OutputType:
+        """
+        Méthode principale de traitement de l'agent.
+        Doit être implémentée par chaque agent concret.
+        
+        Args:
+            input_data: Données d'entrée spécifiques à l'agent
+            
+        Returns:
+            Données de sortie spécifiques à l'agent
+        """
+        pass
+    
+    @abstractmethod
+    def validate_input(self, input_data: InputType) -> bool:
+        """
+        Valide les données d'entrée.
+        
+        Args:
+            input_data: Données à valider
+            
+        Returns:
+            True si les données sont valides
+        """
+        pass
+    
+    async def execute(self, input_data: InputType) -> OutputType:
+        """
+        Exécute l'agent avec gestion des erreurs et retry.
+        
+        Args:
+            input_data: Données d'entrée
+            
+        Returns:
+            Résultat de l'exécution
+            
+        Raises:
+            Exception: Si l'exécution échoue après tous les retry
+        """
+        self.logger.info(f"Début d'exécution de l'agent {self.name}")
+        self.state.start_execution()
+        self.metrics["total_executions"] += 1
+        
+        # Validation des données d'entrée
+        if not self.validate_input(input_data):
+            error_msg = f"Données d'entrée invalides pour l'agent {self.name}"
+            self.logger.error(error_msg)
+            self.state.mark_error(error_msg)
+            self.metrics["failed_executions"] += 1
+            raise ValueError(error_msg)
+        
+        # Tentatives d'exécution avec retry
+        last_exception = None
+        
+        for attempt in range(self.max_retries + 1):
+            try:
+                self.logger.info(f"Tentative {attempt + 1}/{self.max_retries + 1}")
+                
+                # Exécution avec timeout
+                result = await asyncio.wait_for(
+                    self.process(input_data),
+                    timeout=self.timeout
+                )
+                
+                # Succès
+                self.state.complete_execution()
+                self.metrics["successful_executions"] += 1
+                self._update_processing_time()
+                
+                self.logger.info(f"Agent {self.name} terminé avec succès")
+                return result
+                
+            except asyncio.TimeoutError as e:
+                error_msg = f"Timeout atteint pour l'agent {self.name} (>{self.timeout}s)"
+                self.logger.warning(error_msg)
+                last_exception = e
+                self.state.retry_count += 1
+                
+            except Exception as e:
+                error_msg = f"Erreur dans l'agent {self.name}: {str(e)}"
+                self.logger.warning(error_msg)
+                last_exception = e
+                self.state.retry_count += 1
+                
+                # Attendre avant la prochaine tentative (backoff exponentiel)
+                if attempt < self.max_retries:
+                    wait_time = 2 ** attempt  # 1s, 2s, 4s, etc.
+                    self.logger.info(f"Attente de {wait_time}s avant la prochaine tentative")
+                    await asyncio.sleep(wait_time)
+        
+        # Toutes les tentatives ont échoué
+        final_error = f"Agent {self.name} a échoué après {self.max_retries + 1} tentatives"
+        self.logger.error(final_error)
+        self.state.mark_error(final_error)
+        self.metrics["failed_executions"] += 1
+        
+        raise Exception(final_error) from last_exception
+    
+    def _update_processing_time(self):
+        """Met à jour les métriques de temps de traitement."""
+        if self.state.duration:
+            self.metrics["total_processing_time"] += self.state.duration
+            self.metrics["average_processing_time"] = (
+                self.metrics["total_processing_time"] / 
+                self.metrics["successful_executions"]
+            )
+    
+    def get_status(self) -> Dict[str, Any]:
+        """
+        Retourne le statut actuel de l'agent.
+        
+        Returns:
+            Dictionnaire avec les informations de statut
+        """
+        return {
+            "agent_id": self.agent_id,
+            "name": self.name,
+            "type": self.agent_type.value,
+            "status": self.state.status.value,
+            "retry_count": self.state.retry_count,
+            "duration": self.state.duration,
+            "error_message": self.state.error_message,
+            "metrics": self.metrics,
+            "last_execution": self.state.end_time.isoformat() if self.state.end_time else None
+        }
+    
+    def reset(self):
+        """Remet l'agent à zéro pour une nouvelle exécution."""
+        self.state = AgentState(
+            agent_type=self.agent_type,
+            max_retries=self.max_retries
+        )
+        self.logger.info(f"Agent {self.name} remis à zéro")
+    
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.name}, status={self.state.status.value})"
+    
+    def __repr__(self) -> str:
+        return (f"{self.__class__.__name__}(agent_id={self.agent_id}, "
+                f"type={self.agent_type.value}, status={self.state.status.value})")
+
+
+class AgentError(Exception):
+    """Exception personnalisée pour les erreurs d'agents."""
+    
+    def __init__(self, message: str, agent_name: str, agent_id: str):
+        self.agent_name = agent_name
+        self.agent_id = agent_id
+        super().__init__(f"Agent {agent_name} ({agent_id}): {message}")
+
+
+class AgentTimeoutError(AgentError):
+    """Exception pour les timeouts d'agents."""
+    pass
+
+
+class AgentValidationError(AgentError):
+    """Exception pour les erreurs de validation d'agents."""
+    pass

src/agents/content_extractor_agent.py

@@ -0,0 +1,626 @@
+"""
+Agent Content Extractor - Extraction et nettoyage de contenu web.
+Extrait le contenu de pages web, PDFs et autres documents.
+"""
+
+import asyncio
+from typing import List, Optional
+from datetime import datetime
+
+from src.agents.base_agent import BaseAgent
+from src.models.document_models import Document, ExtractionInput, ExtractionResult
+from src.models.research_models import ResearchOutput
+from src.models.state_models import AgentState, AgentType
+from src.services.content_extraction import ContentExtractionManager, ContentExtractionError
+from src.core.logging import setup_logger
+
+
+class ContentExtractorAgent(BaseAgent[ExtractionInput, ExtractionResult]):
+    """
+    Agent responsable de l'extraction de contenu depuis des URLs.
+    
+    Fonctionnalités:
+    - Extraction de contenu HTML avec nettoyage intelligent
+    - Support des PDFs et autres formats
+    - Traitement parallèle de plusieurs URLs
+    - Gestion des erreurs et retry automatique
+    - Structuration et nettoyage du contenu
+    """
+    
+    def __init__(self, max_concurrent_extractions: int = 5, max_retries: int = 2):
+        super().__init__(
+            agent_type=AgentType.CONTENT_EXTRACTOR,
+            name="content_extractor",
+            max_retries=max_retries,
+            timeout=300.0  # 5 minutes
+        )
+        self.extraction_manager = ContentExtractionManager(
+            max_concurrent=max_concurrent_extractions,
+            max_retries=max_retries
+        )
+    
+    def validate_input(self, input_data: ExtractionInput) -> bool:
+        """
+        Valide les données d'entrée pour l'extraction.
+        
+        Args:
+            input_data: Input contenant les URLs à extraire
+            
+        Returns:
+            True si les données sont valides
+        """
+        if not input_data.urls:
+            self.logger.error("Aucune URL fournie pour l'extraction")
+            return False
+        
+        if len(input_data.urls) > 50:  # Limite raisonnable
+            self.logger.error(f"Trop d'URLs ({len(input_data.urls)}), maximum 50")
+            return False
+        
+        # Filtrer les URLs valides
+        valid_urls = self._filter_valid_urls(input_data.urls)
+        if not valid_urls:
+            self.logger.error("Aucune URL valide trouvée")
+            return False
+        
+        return True
+    
+    async def process_from_research_output(self, research_output: ResearchOutput) -> ExtractionResult:
+        """
+        Traite directement un ResearchOutput pour extraire le contenu des URLs.
+        
+        Args:
+            research_output: Résultats de recherche avec URLs à extraire
+            
+        Returns:
+            ExtractionResult avec les documents extraits
+        """
+        # Extraire les URLs des résultats de recherche (conversion en string)
+        urls = [str(result.url) for result in research_output.results]
+        
+        self.logger.info(f"Extraction de contenu depuis ResearchOutput: {len(urls)} URLs")
+        self.logger.info(f"Sujet de recherche: {research_output.query.topic}")
+        
+        # Créer l'input d'extraction
+        extraction_input = ExtractionInput(
+            urls=urls,
+            content_filters={
+                'min_content_length': 200,  # Minimum de contenu
+                'max_content_length': 50000,  # Maximum pour éviter les textes trop longs
+                'required_keywords': research_output.query.keywords  # Filtrer par mots-clés de recherche
+            },
+            extraction_options={
+                'source_query': research_output.query.topic,
+                'search_keywords': research_output.query.keywords
+            }
+        )
+        
+        # Traiter avec la méthode normale
+        return await self.process(extraction_input)
+    
+    async def process(self, input_data: ExtractionInput) -> ExtractionResult:
+        """
+        Exécute l'extraction de contenu pour les URLs fournies.
+        
+        Args:
+            input_data: Input contenant les URLs à extraire et les options
+            
+        Returns:
+            ExtractionResult avec les documents extraits
+            
+        Raises:
+            ValueError: Si les URLs sont invalides
+            ContentExtractionError: Si l'extraction échoue
+        """
+        start_time = datetime.now()
+        self.logger.info(f"Début extraction de contenu pour {len(input_data.urls)} URLs")
+        
+        # Filtrer les URLs valides (validation déjà faite dans validate_input)
+        valid_urls = self._filter_valid_urls(input_data.urls)
+        self.logger.info(f"URLs valides à traiter: {len(valid_urls)}/{len(input_data.urls)}")
+        
+        try:
+            # Extraction du contenu
+            documents = await self._extract_all_content(valid_urls, input_data)
+            
+            # Post-traitement des documents
+            processed_documents = self._post_process_documents(documents, input_data)
+            
+            # Calcul des statistiques
+            execution_time = (datetime.now() - start_time).total_seconds()
+            
+            # Identifier les URLs qui ont échoué
+            successful_urls = {str(doc.url) for doc in processed_documents}
+            failed_urls = [url for url in valid_urls if url not in successful_urls]
+            
+            # Création du résultat
+            result = ExtractionResult(
+                documents=processed_documents,
+                total_urls=len(input_data.urls),
+                successful_extractions=len(processed_documents),
+                failed_extractions=len(input_data.urls) - len(processed_documents),
+                failed_urls=failed_urls,
+                execution_time=execution_time,
+                extraction_stats=self._calculate_stats(processed_documents)
+            )
+            
+            self.logger.info(
+                f"Extraction terminée: {result.successful_extractions}/{result.total_urls} "
+                f"succès en {execution_time:.2f}s"
+            )
+            
+            return result
+            
+        except Exception as e:
+            self.logger.error(f"Erreur lors de l'extraction: {str(e)}")
+            raise ContentExtractionError(f"Échec de l'extraction de contenu: {str(e)}")
+    
+    def _filter_valid_urls(self, urls: List[str]) -> List[str]:
+        """Filtre et valide les URLs."""
+        import re
+        from urllib.parse import urlparse
+        
+        valid_urls = []
+        url_pattern = re.compile(
+            r'^https?://'  # http:// ou https://
+            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|'  # domain
+            r'localhost|'  # localhost
+            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'  # IP
+            r'(?::\d+)?'  # port
+            r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+        
+        for url in urls:
+            if not url or not isinstance(url, str):
+                self.logger.warning(f"URL invalide ignorée: {url}")
+                continue
+            
+            url = url.strip()
+            if not url:
+                continue
+            
+            # Validation du format
+            if not url_pattern.match(url):
+                self.logger.warning(f"Format URL invalide: {url}")
+                continue
+            
+            # Validation avec urlparse
+            try:
+                parsed = urlparse(url)
+                if not parsed.netloc:
+                    self.logger.warning(f"URL sans domaine: {url}")
+                    continue
+                
+                valid_urls.append(url)
+                
+            except Exception as e:
+                self.logger.warning(f"Erreur de parsing URL {url}: {e}")
+                continue
+        
+        return valid_urls
+    
+    async def _extract_all_content(self, urls: List[str], input_data: ExtractionInput) -> List[Document]:
+        """Extrait le contenu de toutes les URLs."""
+        try:
+            # Utiliser le gestionnaire d'extraction
+            documents = await self.extraction_manager.extract_multiple(urls)
+            
+            # Appliquer les filtres si spécifiés
+            if input_data.content_filters:
+                documents = self._apply_content_filters(documents, input_data.content_filters)
+            
+            return documents
+            
+        except Exception as e:
+            self.logger.error(f"Erreur lors de l'extraction multiple: {str(e)}")
+            raise
+    
+    def _apply_content_filters(self, documents: List[Document], filters: dict) -> List[Document]:
+        """Applique les filtres de contenu aux documents."""
+        filtered_documents = []
+        
+        for doc in documents:
+            # Filtrer par longueur minimale
+            min_length = filters.get('min_content_length', 100)
+            if len(doc.content) < min_length:
+                self.logger.debug(f"Document {doc.title} trop court: {len(doc.content)} caractères")
+                continue
+            
+            # Filtrer par longueur maximale
+            max_length = filters.get('max_content_length', 100000)
+            if len(doc.content) > max_length:
+                self.logger.debug(f"Document {doc.title} trop long, troncature")
+                doc.content = doc.content[:max_length] + "... [Contenu tronqué]"
+            
+            # Filtrer par langue si spécifiée
+            required_language = filters.get('language')
+            if required_language and doc.language != required_language:
+                self.logger.debug(f"Document {doc.title} ignoré: langue {doc.language}")
+                continue
+            
+            # Filtrer par mots-clés si spécifiés
+            required_keywords = filters.get('required_keywords', [])
+            if required_keywords:
+                content_lower = doc.content.lower()
+                if not any(keyword.lower() in content_lower for keyword in required_keywords):
+                    self.logger.debug(f"Document {doc.title} ignoré: mots-clés manquants")
+                    continue
+            
+            filtered_documents.append(doc)
+        
+        self.logger.info(f"Filtres appliqués: {len(filtered_documents)}/{len(documents)} documents retenus")
+        return filtered_documents
+    
+    def _post_process_documents(self, documents: List[Document], input_data: ExtractionInput) -> List[Document]:
+        """Post-traitement des documents extraits."""
+        processed_docs = []
+        
+        for doc in documents:
+            # Nettoyage supplémentaire du contenu
+            doc.content = self._clean_content(doc.content)
+            
+            # Recalcul du nombre de mots après nettoyage
+            doc.word_count = len(doc.content.split())
+            
+            # Validation finale
+            if self._is_valid_document(doc, input_data):
+                processed_docs.append(doc)
+            else:
+                self.logger.debug(f"Document {doc.title} rejeté lors de la validation finale")
+        
+        return processed_docs
+    
+    def _clean_content(self, content: str) -> str:
+        """Nettoyage avancé du contenu."""
+        import re
+        
+        if not content:
+            return ""
+        
+        # Supprimer les caractères de contrôle
+        content = re.sub(r'[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]', '', content)
+        
+        # Normaliser les espaces
+        content = re.sub(r'[ \t]+', ' ', content)
+        
+        # Normaliser les sauts de ligne
+        content = re.sub(r'\n\s*\n\s*\n+', '\n\n', content)
+        
+        # Supprimer les espaces en début et fin de lignes
+        lines = content.split('\n')
+        lines = [line.strip() for line in lines]
+        content = '\n'.join(lines)
+        
+        # Supprimer les lignes vides multiples
+        content = re.sub(r'\n{3,}', '\n\n', content)
+        
+        return content.strip()
+    
+    def _is_valid_document(self, doc: Document, input_data: ExtractionInput) -> bool:
+        """Valide un document extrait."""
+        # Vérifications de base
+        if not doc.content or not doc.content.strip():
+            return False
+        
+        if len(doc.content) < 50:  # Contenu trop court
+            return False
+        
+        # Vérification du ratio texte/contenu (détecter les pages avec peu de contenu)
+        if doc.word_count < 20:
+            return False
+        
+        # Vérifications spécifiques aux options d'entrée
+        if hasattr(input_data, 'min_quality_score'):
+            quality_score = self._calculate_content_quality(doc)
+            if quality_score < input_data.min_quality_score:
+                return False
+        
+        return True
+    
+    def _calculate_content_quality(self, doc: Document) -> float:
+        """Calcule un score de qualité pour le contenu (0-1)."""
+        score = 0.0
+        
+        # Points pour la longueur
+        if doc.word_count > 100:
+            score += 0.3
+        elif doc.word_count > 50:
+            score += 0.1
+        
+        # Points pour la structure
+        if doc.title and len(doc.title) > 10:
+            score += 0.2
+        
+        if doc.author:
+            score += 0.1
+        
+        if doc.published_date:
+            score += 0.1
+        
+        # Points pour la richesse du contenu
+        content = doc.content.lower()
+        if any(marker in content for marker in ['conclusion', 'introduction', 'sommaire']):
+            score += 0.2
+        
+        # Pénalité pour contenu répétitif
+        lines = doc.content.split('\n')
+        unique_lines = set(line.strip() for line in lines if line.strip())
+        if len(lines) > 0:
+            uniqueness_ratio = len(unique_lines) / len(lines)
+            if uniqueness_ratio < 0.5:
+                score -= 0.2
+        
+        return max(0.0, min(1.0, score))
+    
+    def _calculate_stats(self, documents: List[Document]) -> dict:
+        """Calcule les statistiques d'extraction."""
+        if not documents:
+            return {
+                'total_words': 0,
+                'average_words_per_doc': 0,
+                'doc_types': {},
+                'languages': {},
+                'has_authors': 0,
+                'has_dates': 0
+            }
+        
+        total_words = sum(doc.word_count for doc in documents)
+        
+        # Compter les types de documents
+        doc_types = {}
+        for doc in documents:
+            doc_type = doc.doc_type.value if doc.doc_type else 'unknown'
+            doc_types[doc_type] = doc_types.get(doc_type, 0) + 1
+        
+        # Compter les langues
+        languages = {}
+        for doc in documents:
+            lang = doc.language or 'unknown'
+            languages[lang] = languages.get(lang, 0) + 1
+        
+        # Compter les métadonnées
+        has_authors = sum(1 for doc in documents if doc.author)
+        has_dates = sum(1 for doc in documents if doc.published_date)
+        
+        return {
+            'total_words': total_words,
+            'average_words_per_doc': total_words // len(documents),
+            'doc_types': doc_types,
+            'languages': languages,
+            'has_authors': has_authors,
+            'has_dates': has_dates
+        }
+
+
+# Fonction utilitaire pour les tests
+async def extract_content_from_urls(urls: List[str], **options) -> List[Document]:
+    """
+    Fonction utilitaire pour extraire du contenu depuis une liste d'URLs.
+    
+    Args:
+        urls: Liste des URLs à extraire
+        **options: Options d'extraction (filters, etc.)
+    
+    Returns:
+        Liste des documents extraits
+    """
+    agent = ContentExtractorAgent()
+    
+    input_data = ExtractionInput(
+        urls=urls,
+        content_filters=options.get('content_filters', {}),
+        extraction_options=options.get('extraction_options', {})
+    )
+    
+    result = await agent.execute(input_data)
+    return result.documents
+
+
+# Fonction utilitaire pour l'intégration avec le Researcher
+async def extract_from_search_results(search_results: List[dict]) -> List[Document]:
+    """
+    Extrait le contenu depuis des résultats de recherche.
+    
+    Args:
+        search_results: Résultats de recherche avec URLs
+        
+    Returns:
+        Liste des documents extraits
+    """
+    urls = []
+    for result in search_results:
+        if isinstance(result, dict) and 'url' in result:
+            urls.append(result['url'])
+        elif hasattr(result, 'url'):
+            urls.append(result.url)
+    
+    if not urls:
+        return []
+    
+    return await extract_content_from_urls(urls)
+
+
+# Fonctions utilitaires pour la sauvegarde
+def save_extraction_result(result: ExtractionResult, filename: str = None) -> str:
+    """
+    Sauvegarde un ExtractionResult dans un fichier JSON.
+    
+    Args:
+        result: Résultat d'extraction à sauvegarder
+        filename: Nom du fichier (optionnel)
+        
+    Returns:
+        Nom du fichier sauvegardé
+    """
+    import json
+    from datetime import datetime
+    
+    if not filename:
+        # Générer un nom de fichier basé sur le nombre de documents et timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"extraction_result_{result.successful_extractions}docs_{timestamp}.json"
+    
+    try:
+        # Conversion en dictionnaire avec sérialisation des dates
+        result_dict = result.model_dump(mode='json')
+        
+        # Sauvegarde dans le fichier
+        with open(filename, 'w', encoding='utf-8') as f:
+            json.dump(result_dict, f, indent=2, ensure_ascii=False)
+        
+        return filename
+        
+    except Exception as e:
+        raise Exception(f"Erreur lors de la sauvegarde: {e}")
+
+
+def load_extraction_result(filename: str) -> ExtractionResult:
+    """
+    Charge un ExtractionResult depuis un fichier JSON.
+    
+    Args:
+        filename: Nom du fichier à charger
+        
+    Returns:
+        ExtractionResult chargé
+    """
+    import json
+    
+    try:
+        with open(filename, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # Reconstruction de l'ExtractionResult
+        return ExtractionResult(**data)
+        
+    except Exception as e:
+        raise Exception(f"Erreur lors du chargement: {e}")
+
+
+# Configuration du logger pour l'agent
+logger = setup_logger("ContentExtractorAgent")
+# Exemple d'utilisation
+if __name__ == "__main__":
+    import asyncio
+    import json
+    from src.models.research_models import ResearchOutput
+    
+    async def test_with_research_output():
+        """Test avec un fichier ResearchOutput sauvegardé."""
+        # Charger le ResearchOutput depuis le fichier JSON le plus récent
+        research_file = "research_output_impact_de_lintelligence_artifi_20251116_141136.json"
+        
+        try:
+            # Charger le ResearchOutput
+            with open(research_file, 'r', encoding='utf-8') as f:
+                research_data = json.load(f)
+            
+            research_output = ResearchOutput(**research_data)
+            logger.info(f"=== CHARGEMENT DU RESEARCH OUTPUT ===")
+            logger.info(f"Sujet: {research_output.query.topic}")
+            logger.info(f"URLs à extraire: {len(research_output.results)}")
+            
+            # Créer l'agent et traiter
+            agent = ContentExtractorAgent()
+            
+            logger.info(f"=== DÉBUT DE L'EXTRACTION DE CONTENU ===")
+            extraction_result = await agent.process_from_research_output(research_output)
+            
+            logger.info(f"=== RÉSULTATS D'EXTRACTION ===")
+            logger.info(f"URLs traitées: {extraction_result.total_urls}")
+            logger.info(f"Extractions réussies: {extraction_result.successful_extractions}")
+            logger.info(f"Extractions échouées: {extraction_result.failed_extractions}")
+            logger.info(f"Temps d'exécution: {extraction_result.execution_time:.2f}s")
+            
+            # Afficher les détails des documents extraits
+            for i, doc in enumerate(extraction_result.documents, 1):
+                logger.info(f"\n{i}. {doc.title}")
+                logger.info(f"   URL: {doc.url}")
+                logger.info(f"   Mots: {doc.word_count}")
+                logger.info(f"   Langue: {doc.language}")
+                logger.info(f"   Type: {doc.doc_type}")
+                logger.info(f"   Contenu (aperçu): {doc.content[:200]}...")
+            
+            # URLs qui ont échoué
+            if extraction_result.failed_urls:
+                logger.info(f"\n❌ URLs en échec:")
+                for url in extraction_result.failed_urls:
+                    logger.info(f"   • {url}")
+            
+            # === SAUVEGARDE DE L'EXTRACTION RESULT ===
+            logger.info(f"\n=== SAUVEGARDE DE L'EXTRACTION RESULT ===")
+            
+            try:
+                filename = save_extraction_result(extraction_result)
+                logger.info(f"✅ ExtractionResult sauvegardé dans: {filename}")
+                
+                # Affichage du contenu sauvegardé
+                logger.info("📄 Contenu sauvegardé:")
+                logger.info(f"  • Documents extraits: {len(extraction_result.documents)}")
+                logger.info(f"  • Temps d'extraction: {extraction_result.execution_time:.2f}s")
+                logger.info(f"  • Statistiques: {extraction_result.extraction_stats}")
+                
+                # Test de chargement pour vérifier l'intégrité
+                logger.info("=== Test de chargement ===")
+                loaded_result = load_extraction_result(filename)
+                logger.info(f"✅ ExtractionResult rechargé avec succès")
+                logger.info(f"  • Vérification: {len(loaded_result.documents)} documents chargés")
+                
+                # Comparaison des données
+                if loaded_result.successful_extractions == extraction_result.successful_extractions:
+                    logger.info("✅ Intégrité des données vérifiée")
+                else:
+                    logger.error("❌ Erreur d'intégrité des données")
+                
+                # Affichage du format JSON pour référence
+                logger.info("\n📋 EXEMPLE DE FORMAT JSON SAUVEGARDÉ:")
+                logger.info("-" * 50)
+                
+                # Créer un exemple compact pour l'affichage
+                example_result = {
+                    "documents": [
+                        {
+                            "title": doc.title,
+                            "url": str(doc.url),
+                            "content": doc.content[:200] + "...",
+                            "word_count": doc.word_count,
+                            "language": doc.language,
+                            "doc_type": doc.doc_type.value if doc.doc_type else None
+                        } for doc in extraction_result.documents[:2]  # Limiter à 2 documents
+                    ],
+                    "total_urls": extraction_result.total_urls,
+                    "successful_extractions": extraction_result.successful_extractions,
+                    "failed_extractions": extraction_result.failed_extractions,
+                    "failed_urls": extraction_result.failed_urls,
+                    "execution_time": extraction_result.execution_time,
+                    "extraction_stats": extraction_result.extraction_stats
+                }
+                
+                print(json.dumps(example_result, indent=2, ensure_ascii=False))
+                
+            except Exception as save_error:
+                logger.error(f"❌ Erreur lors de la sauvegarde: {save_error}")
+            
+        except FileNotFoundError:
+            logger.error(f"❌ Fichier ResearchOutput non trouvé: {research_file}")
+            logger.info("Utilisation de l'exemple avec URLs directes...")
+            await test_with_direct_urls()
+        except Exception as e:
+            logger.error(f"❌ Erreur lors du traitement: {e}")
+    
+    async def test_with_direct_urls():
+        """Test avec des URLs directes."""
+        urls = [
+            'https://www.iana.org/help/example-domains',
+        ]
+        
+        logger.info(f"=== TEST AVEC URLS DIRECTES ===")
+        documents = await extract_content_from_urls(urls)
+        for doc in documents:
+            logger.info(f"Title: {doc.title}, URL: {doc.url}, Word Count: {doc.word_count}, Language: {doc.language}, Content Length: {len(doc.content)}")
+    
+    # Choisir le test à exécuter
+    import sys
+    if len(sys.argv) > 1 and sys.argv[1] == "--direct":
+        asyncio.run(test_with_direct_urls())
+    else:
+        asyncio.run(test_with_research_output())

src/agents/global_synthesizer_agent.py

@@ -0,0 +1,826 @@
+"""
+Agent Global Synthesizer - Synthèse finale et génération de rapport.
+Prend les résumés de l'agent Summarizer et génère un rapport final structuré.
+"""
+
+import asyncio
+import hashlib
+import re
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+from src.agents.base_agent import BaseAgent
+from src.models.synthesis_models import (
+    GlobalSynthesisInput, GlobalSynthesisOutput, FinalReport,
+    ExecutiveSummary, ReportSection, SourceReference, Methodology,
+    ReportType, ReportFormat
+)
+from src.models.document_models import DocumentSummary, SummarizationOutput
+from src.models.state_models import AgentType
+from src.services.llm_service import LLMManager, LLMError
+from src.core.logging import setup_logger
+from config.prompts import GLOBAL_SYNTHESIZER_PROMPTS, SYSTEM_PROMPTS
+
+
+class GlobalSynthesizerAgent(BaseAgent[GlobalSynthesisInput, GlobalSynthesisOutput]):
+    """
+    Agent responsable de la synthèse finale et de la génération de rapport.
+    
+    Fonctionnalités:
+    - Synthèse de multiples résumés de documents
+    - Génération de rapport final structuré
+    - Analyse transversale et identification de patterns
+    - Évaluation de qualité et méthodologie
+    - Support de différents formats de rapport
+    - Génération de résumé exécutif
+    """
+    
+    def __init__(
+        self,
+        max_retries: int = 2,
+        timeout: float = 300.0  # 5 minutes pour la synthèse finale
+    ):
+        super().__init__(
+            agent_type=AgentType.WRITER,
+            name="global_synthesizer",
+            max_retries=max_retries,
+            timeout=timeout
+        )
+        
+        # Services
+        self.llm_manager = LLMManager()
+        
+        # Configuration
+        self.max_concurrent_synthesis = 3  # Nombre de tâches parallèles max
+        self.min_sources_for_analysis = 1  # Minimum de sources pour une analyse
+        
+    def validate_input(self, input_data: GlobalSynthesisInput) -> bool:
+        """
+        Valide les données d'entrée pour la synthèse globale.
+        
+        Args:
+            input_data: Input contenant les résumés à synthétiser
+            
+        Returns:
+            True si les données sont valides
+        """
+        if not input_data.summarization_output:
+            self.logger.error("Aucune sortie de summarization fournie")
+            return False
+        
+        if not input_data.summarization_output.summaries:
+            self.logger.error("Aucun résumé disponible pour la synthèse")
+            return False
+        
+        if len(input_data.summarization_output.summaries) < self.min_sources_for_analysis:
+            self.logger.error(f"Minimum {self.min_sources_for_analysis} résumé(s) requis")
+            return False
+        
+        if not input_data.original_topic or len(input_data.original_topic.strip()) < 3:
+            self.logger.error("Sujet original manquant ou trop court")
+            return False
+        
+        return True
+    
+    async def process(self, input_data: GlobalSynthesisInput) -> GlobalSynthesisOutput:
+        """
+        Traite la synthèse globale et génère le rapport final.
+        
+        Args:
+            input_data: Input contenant les résumés et options de synthèse
+            
+        Returns:
+            GlobalSynthesisOutput avec le rapport final
+        """
+        start_time = datetime.now()
+        self.logger.info(f"Début synthèse globale pour: '{input_data.original_topic}'")
+        self.logger.info(f"Nombre de résumés à synthétiser: {len(input_data.summarization_output.summaries)}")
+        
+        try:
+            # Étape 1: Préparation des données
+            prepared_data = self._prepare_synthesis_data(input_data)
+            
+            # Étape 2: Génération des sections du rapport en parallèle
+            report_sections = await self._generate_report_sections(prepared_data, input_data)
+            
+            # Étape 3: Génération du résumé exécutif
+            executive_summary = await self._generate_executive_summary(prepared_data, input_data)
+            
+            # Étape 4: Création de la méthodologie
+            methodology = self._create_methodology(input_data)
+            
+            # Étape 5: Création des références de sources
+            source_references = self._create_source_references(input_data.summarization_output.summaries)
+            
+            # Étape 6: Évaluation de qualité
+            quality_scores = await self._assess_quality(input_data, report_sections)
+            
+            # Étape 7: Assemblage du rapport final
+            final_report = self._assemble_final_report(
+                input_data, 
+                executive_summary,
+                report_sections,
+                methodology,
+                source_references,
+                quality_scores
+            )
+            
+            # Étape 8: Génération des formats alternatifs
+            formatted_outputs = await self._generate_formatted_outputs(final_report, input_data)
+            
+            # Calcul du temps de traitement
+            processing_time = (datetime.now() - start_time).total_seconds()
+            
+            # Création du résultat
+            result = GlobalSynthesisOutput(
+                final_report=final_report,
+                synthesis_metadata={
+                    "synthesis_approach": "comprehensive",
+                    "llm_model_used": "groq/llama-3.1-8b-instant",
+                    "quality_checks_passed": quality_scores["confidence_score"] > 0.6
+                },
+                processing_stats={
+                    "input_summaries": len(input_data.summarization_output.summaries),
+                    "synthesis_time": processing_time,
+                    "final_report_words": final_report.word_count,
+                    "sections_generated": len(report_sections)
+                },
+                formatted_outputs=formatted_outputs
+            )
+            
+            self.logger.info(f"Synthèse globale terminée en {processing_time:.2f}s")
+            self.logger.info(f"Rapport final: {final_report.word_count} mots, {len(report_sections)} sections")
+            
+            return result
+            
+        except Exception as e:
+            self.logger.error(f"Erreur lors de la synthèse globale: {str(e)}")
+            raise
+    
+    def _prepare_synthesis_data(self, input_data: GlobalSynthesisInput) -> Dict[str, Any]:
+        """Prépare les données nécessaires pour la synthèse."""
+        summaries = input_data.summarization_output.summaries
+        
+        # Compilation des résumés
+        document_summaries = []
+        for i, summary in enumerate(summaries, 1):
+            doc_summary = f"""
+Document {i}: {summary.title}
+URL: {summary.url}
+Résumé exécutif: {summary.executive_summary}
+Résumé détaillé: {summary.detailed_summary}
+Sentiment: {summary.sentiment}
+Crédibilité: {summary.credibility_score}
+Points clés: {[kp.title for kp in summary.key_points]}
+"""
+            document_summaries.append(doc_summary.strip())
+        
+        return {
+            "topic": input_data.original_topic,
+            "document_summaries": "\n\n".join(document_summaries),
+            "common_themes": input_data.summarization_output.common_themes,
+            "consensus_points": input_data.summarization_output.consensus_points,
+            "conflicting_views": input_data.summarization_output.conflicting_views,
+            "summaries_count": len(summaries),
+            "average_credibility": input_data.summarization_output.average_credibility
+        }
+    
+    async def _generate_report_sections(
+        self, 
+        prepared_data: Dict[str, Any], 
+        input_data: GlobalSynthesisInput
+    ) -> List[ReportSection]:
+        """Génère les sections principales du rapport."""
+        
+        # Tâches parallèles pour différentes sections
+        tasks = []
+        
+        # 1. Synthèse principale
+        main_synthesis_prompt = GLOBAL_SYNTHESIZER_PROMPTS['final_synthesis'].format(**prepared_data)
+        tasks.append(self._get_llm_response(main_synthesis_prompt, "main_synthesis"))
+        
+        # 2. Analyse thématique
+        thematic_prompt = GLOBAL_SYNTHESIZER_PROMPTS['thematic_analysis'].format(
+            topic=prepared_data["topic"],
+            summaries=prepared_data["document_summaries"]
+        )
+        tasks.append(self._get_llm_response(thematic_prompt, "thematic_analysis"))
+        
+        # Exécution des tâches en parallèle
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Traitement des résultats
+        sections = []
+        
+        for result in results:
+            if isinstance(result, Exception):
+                self.logger.error(f"Erreur génération section: {result}")
+                continue
+            
+            section_type, content = result
+            
+            if section_type == "main_synthesis":
+                # Parser la synthèse principale en sections
+                parsed_sections = self._parse_main_synthesis(content)
+                sections.extend(parsed_sections)
+            
+            elif section_type == "thematic_analysis":
+                # Ajouter l'analyse thématique comme section
+                thematic_section = ReportSection(
+                    title="Analyse Thématique Détaillée",
+                    content=content,
+                    order=2
+                )
+                sections.append(thematic_section)
+        
+        # Trier les sections par ordre
+        sections.sort(key=lambda x: x.order)
+        
+        return sections
+    
+    async def _generate_executive_summary(
+        self, 
+        prepared_data: Dict[str, Any], 
+        input_data: GlobalSynthesisInput
+    ) -> ExecutiveSummary:
+        """Génère le résumé exécutif."""
+        
+        # Préparation des données pour le résumé exécutif
+        analysis_data = {
+            "summaries": prepared_data["document_summaries"],
+            "themes": prepared_data["common_themes"],
+            "consensus": prepared_data["consensus_points"],
+            "conflicts": prepared_data["conflicting_views"],
+            "credibility": prepared_data["average_credibility"]
+        }
+        
+        prompt = GLOBAL_SYNTHESIZER_PROMPTS['executive_summary'].format(
+            topic=prepared_data["topic"],
+            analysis_data=str(analysis_data)
+        )
+        
+        try:
+            response = await self.llm_manager.get_completion(
+                prompt,
+                system_prompt=SYSTEM_PROMPTS['global_synthesizer'],
+                temperature=0.3,
+                max_tokens=1500
+            )
+            
+            # Parser la réponse pour extraire les composants
+            return self._parse_executive_summary(response)
+            
+        except Exception as e:
+            self.logger.error(f"Erreur génération résumé exécutif: {e}")
+            # Fallback: créer un résumé simple
+            return self._create_fallback_executive_summary(prepared_data)
+    
+    def _create_methodology(self, input_data: GlobalSynthesisInput) -> Methodology:
+        """Crée la description de la méthodologie utilisée."""
+        
+        analysis_methods = [
+            "Extraction automatique de contenu web",
+            "Analyse et résumé par intelligence artificielle",
+            "Synthèse thématique transversale",
+            "Évaluation de crédibilité des sources"
+        ]
+        
+        limitations = [
+            "Analyse limitée aux sources web accessibles publiquement",
+            "Évaluation de crédibilité basée sur des critères automatisés", 
+            "Synthèse générée par IA - vérification humaine recommandée"
+        ]
+        
+        summaries_count = len(input_data.summarization_output.summaries)
+        avg_credibility = input_data.summarization_output.average_credibility or 0.5
+        
+        quality_assessment = f"""
+Qualité des données évaluée sur {summaries_count} sources analysées.
+Score de crédibilité moyen: {avg_credibility:.2f}/1.0.
+Sources diversifiées avec analyse automatisée de sentiment et biais.
+"""
+        
+        return Methodology(
+            research_approach="Recherche web automatisée avec synthèse par IA",
+            sources_count=summaries_count,
+            analysis_methods=analysis_methods,
+            limitations=limitations,
+            data_quality_assessment=quality_assessment.strip()
+        )
+    
+    def _create_source_references(self, summaries: List[DocumentSummary]) -> List[SourceReference]:
+        """Crée les références bibliographiques des sources."""
+        
+        references = []
+        
+        for summary in summaries:
+            reference = SourceReference(
+                title=summary.title,
+                url=str(summary.url),
+                author=getattr(summary, 'author', None),
+                publication_date=getattr(summary, 'published_date', None),
+                credibility_score=summary.credibility_score,
+                citation_count=1  # Par défaut, chaque source est citée au moins une fois
+            )
+            references.append(reference)
+        
+        return references
+    
+    async def _assess_quality(
+        self, 
+        input_data: GlobalSynthesisInput, 
+        sections: List[ReportSection]
+    ) -> Dict[str, float]:
+        """Évalue la qualité de l'analyse et du rapport."""
+        
+        summaries = input_data.summarization_output.summaries
+        credibility_scores = [s.credibility_score for s in summaries if s.credibility_score]
+        
+        # Métriques de base
+        completeness_score = min(len(summaries) / 5.0, 1.0)  # Optimal à 5+ sources
+        
+        if credibility_scores:
+            reliability_score = sum(credibility_scores) / len(credibility_scores)
+        else:
+            reliability_score = 0.5
+        
+        coherence_score = min(len(sections) / 3.0, 1.0)  # Optimal à 3+ sections
+        
+        # Score de confiance global
+        confidence_score = (completeness_score * 0.4 + 
+                          reliability_score * 0.4 + 
+                          coherence_score * 0.2)
+        
+        return {
+            "confidence_score": confidence_score,
+            "completeness_score": completeness_score,
+            "reliability_score": reliability_score,
+            "coherence_score": coherence_score
+        }
+    
+    def _assemble_final_report(
+        self,
+        input_data: GlobalSynthesisInput,
+        executive_summary: ExecutiveSummary,
+        sections: List[ReportSection],
+        methodology: Methodology,
+        source_references: List[SourceReference],
+        quality_scores: Dict[str, float]
+    ) -> FinalReport:
+        """Assemble le rapport final complet."""
+        
+        # Génération de l'ID du rapport
+        report_id = self._generate_report_id(input_data.original_topic)
+        
+        # Titre du rapport
+        title = f"Analyse de Recherche: {input_data.original_topic.title()}"
+        
+        # Introduction générique
+        introduction = f"""
+            Ce rapport présente une analyse complète du sujet "{input_data.original_topic}" 
+            basée sur l'analyse de {len(source_references)} sources documentaires.
+
+            L'analyse a été réalisée par un système d'intelligence artificielle utilisant des 
+            méthodes d'extraction automatique de contenu, de résumé intelligent et de synthèse 
+            thématique transversale.
+        """.strip()
+        
+        # Conclusion générique
+        conclusion = f"""
+            Cette analyse de "{input_data.original_topic}" révèle des insights importants 
+            basés sur {len(source_references)} sources analysées. 
+
+            Les résultats présentés dans ce rapport offrent une perspective complète sur 
+            les différents aspects du sujet, avec un score de confiance global de 
+            {quality_scores['confidence_score']:.2f}/1.0.
+
+            Pour des décisions importantes, il est recommandé de compléter cette analyse 
+            par une vérification humaine et des sources supplémentaires si nécessaire.
+        """.strip()
+        
+        # Calcul du nombre de mots (approximatif)
+        word_count = (
+            len(introduction.split()) +
+            len(conclusion.split()) +
+            len(executive_summary.summary_text.split()) +
+            sum(len(section.content.split()) for section in sections)
+        )
+        
+        # Extraction des thèmes et tendances
+        summarization_output = input_data.summarization_output
+        
+        return FinalReport(
+            report_id=report_id,
+            title=title,
+            topic=input_data.original_topic,
+            report_type=input_data.report_type,
+            report_format=input_data.report_format,
+            
+            executive_summary=executive_summary,
+            introduction=introduction,
+            main_sections=sections,
+            conclusion=conclusion,
+            
+            key_themes=summarization_output.common_themes[:10],
+            consensus_points=summarization_output.consensus_points[:10],
+            conflicting_viewpoints=summarization_output.conflicting_views[:10],
+            emerging_trends=[],  # À améliorer avec analyse spécifique
+            
+            methodology=methodology,
+            sources=source_references,
+            
+            confidence_score=quality_scores["confidence_score"],
+            completeness_score=quality_scores["completeness_score"],
+            
+            total_sources_analyzed=len(source_references),
+            processing_time=0.0,  # Sera mis à jour par le processus principal
+            word_count=word_count
+        )
+    
+    async def _generate_formatted_outputs(
+        self, 
+        final_report: FinalReport, 
+        input_data: GlobalSynthesisInput
+    ) -> Dict[str, str]:
+        """Génère le rapport dans différents formats."""
+        
+        formatted_outputs = {}
+        
+        # Format Markdown (par défaut)
+        markdown_content = self._format_as_markdown(final_report)
+        formatted_outputs["markdown"] = markdown_content
+        
+        # Format texte simple
+        text_content = self._format_as_text(final_report)
+        formatted_outputs["text"] = text_content
+        
+        # Format HTML (basique)
+        html_content = self._format_as_html(final_report)
+        formatted_outputs["html"] = html_content
+        
+        return formatted_outputs
+    
+    def _format_as_markdown(self, report: FinalReport) -> str:
+        """Formate le rapport en Markdown."""
+        
+        content = f"""# {report.title}
+
+**Sujet:** {report.topic}  
+**Date de génération:** {report.generated_at.strftime('%d/%m/%Y %H:%M')}  
+**ID du rapport:** {report.report_id}
+
+---
+
+## Résumé Exécutif
+
+{report.executive_summary.summary_text}
+
+### Conclusions Principales
+{chr(10).join(f"- {finding}" for finding in report.executive_summary.key_findings)}
+
+### Insights Clés
+{chr(10).join(f"- {insight}" for insight in report.executive_summary.main_insights)}
+
+### Recommandations
+{chr(10).join(f"- {rec}" for rec in report.executive_summary.recommendations)}
+
+---
+
+## Introduction
+
+{report.introduction}
+
+---
+
+"""
+        
+        # Ajout des sections principales
+        for section in report.main_sections:
+            content += f"## {section.title}\n\n{section.content}\n\n---\n\n"
+        
+        # Thèmes et analyses
+        if report.key_themes:
+            content += "## Thèmes Principaux\n\n"
+            content += "\n".join(f"- {theme}" for theme in report.key_themes[:5])
+            content += "\n\n---\n\n"
+        
+        # Conclusion
+        content += f"## Conclusion\n\n{report.conclusion}\n\n---\n\n"
+        
+        # Méthodologie
+        content += f"""## M��thodologie
+
+            **Approche:** {report.methodology.research_approach}  
+            **Sources analysées:** {report.methodology.sources_count}  
+            **Score de confiance:** {report.confidence_score:.2f}/1.0
+
+            ### Méthodes d'Analyse
+            {chr(10).join(f"- {method}" for method in report.methodology.analysis_methods)}
+
+            ### Limitations
+            {chr(10).join(f"- {limitation}" for limitation in report.methodology.limitations)}
+
+            ---
+
+            ## Sources
+
+        """
+        
+        # Sources
+        for i, source in enumerate(report.sources, 1):
+            content += f"{i}. **{source.title}**  \n"
+            content += f"   URL: {source.url}  \n"
+            if source.credibility_score:
+                content += f"   Crédibilité: {source.credibility_score:.2f}/1.0  \n"
+            content += "\n"
+        
+        return content
+    
+    def _format_as_text(self, report: FinalReport) -> str:
+        """Formate le rapport en texte simple."""
+        content = f"""
+            {report.title}
+            {'=' * len(report.title)}
+
+            Sujet: {report.topic}
+            Date: {report.generated_at.strftime('%d/%m/%Y %H:%M')}
+            ID: {report.report_id}
+
+            RÉSUMÉ EXÉCUTIF
+            {'-' * 20}
+
+            {report.executive_summary.summary_text}
+
+            CONCLUSIONS PRINCIPALES:
+            {chr(10).join(f"• {finding}" for finding in report.executive_summary.key_findings)}
+
+            INTRODUCTION
+            {'-' * 15}
+
+            {report.introduction}
+
+        """
+        
+        # Sections principales
+        for section in report.main_sections:
+            content += f"\n{section.title.upper()}\n"
+            content += "-" * len(section.title) + "\n\n"
+            content += section.content + "\n\n"
+        
+        # Conclusion
+        content += f"CONCLUSION\n{'-' * 10}\n\n{report.conclusion}\n\n"
+        
+        return content
+    
+    def _format_as_html(self, report: FinalReport) -> str:
+        """Formate le rapport en HTML basique."""
+        
+        html = f"""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <title>{report.title}</title>
+                <meta charset="utf-8">
+                <style>
+                    body {{ font-family: Arial, sans-serif; margin: 40px; line-height: 1.6; }}
+                    h1 {{ color: #333; border-bottom: 2px solid #333; }}
+                    h2 {{ color: #666; border-bottom: 1px solid #ccc; }}
+                    .metadata {{ background: #f5f5f5; padding: 15px; border-radius: 5px; }}
+                    .section {{ margin: 20px 0; }}
+                    ul {{ margin: 10px 0; }}
+                </style>
+            </head>
+            <body>
+                <h1>{report.title}</h1>
+                
+                <div class="metadata">
+                    <strong>Sujet:</strong> {report.topic}<br>
+                    <strong>Date:</strong> {report.generated_at.strftime('%d/%m/%Y %H:%M')}<br>
+                    <strong>Score de confiance:</strong> {report.confidence_score:.2f}/1.0
+                </div>
+                
+                <h2>Résumé Exécutif</h2>
+                <p>{report.executive_summary.summary_text}</p>
+                
+                <h3>Conclusions Principales</h3>
+                <ul>
+                    {''.join(f"<li>{finding}</li>" for finding in report.executive_summary.key_findings)}
+                </ul>
+                
+                <h2>Introduction</h2>
+                <p>{report.introduction}</p>
+        """
+        
+        # Sections principales
+        for section in report.main_sections:
+            html += f"""
+                <h2>{section.title}</h2>
+                <div class="section">
+                    {section.content.replace(chr(10), '<br>')}
+                </div>
+            """
+        
+        # Conclusion
+        html += f"""
+            <h2>Conclusion</h2>
+            <p>{report.conclusion}</p>
+            
+            <h2>Sources</h2>
+            <ol>
+        """
+        
+        for source in report.sources:
+            html += f"""
+                    <li>
+                        <strong>{source.title}</strong><br>
+                        <a href="{source.url}">{source.url}</a>
+                        {f"<br>Crédibilité: {source.credibility_score:.2f}/1.0" if source.credibility_score else ""}
+                    </li>
+            """
+        
+        html += """
+            </ol>
+        </body>
+        </html>
+        """
+        
+        return html
+    
+    # Méthodes utilitaires
+    
+    async def _get_llm_response(self, prompt: str, task_type: str) -> tuple:
+        """Obtient une réponse LLM pour une tâche spécifique."""
+        try:
+            response = await self.llm_manager.get_completion(
+                prompt,
+                system_prompt=SYSTEM_PROMPTS['global_synthesizer'],
+                temperature=0.3,
+                max_tokens=3000
+            )
+            return task_type, response
+        except Exception as e:
+            self.logger.error(f"Erreur LLM pour {task_type}: {e}")
+            return task_type, f"Erreur: {str(e)}"
+    
+    def _parse_main_synthesis(self, content: str) -> List[ReportSection]:
+        """Parse la synthèse principale en sections structurées."""
+        
+        sections = []
+        
+        # Recherche des sections avec titres
+        section_pattern = r'##\s+(.+?)\n(.*?)(?=##|\Z)'
+        matches = re.findall(section_pattern, content, re.DOTALL)
+        
+        for i, (title, section_content) in enumerate(matches):
+            section = ReportSection(
+                title=title.strip(),
+                content=section_content.strip(),
+                order=i + 1
+            )
+            sections.append(section)
+        
+        # Si aucune section trouvée, créer une section générale
+        if not sections:
+            sections.append(ReportSection(
+                title="Analyse Générale",
+                content=content,
+                order=1
+            ))
+        
+        return sections
+    
+    def _parse_executive_summary(self, content: str) -> ExecutiveSummary:
+        """Parse le contenu du résumé exécutif."""
+        
+        # Extraction simplifiée - à améliorer selon le format LLM
+        lines = content.split('\n')
+        
+        key_findings = []
+        main_insights = []
+        recommendations = []
+        summary_text = content
+        
+        # Recherche des sections spécifiques
+        current_section = None
+        
+        for line in lines:
+            line = line.strip()
+            
+            if 'conclusion' in line.lower() or 'finding' in line.lower():
+                current_section = 'findings'
+            elif 'insight' in line.lower() or 'découverte' in line.lower():
+                current_section = 'insights'
+            elif 'recommandation' in line.lower() or 'recommendation' in line.lower():
+                current_section = 'recommendations'
+            elif line.startswith('-') or line.startswith('•'):
+                point = line[1:].strip()
+                if len(point) > 10:
+                    if current_section == 'findings':
+                        key_findings.append(point)
+                    elif current_section == 'insights':
+                        main_insights.append(point)
+                    elif current_section == 'recommendations':
+                        recommendations.append(point)
+        
+        # Fallback: extraire les premières phrases comme findings
+        if not key_findings:
+            sentences = content.split('.')[:3]
+            key_findings = [s.strip() + '.' for s in sentences if len(s.strip()) > 20]
+        
+        return ExecutiveSummary(
+            key_findings=key_findings[:5],
+            main_insights=main_insights[:5],
+            recommendations=recommendations[:5],
+            summary_text=summary_text[:500] + "..." if len(summary_text) > 500 else summary_text
+        )
+    
+    def _create_fallback_executive_summary(self, prepared_data: Dict[str, Any]) -> ExecutiveSummary:
+        """Crée un résumé exécutif de fallback."""
+        
+        return ExecutiveSummary(
+            key_findings=[
+                f"Analyse basée sur {prepared_data['summaries_count']} sources documentaires",
+                f"Score de crédibilité moyen: {prepared_data.get('average_credibility', 0.5):.2f}/1.0",
+                "Synthèse générée automatiquement par IA"
+            ],
+            main_insights=[
+                "Analyse transversale des différentes perspectives sur le sujet",
+                "Identification des thèmes récurrents et des consensus",
+                "Évaluation critique des sources et de leur fiabilité"
+            ],
+            recommendations=[
+                "Vérification humaine recommandée pour les décisions importantes",
+                "Complément par des sources supplémentaires si nécessaire",
+                "Mise à jour régulière de l'analyse"
+            ],
+            summary_text=f"Cette analyse du sujet '{prepared_data['topic']}' synthétise {prepared_data['summaries_count']} sources documentaires pour fournir une vue d'ensemble complète et objective."
+        )
+    
+    def _generate_report_id(self, topic: str) -> str:
+        """Génère un ID unique pour le rapport."""
+        
+        # Hash du sujet + timestamp
+        topic_hash = hashlib.md5(topic.encode()).hexdigest()[:8]
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M")
+        
+        return f"rpt_{timestamp}_{topic_hash}"
+    
+    # #fonction global_summary from summarization output
+    async def process_from_summarization_output(self, summarization_output: SummarizationOutput) -> GlobalSynthesisOutput:
+        """Génère une synthèse globale à partir de la sortie du summarizer."""
+        # Utilise le topic du fichier si non fourni
+        topic_val =  (getattr(summarization_output, "topic", None) or "Sujet de synthèse")
+        synthesis_input = GlobalSynthesisInput(
+            summarization_output=summarization_output,
+            original_topic=topic_val
+        )
+        if not self.validate_input(synthesis_input):
+            self.logger.error("Entrée de synthèse invalide. Abandon.")
+            raise ValueError("Invalid synthesis input")
+        
+        self.logger.info(f"Démarrage de la synthèse globale pour '{synthesis_input.original_topic}'...")
+        output = await self.process(synthesis_input)
+        return output
+     
+
+
+# Exemple d'utilisation
+if __name__ == "__main__":
+    import asyncio
+    from src.models.document_models import Document, DocumentSummary, SummarizationOutput, KeyPoint
+    
+    import argparse
+    import json
+    import os
+    import sys
+    from pathlib import Path
+
+    logger = setup_logger("global_synthesizer_cli")
+
+    def load_summarization_output(json_path):
+        with open(json_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return SummarizationOutput(**data)
+
+    async def run_synthesis(input_json, topic=None, output_json=None):
+        summarization_output = load_summarization_output(input_json)
+        
+        agent = GlobalSynthesizerAgent()
+        output = await agent.process_from_summarization_output(summarization_output)
+        # Génération du nom de fichier si non fourni
+        if not output_json:
+            ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_json = f"synthesis_output_{ts}.json"
+        # Correction : model_dump_json n'accepte pas ensure_ascii
+        with open(output_json, "w", encoding="utf-8") as f:
+            f.write(output.model_dump_json(indent=2))
+        logger.info(f"Synthèse sauvegardée dans {output_json}")
+        print(f"\nSynthèse globale terminée. Rapport sauvegardé dans: {output_json}")
+
+    if __name__ == "__main__":
+        parser = argparse.ArgumentParser(description="Global Synthesizer Agent CLI")
+        parser.add_argument("--input", required=True, help="Chemin du fichier JSON de sortie du summarizer")
+        parser.add_argument("--topic", required=False, help="Sujet de recherche (optionnel)")
+        parser.add_argument("--output", required=False, help="Chemin du fichier de sortie JSON (optionnel)")
+        args = parser.parse_args()
+        asyncio.run(run_synthesis(args.input, args.topic, args.output))

src/agents/researcher_agent.py

@@ -0,0 +1,642 @@
+"""
+Agent Researcher - Premier agent du pipeline.
+Effectue la recherche web sur un sujet donné et retourne des sources pertinentes.
+"""
+
+from typing import List, Dict, Any, Optional
+import asyncio
+from datetime import datetime
+
+from src.agents.base_agent import BaseAgent
+from src.models.research_models import ResearchQuery, ResearchOutput, SearchResult
+from src.models.state_models import AgentType
+from src.services.search_api import SearchAPIManager, SearchAPIError
+from src.services.llm_service import LLMService, LLMError
+from src.core.logging import setup_logger
+from config.prompts import RESEARCHER_PROMPT, SYSTEM_PROMPTS, KEYWORD_EXTRACTION_PROMPT
+
+
+class ResearcherAgent(BaseAgent[ResearchQuery, ResearchOutput]):
+    """
+    Agent de recherche web.
+    
+    Responsabilités:
+    - Recevoir une requête de recherche
+    - Effectuer des recherches sur le web via des APIs
+    - Analyser et filtrer les résultats
+    - Retourner une liste de sources pertinentes
+    """
+    
+    def __init__(
+        self,
+        name: str = "researcher",
+        max_retries: int = 3,
+        timeout: float = 120.0  # 2 minutes pour la recherche
+    ):
+        super().__init__(
+            agent_type=AgentType.RESEARCHER,
+            name=name,
+            max_retries=max_retries,
+            timeout=timeout
+        )
+        
+        # Initialisation du gestionnaire de recherche
+        try:
+            self.search_manager = SearchAPIManager()
+            self.logger.info(f"APIs disponibles: {self.search_manager.get_available_apis()}")
+        except Exception as e:
+            self.logger.error(f"Impossible d'initialiser le gestionnaire de recherche: {e}")
+            raise
+        
+        # Initialisation du service LLM pour l'extraction de mots-clés
+        try:
+            self.llm_service = LLMService()
+            self.logger.info("Service LLM initialisé pour l'extraction de mots-clés")
+        except Exception as e:
+            self.logger.error(f"Impossible d'initialiser le service LLM: {e}")
+            raise
+        
+        # Configuration de recherche
+        self.default_search_params = {
+            "preferred_api": "tavily",
+            "search_depth": "basic",
+            "include_answer": True
+        }
+    
+    def validate_input(self, input_data: ResearchQuery) -> bool:
+        """
+        Valide la requête de recherche.
+        
+        Args:
+            input_data: Requête de recherche à valider
+            
+        Returns:
+            True si la requête est valide
+        """
+        if not input_data.topic or len(input_data.topic.strip()) < 3:
+            self.logger.error("Le sujet de recherche doit contenir au moins 3 caractères")
+            return False
+        
+        if input_data.max_results <= 0 or input_data.max_results > 20:
+            self.logger.error("Le nombre de résultats doit être entre 1 et 20")
+            return False
+        
+        return True
+    
+    async def process(self, input_data: ResearchQuery) -> ResearchOutput:
+        """
+        Traite la requête de recherche.
+        
+        Args:
+            input_data: Requête de recherche
+            
+        Returns:
+            Résultats de recherche structurés
+        """
+        start_time = datetime.now()
+        self.logger.info(f"Début de recherche pour: '{input_data.topic}'")
+        
+        # Préparation de la requête
+        search_query = self._prepare_search_query(input_data)
+        self.logger.info(f"Requête préparée: '{search_query}'")
+        
+        # Configuration des paramètres de recherche
+        search_params = {
+            **self.default_search_params,
+            "search_depth": input_data.search_depth,
+            "max_results": input_data.max_results
+        }
+        
+        try:
+            # Recherche principale
+            results = await self.search_manager.search(
+                query=search_query,
+                **search_params
+            )
+            
+            # Post-traitement des résultats
+            filtered_results = self._filter_and_rank_results(
+                results, 
+                input_data.topic,
+                input_data.keywords
+            )
+            
+            # Limitation au nombre demandé
+            final_results = filtered_results[:input_data.max_results]
+            
+            # Calcul du temps de recherche
+            search_time = (datetime.now() - start_time).total_seconds()
+            
+            # Création de l'output
+            research_output = ResearchOutput(
+                query=input_data,
+                results=final_results,
+                total_found=len(results),
+                search_time=search_time,
+                search_engine=search_params["preferred_api"],
+                timestamp=datetime.now()
+            )
+            
+            self.logger.info(
+                f"Recherche terminée: {len(final_results)} résultats finaux "
+                f"sur {len(results)} trouvés en {search_time:.2f}s"
+            )
+            
+            return research_output
+            
+        except SearchAPIError as e:
+            self.logger.error(f"Erreur de recherche: {e}")
+            raise
+        except Exception as e:
+            self.logger.error(f"Erreur inattendue lors de la recherche: {e}")
+            raise
+    
+    def _prepare_search_query(self, query: ResearchQuery) -> str:
+        """
+        Prépare la requête de recherche en optimisant les mots-clés.
+        
+        Args:
+            query: Requête originale
+            
+        Returns:
+            Requête optimisée pour la recherche
+        """
+        # Commencer par le sujet principal
+        search_terms = [query.topic]
+        
+        # Ajouter les mots-clés s'ils existent
+        if query.keywords:
+            # Éviter la redondance avec le sujet principal
+            unique_keywords = [
+                kw for kw in query.keywords 
+                if kw.lower() not in query.topic.lower()
+            ]
+            search_terms.extend(unique_keywords)
+        
+        # Joindre avec des espaces
+        search_query = " ".join(search_terms)
+        
+        ##################### A Améliorer selon ce qu'on veut rechercher #################################
+                 # Optimisations spécifiques selon la profondeur 
+        ##################################################################################################
+        if query.search_depth == "advanced":
+            # Pour les recherches avancées, ajouter des termes de contexte
+            if "intelligence artificielle" in search_query.lower() or "ia" in search_query.lower():
+                search_query += " 2024 2025 récent"
+            if "emploi" in search_query.lower() or "travail" in search_query.lower():
+                search_query += " marché impact"
+        
+        return search_query.strip()
+    
+    def _filter_and_rank_results(
+        self, 
+        results: List[SearchResult], 
+        topic: str,
+        keywords: List[str]
+    ) -> List[SearchResult]:
+        """
+        Filtre et classe les résultats par pertinence.
+        
+        Args:
+            results: Résultats bruts de la recherche
+            topic: Sujet de recherche original
+            keywords: Mots-clés de recherche
+            
+        Returns:
+            Résultats filtrés et classés
+        """
+        if not results:
+            return []
+        
+        # Mots-clés pour le scoring (topic + keywords)
+        scoring_terms = [topic.lower()] + [kw.lower() for kw in keywords]
+        
+        # Calcul du score de pertinence pour chaque résultat
+        scored_results = []
+        for result in results:
+            score = self._calculate_relevance_score(result, scoring_terms)
+            
+            # Mise à jour du score dans le résultat
+            result.score = score
+            scored_results.append(result)
+        
+        # Tri par score décroissant
+        scored_results.sort(key=lambda x: x.score or 0, reverse=True)
+        
+        # Filtrage des résultats de faible qualité
+        min_score = 0.1  # Score minimum acceptable
+        filtered_results = [r for r in scored_results if (r.score or 0) >= min_score]
+        
+        self.logger.info(f"Filtrage: {len(filtered_results)} résultats conservés sur {len(results)}")
+        
+        return filtered_results
+    
+    #Améiorer le score selon le site 
+    # EX: if result.url.endswith(".edu") or result.url.endswith(".gov"):
+    # score += 0.1
+    def _calculate_relevance_score(
+        self, 
+        result: SearchResult, 
+        scoring_terms: List[str]
+    ) -> float:
+        """
+        Calcule un score de pertinence pour un résultat.
+        
+        Args:
+            result: Résultat à scorer
+            scoring_terms: Termes de référence pour le scoring
+            
+        Returns:
+            Score entre 0 et 1
+        """
+        score = 0.0
+        
+        # Texte à analyser (titre + snippet)
+        text_to_analyze = f"{result.title} {result.snippet}".lower()
+        
+        # Score basé sur la présence des termes de recherche
+        term_matches = 0
+        for term in scoring_terms:
+            if term in text_to_analyze:
+                term_matches += 1
+        
+        if scoring_terms:
+            term_score = term_matches / len(scoring_terms)
+            score += term_score * 0.6  # 60% du score
+        
+        # Bonus pour les titres pertinents
+        title_matches = sum(1 for term in scoring_terms if term in result.title.lower())
+        if scoring_terms:
+            title_score = title_matches / len(scoring_terms)
+            score += title_score * 0.3  # 30% du score
+        
+        # Bonus pour les sources récentes (si date disponible)
+        if result.published_date:
+            days_old = (datetime.now() - result.published_date.replace(tzinfo=None)).days
+            if days_old <= 365:  # Moins d'un an
+                recency_score = max(0, 1 - (days_old / 365))
+                score += recency_score * 0.1  # 10% du score
+        
+        # Score existant de l'API (si disponible)
+        if result.score and result.score > 0:
+            score = (score + result.score) / 2  # Moyenne avec le score API
+        
+        return min(score, 1.0)  # Cap à 1.0
+    
+    async def extract_keywords_with_llm(self, topic: str) -> List[str]:
+        """
+        Extrait automatiquement des mots-clés pertinents à partir du sujet
+        en utilisant le service LLM.
+        
+        Args:
+            topic: Sujet de recherche
+            
+        Returns:
+            Liste de mots-clés extraits
+        """
+        try:
+            self.logger.info(f"Extraction de mots-clés pour: '{topic}'")
+            
+            # Préparation du prompt avec le template
+            prompt = KEYWORD_EXTRACTION_PROMPT.format(topic=topic)
+            
+            # Appel au service LLM
+            response = await self.llm_service.generate_completion(
+                prompt=prompt,
+                system_prompt="Tu es un expert en analyse sémantique spécialisé dans l'extraction de mots-clés pour la recherche web.",
+                temperature=0.3,  # Faible température pour plus de cohérence
+                max_tokens=150    # Limite pour les mots-clés
+            )
+            
+            # Parsing de la réponse
+            keywords = self._parse_keywords_response(response)
+            
+            self.logger.info(f"Mots-clés extraits: {keywords}")
+            return keywords
+            
+        except LLMError as e:
+            self.logger.error(f"Erreur LLM lors de l'extraction de mots-clés: {e}")
+            # Fallback: extraction simple basée sur le sujet
+            return self._extract_keywords_fallback(topic)
+        except Exception as e:
+            self.logger.error(f"Erreur inattendue lors de l'extraction de mots-clés: {e}")
+            return self._extract_keywords_fallback(topic)
+    
+    def _parse_keywords_response(self, response: str) -> List[str]:
+        """
+        Parse la réponse du LLM pour extraire les mots-clés.
+        
+        Args:
+            response: Réponse brute du LLM
+            
+        Returns:
+            Liste de mots-clés nettoyés
+        """
+        # Nettoyer la réponse
+        response = response.strip()
+        
+        # Supprimer les préfixes potentiels
+        for prefix in ["mots-clés:", "keywords:", "réponse:", "voici:", "liste:"]:
+            if response.lower().startswith(prefix):
+                response = response[len(prefix):].strip()
+        
+        # Séparer par virgules
+        keywords = [kw.strip() for kw in response.split(",")]
+        
+        # Nettoyer et filtrer
+        cleaned_keywords = []
+        for kw in keywords:
+            # Supprimer les numéros et tirets
+            kw = kw.strip("0123456789.-\t\n ")
+            
+            # Filtrer les mots trop courts ou vides
+            if len(kw) >= 2 and kw.lower() not in ["et", "ou", "le", "la", "les", "de", "du", "des"]:
+                cleaned_keywords.append(kw)
+        
+        # Limiter le nombre de mots-clés
+        return cleaned_keywords[:7]
+    
+    def _extract_keywords_fallback(self, topic: str) -> List[str]:
+        """
+        Méthode de fallback pour extraire des mots-clés simples.
+        
+        Args:
+            topic: Sujet de recherche
+            
+        Returns:
+            Liste de mots-clés basiques
+        """
+        self.logger.info("Utilisation du fallback pour l'extraction de mots-clés")
+        
+        # Mots communs à ignorer
+        stop_words = {
+            "le", "la", "les", "de", "du", "des", "et", "ou", "sur", "dans", 
+            "avec", "pour", "par", "en", "à", "un", "une", "ce", "cette", "ces"
+        }
+        
+        # Extraction simple basée sur les mots significatifs
+        words = topic.lower().split()
+        keywords = [word for word in words if len(word) >= 3 and word not in stop_words]
+        
+        return keywords[:5]  # Limiter à 5 mots-clés max
+    
+    async def search_with_fallback(
+        self, 
+        query: str, 
+        max_results: int = 5
+    ) -> List[SearchResult]:
+        """
+        Méthode utilitaire pour recherche simple avec fallback.
+        
+        Args:
+            query: Requête de recherche simple
+            max_results: Nombre de résultats souhaités
+            
+        Returns:
+            Liste des résultats
+        """
+        research_query = ResearchQuery(
+            topic=query,
+            max_results=max_results
+        )
+        
+        output = await self.process(research_query)
+        return output.results
+    
+    def get_search_stats(self) -> Dict[str, Any]:
+        """
+        Retourne les statistiques de recherche de l'agent.
+        
+        Returns:
+            Dictionnaire avec les statistiques
+        """
+        base_stats = self.get_status()
+        search_stats = {
+            "available_apis": self.search_manager.get_available_apis(),
+            "search_params": self.default_search_params
+        }
+        
+        return {**base_stats, **search_stats}
+    
+
+# Fonctions utilitaires pour la sauvegarde
+def save_research_output(output: ResearchOutput, filename: str = None) -> str:
+    """
+    Sauvegarde un ResearchOutput dans un fichier JSON.
+    
+    Args:
+        output: Sortie de recherche à sauvegarder
+        filename: Nom du fichier (optionnel)
+        
+    Returns:
+        Nom du fichier sauvegardé
+    """
+    import json
+    from datetime import datetime
+    
+    if not filename:
+        # Générer un nom de fichier basé sur le sujet et timestamp
+        clean_topic = "".join(c for c in output.query.topic if c.isalnum() or c in (' ', '-', '_')).rstrip()
+        clean_topic = clean_topic.replace(' ', '_')[:30]
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"research_output_{clean_topic}_{timestamp}.json"
+    
+    try:
+        # Conversion en dictionnaire avec sérialisation des dates
+        output_dict = output.model_dump(mode='json')
+        
+        # Sauvegarde dans le fichier
+        with open(filename, 'w', encoding='utf-8') as f:
+            json.dump(output_dict, f, indent=2, ensure_ascii=False)
+        
+        return filename
+        
+    except Exception as e:
+        raise Exception(f"Erreur lors de la sauvegarde: {e}")
+
+
+def load_research_output(filename: str) -> ResearchOutput:
+    """
+    Charge un ResearchOutput depuis un fichier JSON.
+    
+    Args:
+        filename: Nom du fichier à charger
+        
+    Returns:
+        ResearchOutput chargé
+    """
+    import json
+    
+    try:
+        with open(filename, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # Reconstruction du ResearchOutput
+        return ResearchOutput(**data)
+        
+    except Exception as e:
+        raise Exception(f"Erreur lors du chargement: {e}")
+
+
+# Ecrire un main pour tester ici la classe
+if __name__ == "__main__":
+    import asyncio
+    import json
+    from datetime import datetime
+    from src.core.logging import setup_logger
+    logger = setup_logger("researcher_agent_test")
+    
+    async def main():
+        agent = ResearcherAgent()
+        
+        # Test 1: Extraction automatique de mots-clés avec LLM
+        topic = "impact de l'intelligence artificielle sur le marché de l'emploi"
+        logger.info(f"=== Test d'extraction de mots-clés pour: {topic} ===")
+        
+        try:
+            # Extraction automatique des mots-clés
+            keywords = await agent.extract_keywords_with_llm(topic)
+            logger.info(f"Mots-clés extraits automatiquement: {keywords}")
+            
+            # Création de la requête avec les mots-clés extraits
+            query = ResearchQuery(
+                topic=topic,
+                keywords=keywords,  # Utilisation des mots-clés extraits automatiquement
+                max_results=2,
+                search_depth="basic"
+            )   
+            
+            if agent.validate_input(query):
+                logger.info("=== Début de la recherche avec mots-clés automatiques ===")
+                output = await agent.process(query)
+                logger.info(f"Résultats obtenus: {len(output.results)}")
+                
+                # Affichage des résultats
+                for i, res in enumerate(output.results, 1):
+                    logger.info(f"{i}. {res.title}")
+                    logger.info(f"   URL: {res.url}")
+                    logger.info(f"   Score: {res.score:.3f}")
+                    logger.info(f"   Snippet: {res.snippet[:100]}...")
+                    logger.info("")
+                
+                # === SAUVEGARDE DU RESEARCHOUTPUT ===
+                logger.info("=== Sauvegarde du ResearchOutput ===")
+                
+                try:
+                    filename = save_research_output(output)
+                    logger.info(f"✅ ResearchOutput sauvegardé dans: {filename}")
+                    
+                    # Affichage du contenu sauvegardé
+                    logger.info("📄 Contenu sauvegardé:")
+                    logger.info(f"  • Sujet: {output.query.topic}")
+                    logger.info(f"  • Mots-clés: {output.query.keywords}")
+                    logger.info(f"  • Nombre de résultats: {len(output.results)}")
+                    logger.info(f"  • Temps de recherche: {output.search_time:.2f}s")
+                    logger.info(f"  • Moteur utilisé: {output.search_engine}")
+                    logger.info(f"  • Timestamp: {output.timestamp}")
+                    
+                    # Test de chargement pour vérifier l'intégrité
+                    logger.info("=== Test de chargement ===")
+                    loaded_output = load_research_output(filename)
+                    logger.info(f"✅ ResearchOutput rechargé avec succès")
+                    logger.info(f"  • Vérification: {len(loaded_output.results)} résultats chargés")
+                    
+                    # Comparaison des données
+                    if loaded_output.query.topic == output.query.topic:
+                        logger.info("✅ Intégrité des données vérifiée")
+                    else:
+                        logger.error("❌ Erreur d'intégrité des données")
+                    
+                    # Affichage du format JSON pour référence
+                    logger.info("\n📋 EXEMPLE DE FORMAT JSON SAUVEGARDÉ:")
+                    logger.info("-" * 50)
+                    
+                    # Créer un exemple compact pour l'affichage
+                    example_output = {
+                        "query": {
+                            "topic": output.query.topic,
+                            "keywords": output.query.keywords[:3],  # Limiter pour l'affichage
+                            "max_results": output.query.max_results,
+                            "search_depth": output.query.search_depth
+                        },
+                        "results": [
+                            {
+                                "title": res.title,
+                                "url": str(res.url),
+                                "snippet": res.snippet[:100] + "...",
+                                "score": res.score
+                            } for res in output.results[:2]  # Limiter à 2 résultats pour l'affichage
+                        ],
+                        "total_found": output.total_found,
+                        "search_time": output.search_time,
+                        "search_engine": output.search_engine,
+                        "timestamp": output.timestamp.isoformat()
+                    }
+                    
+                    print(json.dumps(example_output, indent=2, ensure_ascii=False))
+                    
+                except Exception as save_error:
+                    logger.error(f"❌ Erreur lors de la sauvegarde: {save_error}")
+                
+            else:
+                logger.error("Requête invalide.")
+                
+        except Exception as e:
+            logger.error(f"Erreur lors du test: {e}")
+    
+    # Fonction utilitaire pour tester la sauvegarde indépendamment
+    async def test_save_load():
+        """Test spécifique de sauvegarde/chargement."""
+        logger.info("=== TEST SAUVEGARDE/CHARGEMENT SEUL ===")
+        
+        # Créer un ResearchOutput factice pour le test
+        from datetime import datetime
+        
+        fake_results = [
+            SearchResult(
+                title="Test Article 1",
+                url="https://example.com/test1",
+                snippet="Ceci est un test de snippet pour l'article 1",
+                score=0.85
+            ),
+            SearchResult(
+                title="Test Article 2", 
+                url="https://example.com/test2",
+                snippet="Ceci est un test de snippet pour l'article 2",
+                score=0.78
+            )
+        ]
+        
+        fake_query = ResearchQuery(
+            topic="test sauvegarde",
+            keywords=["test", "sauvegarde", "json"],
+            max_results=2
+        )
+        
+        fake_output = ResearchOutput(
+            query=fake_query,
+            results=fake_results,
+            total_found=2,
+            search_time=1.5,
+            search_engine="test",
+            timestamp=datetime.now()
+        )
+        
+        try:
+            # Test de sauvegarde
+            filename = save_research_output(fake_output, "test_research_output.json")
+            logger.info(f"✅ Test sauvegarde réussi: {filename}")
+            
+            # Test de chargement
+            loaded = load_research_output(filename)
+            logger.info(f"✅ Test chargement réussi: {len(loaded.results)} résultats")
+            
+        except Exception as e:
+            logger.error(f"❌ Test sauvegarde/chargement échoué: {e}")
+    
+    # Choix du test à exécuter
+    import sys
+    if len(sys.argv) > 1 and sys.argv[1] == "--test-save":
+        asyncio.run(test_save_load())
+    else:
+        asyncio.run(main())

src/agents/summarizer_agent.py

@@ -0,0 +1,669 @@
+"""
+Agent Summarizer - Analyse et résumé de documents.
+Crée des résumés structurés et des analyses approfondies des documents extraits.
+"""
+
+import asyncio
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import hashlib
+
+from src.agents.base_agent import BaseAgent
+from src.models.document_models import Document, DocumentSummary, SummarizationOutput, KeyPoint, Citation
+from src.models.state_models import AgentType
+from src.services.llm_service import LLMManager, LLMError
+from src.services.text_chunking import ChunkingManager, TextChunk
+from src.core.logging import setup_logger
+from config.prompts import SUMMARIZER_PROMPTS, SYSTEM_PROMPTS
+import hashlib
+import re
+
+
+class SummarizationInput:
+    """Input pour l'agent Summarizer."""
+    
+    def __init__(
+        self,
+        documents: List[Document],
+        summary_options: Optional[Dict[str, Any]] = None
+    ):
+        self.documents = documents
+        self.summary_options = summary_options or {}
+        
+        # Options par défaut
+        self.include_sentiment = self.summary_options.get('include_sentiment', True)
+        self.include_citations = self.summary_options.get('include_citations', True)
+        self.max_key_points = self.summary_options.get('max_key_points', 5)
+        self.detailed_analysis = self.summary_options.get('detailed_analysis', True)
+        self.chunk_large_docs = self.summary_options.get('chunk_large_docs', True)
+        self.max_doc_size = self.summary_options.get('max_doc_size', 8000)  # caractères
+
+
+class SummarizerAgent(BaseAgent):
+    """
+    Agent responsable de l'analyse et du résumé de documents.
+    
+    Fonctionnalités:
+    - Résumé exécutif et détaillé
+    - Extraction de points clés et arguments
+    - Analyse de sentiment et biais
+    - Gestion des documents longs via chunking
+    - Citations et statistiques importantes
+    - Évaluation de crédibilité
+    """
+    
+    def __init__(
+        self,
+        max_retries: int = 2,
+        timeout: float = 600.0  # 10 minutes pour traiter plusieurs documents
+    ):
+        super().__init__(
+            agent_type=AgentType.READER,
+            name="summarizer",
+            max_retries=max_retries,
+            timeout=timeout
+        )
+        
+        # Services
+        self.llm_manager = LLMManager()
+        self.chunking_manager = ChunkingManager()
+        
+        # Configuration
+        self.max_concurrent_summaries = 3 # maximum de résumés parallèles
+        self.chunk_overlap_threshold = 6000  # Seuil pour le chunking en caractères
+    
+    def validate_input(self, input_data: SummarizationInput) -> bool:
+        """
+        Valide les données d'entrée pour la summarization.
+        
+        Args:
+            input_data: Input contenant les documents à résumer
+            
+        Returns:
+            True si les données sont valides
+        """
+        if not input_data.documents:
+            self.logger.error("Aucun document fourni pour la summarization")
+            return False
+        
+        if len(input_data.documents) > 20:  # Limite raisonnable
+            self.logger.error(f"Trop de documents ({len(input_data.documents)}), maximum 20")
+            return False
+        
+        # Vérifier que les documents ont du contenu
+        valid_docs = [doc for doc in input_data.documents if doc.content and doc.content.strip()]
+        if not valid_docs:
+            self.logger.error("Aucun document avec contenu valide")
+            return False
+        
+        return True
+    
+    async def process(self, input_data: SummarizationInput) -> SummarizationOutput:
+        """
+        Traite la summarization des documents.
+        
+        Args:
+            input_data: Input contenant les documents à résumer
+            
+        Returns:
+            SummarizationOutput avec tous les résumés
+        """
+        start_time = datetime.now()
+        self.logger.info(f"Début summarization de {len(input_data.documents)} documents")
+        
+        # Filtrer les documents valides
+        valid_documents = [doc for doc in input_data.documents if doc.content and doc.content.strip()]
+        self.logger.info(f"Documents valides à traiter: {len(valid_documents)}")
+        
+        try:
+            # Traitement parallèle des résumés
+            summaries = await self._summarize_all_documents(valid_documents, input_data)
+            
+            # Analyse globale
+            global_analysis = await self._perform_global_analysis(summaries)
+            
+            # Calcul des métriques
+            total_processing_time = (datetime.now() - start_time).total_seconds()
+            average_credibility = self._calculate_average_credibility(summaries)
+            
+            # Création du résultat
+            result = SummarizationOutput(
+                summaries=summaries,
+                total_documents=len(input_data.documents),
+                total_processing_time=total_processing_time,
+                average_credibility=average_credibility,
+                common_themes=global_analysis.get('common_themes', []),
+                consensus_points=global_analysis.get('consensus_points', []),
+                conflicting_views=global_analysis.get('conflicting_views', [])
+            )
+            
+            self.logger.info(
+                f"Summarization terminée: {len(summaries)} résumés créés en {total_processing_time:.2f}s"
+            )
+            
+            return result
+            
+        except Exception as e:
+            self.logger.error(f"Erreur lors de la summarization: {str(e)}")
+            raise
+    
+    async def _summarize_all_documents(
+        self, 
+        documents: List[Document], 
+        input_data: SummarizationInput
+    ) -> List[DocumentSummary]:
+        """Résume tous les documents en parallèle."""
+        semaphore = asyncio.Semaphore(self.max_concurrent_summaries)
+        
+        async def summarize_single(doc: Document) -> DocumentSummary:
+            async with semaphore:
+                try:
+                    return await self._summarize_document(doc, input_data)
+                except Exception as e:
+                    self.logger.error(f"Erreur résumé document {doc.title}: {e}")
+                    # Créer un résumé d'erreur minimal
+                    return self._create_error_summary(doc, str(e))
+        
+        # Lancer tous les résumés en parallèle
+        tasks = [summarize_single(doc) for doc in documents]
+        summaries = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Filtrer les résultats valides
+        valid_summaries = []
+        for summary in summaries:
+            if isinstance(summary, DocumentSummary):
+                valid_summaries.append(summary)
+            else:
+                self.logger.error(f"Résumé invalide: {summary}")
+        
+        return valid_summaries
+    
+    async def _summarize_document(self, document: Document, input_data: SummarizationInput) -> DocumentSummary:
+        """Résume un document individuel."""
+        start_time = datetime.now()
+        doc_id = self._generate_document_id(document)
+        
+        self.logger.info(f"Résumé document: {document.title} ({len(document.content)} caractères)")
+        
+        # Décider si chunking nécessaire
+        if (input_data.chunk_large_docs and 
+            len(document.content) > self.chunk_overlap_threshold):
+            summary = await self._summarize_large_document(document, input_data)
+        else:
+            summary = await self._summarize_standard_document(document, input_data)
+        
+        # Finaliser le résumé
+        processing_time = (datetime.now() - start_time).total_seconds()
+        summary.document_id = doc_id
+        summary.processing_time = processing_time
+        summary.processed_at = datetime.now()
+        
+        return summary
+    
+    async def _summarize_standard_document(
+        self, 
+        document: Document, 
+        input_data: SummarizationInput
+    ) -> DocumentSummary:
+        """Résume un document de taille standard."""
+        
+        # Préparer le contexte
+        context = {
+            'title': document.title,
+            'author': document.author or "Non spécifié",
+            'url': str(document.url),
+            'content': document.content
+        }
+        
+        # Tâches parallèles
+        tasks = []
+        
+        # 1. Résumé exécutif
+        exec_prompt = SUMMARIZER_PROMPTS['executive_summary'].format(**context)
+        tasks.append(self._get_llm_response(exec_prompt, "executive_summary"))
+        
+        # 2. Analyse détaillée
+        if input_data.detailed_analysis:
+            detailed_prompt = SUMMARIZER_PROMPTS['detailed_analysis'].format(**context)
+            tasks.append(self._get_llm_response(detailed_prompt, "detailed_analysis"))
+        
+        # 3. Analyse de sentiment (optionnelle)
+        if input_data.include_sentiment:
+            sentiment_prompt = SUMMARIZER_PROMPTS['sentiment_analysis'].format(**context)
+            tasks.append(self._get_llm_response(sentiment_prompt, "sentiment_analysis"))
+        
+        # Exécuter les tâches
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Parser les résultats
+        executive_summary = ""
+        detailed_summary = ""
+        key_points = []
+        sentiment = None
+        credibility_score = None
+        
+        for i, result in enumerate(results):
+            if isinstance(result, Exception):
+                self.logger.error(f"Erreur tâche {i}: {result}")
+                continue
+            
+            task_type, content = result
+            
+            if task_type == "executive_summary":
+                executive_summary = content
+            elif task_type == "detailed_analysis":
+                # Parser l'analyse détaillée
+                parsed = self._parse_detailed_analysis(content)
+                detailed_summary = parsed.get('summary', content)
+                key_points = parsed.get('key_points', [])
+            elif task_type == "sentiment_analysis":
+                # Parser l'analyse de sentiment
+                parsed = self._parse_sentiment_analysis(content)
+                sentiment = parsed.get('sentiment')
+                credibility_score = parsed.get('credibility_score')
+        
+        # Créer le résumé
+        summary = DocumentSummary(
+            document_id="",  # Sera rempli plus tard
+            title=document.title,
+            url=document.url,
+            executive_summary=executive_summary,
+            detailed_summary=detailed_summary,
+            key_points=key_points[:input_data.max_key_points],
+            sentiment=sentiment,
+            credibility_score=credibility_score
+        )
+        
+        return summary
+    
+    async def _summarize_large_document(
+        self, 
+        document: Document, 
+        input_data: SummarizationInput
+    ) -> DocumentSummary:
+        """Résume un document long via chunking."""
+        self.logger.info(f"Chunking document long: {document.title}")
+        
+        # Découper le document
+        chunks = self.chunking_manager.chunk_document(
+            document.content,
+            strategy="default",
+            preserve_structure=True
+        )
+        
+        self.logger.info(f"Document découpé en {len(chunks)} chunks")
+        
+        # Résumer chaque chunk
+        chunk_summaries = await self._summarize_chunks(chunks, document)
+        
+        # Synthétiser les résumés partiels
+        synthesis = await self._synthesize_chunk_summaries(chunk_summaries, document)
+        
+        return synthesis
+    
+    async def _summarize_chunks(self, chunks: List[TextChunk], document: Document) -> List[str]:
+        """Résume chaque chunk individuellement en parallèle."""
+        async def summarize_chunk(chunk: TextChunk) -> str:
+            context = {
+                'title': document.title,
+                'chunk_index': chunk.chunk_id,
+                'total_chunks': chunk.total_chunks,
+                'chunk_content': chunk.content
+            }
+            prompt = SUMMARIZER_PROMPTS['chunked_summary'].format(**context)
+            try:
+                return await self.llm_manager.get_completion(
+                    prompt,
+                    system_prompt=SYSTEM_PROMPTS['summarizer']
+                )
+            except Exception as e:
+                self.logger.error(f"Erreur résumé chunk {chunk.chunk_id}: {e}")
+                return f"Erreur résumé chunk {chunk.chunk_id}"
+
+        # Parallélisation sur tous les chunks
+        tasks = [summarize_chunk(chunk) for chunk in chunks]
+        summaries = await asyncio.gather(*tasks)
+        return summaries
+    
+    async def _synthesize_chunk_summaries(
+        self, 
+        chunk_summaries: List[str], 
+        document: Document
+    ) -> DocumentSummary:
+        """Synthétise les résumés de chunks en un résumé unifié."""
+        
+        # Combiner tous les résumés partiels
+        combined_summaries = "\n\n".join([
+            f"Partie {i+1}: {summary}" 
+            for i, summary in enumerate(chunk_summaries)
+        ])
+        
+        context = {
+            'partial_summaries': combined_summaries,
+            'title': document.title,
+            'url': str(document.url)
+        }
+        
+        # Synthèse finale
+        synthesis_prompt = SUMMARIZER_PROMPTS['synthesis'].format(**context)
+        
+        try:
+            synthesis_result = await self.llm_manager.get_completion(
+                synthesis_prompt,
+                system_prompt=SYSTEM_PROMPTS['summarizer']
+            )
+            
+            # Parser le résultat de synthèse
+            parsed = self._parse_synthesis_result(synthesis_result)
+            
+            summary = DocumentSummary(
+                document_id="",
+                title=document.title,
+                url=document.url,
+                executive_summary=parsed.get('executive_summary', ''),
+                detailed_summary=parsed.get('detailed_summary', ''),
+                key_points=parsed.get('key_points', []),
+                sentiment=parsed.get('sentiment'),
+                credibility_score=parsed.get('credibility_score')
+            )
+            
+            return summary
+            
+        except Exception as e:
+            self.logger.error(f"Erreur synthèse finale: {e}")
+            # Fallback: créer un résumé basique
+            return self._create_basic_summary_from_chunks(chunk_summaries, document)
+    
+    async def _get_llm_response(self, prompt: str, task_type: str) -> tuple:
+        """Obtient une réponse LLM pour une tâche spécifique."""
+        try:
+            response = await self.llm_manager.get_completion(
+                prompt,
+                system_prompt=SYSTEM_PROMPTS['summarizer'],
+                temperature=0.3,
+                max_tokens=2000
+            )
+            return task_type, response
+        except Exception as e:
+            self.logger.error(f"Erreur LLM pour {task_type}: {e}")
+            return task_type, f"Erreur: {str(e)}"
+    
+    def _parse_detailed_analysis(self, content: str) -> Dict[str, Any]:
+        """Parse l'analyse détaillée pour extraire les composants."""
+        # Implémentation simplifiée - à améliorer selon le format de réponse
+        result = {'summary': content, 'key_points': []}
+        
+        # Chercher les points clés (format: - Point clé)
+        import re
+        key_point_pattern = r'^[-•]\s*(.+)$'
+        lines = content.split('\n')
+        
+        current_key_points = []
+        for line in lines:
+            match = re.match(key_point_pattern, line.strip())
+            if match:
+                point_text = match.group(1).strip()
+                if len(point_text) > 10:  # Filtrer les points trop courts
+                    key_point = KeyPoint(
+                        title=point_text[:50] + "..." if len(point_text) > 50 else point_text,
+                        content=point_text,
+                        importance=0.8,  # Score par défaut
+                        category="general"
+                    )
+                    current_key_points.append(key_point)
+        
+        result['key_points'] = current_key_points
+        return result
+    
+    def _parse_sentiment_analysis(self, content: str) -> Dict[str, Any]:
+        """Parse l'analyse de sentiment."""
+        result = {}
+        
+        # Extraction simplifiée
+        content_lower = content.lower()
+        
+        if 'positif' in content_lower:
+            result['sentiment'] = 'positif'
+        elif 'négatif' in content_lower:
+            result['sentiment'] = 'négatif'
+        else:
+            result['sentiment'] = 'neutre'
+        
+        # Chercher un score de crédibilité
+        import re
+        
+        # Chercher un pattern comme "Crédibilité: 0.8" ou "0.8"
+        credibility_pattern = r'crédibilité\s*:?\s*(\d+(?:\.\d+)?)|(\d+(?:\.\d+)?)\s*\/\s*[1510]|(\d+(?:\.\d+)?)\s*%'
+        match = re.search(credibility_pattern, content_lower)
+        if match:
+            score = float(match.group(1) or match.group(2) or match.group(3))
+            if score > 1:  # Si en pourcentage
+                score = score / 100
+            result['credibility_score'] = min(max(score, 0.0), 1.0)
+        else:
+            result['credibility_score'] = 0.5  # Valeur par défaut
+        
+        return result
+        
+        return result
+    
+    def _parse_synthesis_result(self, content: str) -> Dict[str, Any]:
+        """Parse le résultat de synthèse."""
+        # Version simplifiée - à améliorer
+        return {
+            'executive_summary': content[:200] + "..." if len(content) > 200 else content,
+            'detailed_summary': content,
+            'key_points': [],
+            'sentiment': 'neutre',
+            'credibility_score': 0.7
+        }
+    
+    def _create_basic_summary_from_chunks(
+        self, 
+        chunk_summaries: List[str], 
+        document: Document
+    ) -> DocumentSummary:
+        """Crée un résumé basique à partir des résumés de chunks."""
+        combined = " ".join(chunk_summaries)
+        
+        return DocumentSummary(
+            document_id="",
+            title=document.title,
+            url=document.url,
+            executive_summary=combined[:200] + "..." if len(combined) > 200 else combined,
+            detailed_summary=combined,
+            key_points=[],
+            sentiment="neutre",
+            credibility_score=0.5
+        )
+    
+    def _create_error_summary(self, document: Document, error: str) -> DocumentSummary:
+        """Crée un résumé d'erreur minimal."""
+        return DocumentSummary(
+            document_id=self._generate_document_id(document),
+            title=document.title,
+            url=document.url,
+            executive_summary=f"Erreur lors du résumé: {error}",
+            detailed_summary=f"Le résumé de ce document n'a pas pu être généré: {error}",
+            key_points=[],
+            sentiment=None,
+            credibility_score=None
+        )
+    
+    def _generate_document_id(self, document: Document) -> str:
+        """Génère un ID unique pour un document."""
+        content_hash = hashlib.md5(f"{document.url}{document.title}".encode()).hexdigest()
+        return f"doc_{content_hash[:8]}"
+    
+    async def _perform_global_analysis(self, summaries: List[DocumentSummary]) -> Dict[str, List[str]]:
+        """Effectue une analyse globale de tous les résumés."""
+        if len(summaries) < 2:
+            return {'common_themes': [], 'consensus_points': [], 'conflicting_views': []}
+        
+        # Combiner tous les résumés pour l'analyse
+        all_summaries = "\n\n".join([
+            f"Document: {s.title}\nRésumé: {s.detailed_summary}"
+            for s in summaries
+        ])
+        
+        # Prompt d'analyse globale
+        global_prompt = f"""
+            Analyse les résumés de documents suivants et identifie:
+
+            1. **Thèmes communs** : Les sujets qui reviennent dans plusieurs documents
+            2. **Points de consensus** : Les idées sur lesquelles les sources s'accordent
+            3. **Points conflictuels** : Les idées contradictoires entre les sources
+
+            RÉSUMÉS:
+            {all_summaries}
+
+            Format ta réponse avec des sections claires et des listes à puces.
+            """
+        
+        try:
+            response = await self.llm_manager.get_completion(
+                global_prompt,
+                system_prompt="Tu es un expert en analyse comparative de documents."
+            )
+            
+            # Parser la réponse (implémentation simplifiée)
+            return self._parse_global_analysis(response)
+            
+        except Exception as e:
+            self.logger.error(f"Erreur analyse globale: {e}")
+            return {'common_themes': [], 'consensus_points': [], 'conflicting_views': []}
+    
+    def _parse_global_analysis(self, content: str) -> Dict[str, List[str]]:
+        """Parse l'analyse globale."""
+        # Implémentation simplifiée
+        lines = content.split('\n')
+        
+        result = {
+            'common_themes': [],
+            'consensus_points': [],
+            'conflicting_views': []
+        }
+        
+        current_section = None
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Détecter les sections
+            if 'thème' in line.lower() or 'theme' in line.lower():
+                current_section = 'common_themes'
+            elif 'consensus' in line.lower():
+                current_section = 'consensus_points'
+            elif 'conflict' in line.lower() or 'contradictoire' in line.lower():
+                current_section = 'conflicting_views'
+            elif line.startswith('-') or line.startswith('•'):
+                # Point de liste
+                if current_section:
+                    point = line[1:].strip()
+                    if len(point) > 5:  # Filtrer les points trop courts
+                        result[current_section].append(point)
+        
+        return result
+    
+    def _calculate_average_credibility(self, summaries: List[DocumentSummary]) -> Optional[float]:
+        """Calcule le score de crédibilité moyen."""
+        scores = [s.credibility_score for s in summaries if s.credibility_score is not None]
+        
+        if not scores:
+            return None
+        
+        return sum(scores) / len(scores)
+
+    #fonction summary from content extraction result
+    async def process_from_extraction_result(
+        self,
+        extraction_result: 'ExtractionResult'
+    ) -> SummarizationOutput:
+        """
+        Traite la summarization à partir d'un ExtractionResult.
+        
+        Args:
+            extraction_result: Résultat de l'extraction de contenu
+        Returns:
+            SummarizationOutput avec tous les résumés
+        """
+        # Préparer l'input de summarization
+        input_data = SummarizationInput(
+            documents=extraction_result.documents,
+            summary_options={
+                'include_sentiment': True,
+                'include_citations': True,
+                'max_key_points': 5,
+                'detailed_analysis': True,
+                'chunk_large_docs': True
+            }
+
+        )
+        
+        if not self.validate_input(input_data):
+            self.logger.error("Input ExtractionResult invalide pour la summarization")
+            raise ValueError("Input ExtractionResult invalide pour la summarization")
+        
+        # Appeler le processus principal de summarization
+        return await self.process(input_data)
+      
+
+
+
+# Exemple d'utilisation
+if __name__ == "__main__":
+    import asyncio
+    import json
+    from src.models.document_models import ExtractionResult
+
+    def save_summarization_output(output, filename=None):
+        """Sauvegarde un SummarizationOutput au format JSON."""
+        from datetime import datetime
+        if not filename:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"summarization_output_{len(output.summaries)}docs_{timestamp}.json"
+        try:
+            with open(filename, 'w', encoding='utf-8') as f:
+                json.dump(output.model_dump(mode='json'), f, indent=2, ensure_ascii=False)
+            return filename
+        except Exception as e:
+            print(f"Erreur lors de la sauvegarde: {e}")
+            return None
+
+    async def summarize_from_extraction_file():
+        # Charger ExtractionResult
+        extraction_file = "extraction_result_2docs_20251116_141527.json"
+        try:
+            with open(extraction_file, 'r', encoding='utf-8') as f:
+                extraction_data = json.load(f)
+            extraction_result = ExtractionResult(**extraction_data)
+        except Exception as e:
+            print(f"Erreur chargement ExtractionResult: {e}")
+            return
+
+        
+
+        summarizer = SummarizerAgent()
+
+        output = await summarizer.process_from_extraction_result(extraction_result)
+
+        # Sauvegarde
+        filename = save_summarization_output(output)
+        if filename:
+            print(f"✅ Résumés sauvegardés dans: {filename}")
+        else:
+            print("❌ Erreur lors de la sauvegarde du résumé.")
+
+        # Affichage rapide
+        for summary in output.summaries:
+            print(f"\nRésumé pour {summary.title}:")
+            print(f"Résumé exécutif: {summary.executive_summary[:200]}...")
+            print(f"Points clés: {[kp.title for kp in summary.key_points]}")
+            print(f"Sentiment: {summary.sentiment}")
+            print(f"Score de crédibilité: {summary.credibility_score}")
+        print(f"Temps total de traitement: {output.total_processing_time:.2f}s")
+        print(f"Score de crédibilité moyen: {output.average_credibility}")
+
+    asyncio.run(summarize_from_extraction_file())

src/core/__init__.py

@@ -0,0 +1,7 @@
+"""
+Fichier d'initialisation du package core.
+"""
+
+from src.core.logging import setup_logger, app_logger
+
+__all__ = ["setup_logger", "app_logger"]

src/core/logging.py

@@ -0,0 +1,73 @@
+"""
+Configuration du système de logging pour l'assistant de recherche.
+Permet de tracer les événements importants (infos, erreurs, avertissements, etc.)
+"""
+
+import logging
+import sys
+from pathlib import Path
+from logging.handlers import RotatingFileHandler
+
+# --- Création du dossier des logs ---
+log_directory = Path("logs")
+log_directory.mkdir(exist_ok=True)
+
+# --- Fonction de configuration du logger ---
+def setup_logger(name: str, level: int = logging.INFO) -> logging.Logger:
+    """
+    Configure et retourne un logger complet avec console et fichiers rotatifs.
+
+    Args:
+        name (str): Nom du logger (ex: 'research_assistant')
+        level (int): Niveau minimal de logging (par défaut: INFO)
+
+    Returns:
+        logging.Logger: Logger configuré
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    # Éviter les doublons si setup_logger() est appelé plusieurs fois
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    # Formatage lisible du message de log
+    formatter = logging.Formatter(
+        "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    )
+
+    # --- Handler Console (affichage terminal) ---
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.DEBUG)  # plus verbeux pour la console
+    console_handler.setFormatter(formatter)
+
+    # --- Handler Fichier (logs persistants) ---
+    file_handler = RotatingFileHandler(
+        log_directory / f"{name}.log",
+        maxBytes=5 * 1024 * 1024,  # 5 Mo
+        backupCount=5,             # garder 5 fichiers d'historique
+        encoding='utf-8'
+    )
+    file_handler.setLevel(logging.INFO)  # moins de bruit dans les fichiers
+    file_handler.setFormatter(formatter)
+
+    # --- Ajout des handlers au logger ---
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
+
+    # Message de démarrage du logger
+    logger.info("Logger initialisé avec succès.")
+    return logger
+
+
+# --- Exemple d’utilisation du logger ---
+app_logger = setup_logger("research_assistant")
+
+if __name__ == "__main__":
+    app_logger.debug("Ceci est un message DEBUG (utile pour le débogage).")
+    app_logger.info("Démarrage de l'application de recherche...")
+    app_logger.warning("Avertissement : connexion lente à la base de données.")
+    app_logger.error("Erreur : impossible de charger un fichier de configuration.")
+    app_logger.critical("ERREUR CRITIQUE : application arrêtée.")
+    app_logger.info("Application terminée.")

src/enhanced_system_prompt.py

@@ -0,0 +1,159 @@
+"""
+Prompt système amélioré pour l'agent avec mémoire
+"""
+
+ENHANCED_SYSTEM_PROMPT = """Tu es un Assistant de Recherche Intelligent avec Mémoire Contextuelle.
+
+🎯 TES CAPACITÉS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Tu disposes d'un système de mémoire avancé qui te permet de :
+• Stocker et réutiliser les résultats de recherches précédentes
+• Éviter les doublons et optimiser les recherches
+• Maintenir un contexte conversationnel enrichi
+• Suggérer des recherches similaires déjà effectuées
+
+🔧 TES OUTILS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+1️⃣ research_complete_pipeline_with_memory(topic, max_results, use_cache)
+   → Pipeline complet de recherche avec cache intelligent
+   → Paramètres:
+     - topic (str): Sujet de recherche
+     - max_results (int): 2-10 sources (défaut: 3)
+     - use_cache (bool): Utiliser le cache si disponible (défaut: True)
+   
+   💡 Utilise cet outil pour:
+   - Nouvelles recherches complètes
+   - Analyses approfondies sur un sujet
+   - Résumés documentés et sourcés
+
+2️⃣ search_in_memory(query, top_k)
+   → Recherche rapide dans les données déjà collectées
+   → Parfait pour retrouver des informations sans nouvelle recherche
+   
+   💡 Utilise cet outil pour:
+   - Questions sur des sujets déjà explorés
+   - Vérifications rapides
+   - Références croisées
+
+3️⃣ get_research_history(n_last)
+   → Consulte l'historique des recherches
+   → Utile pour voir les sujets déjà traités
+   
+   💡 Utilise cet outil pour:
+   - "Qu'ai-je déjà recherché ?"
+   - "Quelles sont mes dernières recherches ?"
+   - Suggestions de sujets connexes
+
+4️⃣ clear_memory(confirm)
+   → Réinitialise la mémoire (avec confirmation)
+   → À utiliser avec précaution
+
+📋 STRATÉGIE D'UTILISATION:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+AVANT de lancer une nouvelle recherche complète:
+1. Vérifie si une recherche similaire existe déjà (use_cache=True par défaut)
+2. Si l'utilisateur demande quelque chose sur un sujet déjà traité, 
+   utilise search_in_memory d'abord
+3. Pour les nouvelles recherches, utilise research_complete_pipeline_with_memory
+
+EXEMPLES DE DÉCISIONS INTELLIGENTES:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+❓ User: "Résume l'impact de l'IA sur l'emploi"
+✅ Action: research_complete_pipeline_with_memory(
+    topic="impact de l'intelligence artificielle sur l'emploi", 
+    max_results=3,
+    use_cache=True
+)
+
+❓ User: "Rappelle-moi ce que tu as trouvé sur l'IA dans l'emploi"
+✅ Action: search_in_memory(query="intelligence artificielle emploi", top_k=3)
+
+❓ User: "Quelles recherches ai-je faites récemment ?"
+✅ Action: get_research_history(n_last=5)
+
+❓ User: "Fais une analyse approfondie sur le climat"
+✅ Action: research_complete_pipeline_with_memory(
+    topic="changement climatique analyse complète", 
+    max_results=7,
+    use_cache=True
+)
+
+❓ User: "Bonjour, comment vas-tu ?"
+✅ Action: Réponse directe, pas d'outil nécessaire
+
+🎨 TON COMPORTEMENT:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• Toujours privilégier l'efficacité : utilise le cache quand possible
+• Informe l'utilisateur si tu utilises des données en cache
+• Suggère des recherches connexes quand pertinent
+• Sois transparent sur tes sources et méthodes
+• Présente les résultats de manière claire et structurée
+
+⚠️ IMPORTANT:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• N'invente JAMAIS d'informations
+• Cite toujours tes sources
+• Si aucune info n'est disponible, dis-le clairement
+• Le système évite automatiquement les doublons
+• Les résultats en cache sont valides 24h
+"""
+
+
+
+# Chargement des variables d'environnement
+from dotenv import load_dotenv
+from langchain_groq import ChatGroq
+import os 
+load_dotenv()
+api_key = os.getenv("GROQ_API_KEY")
+if not api_key:
+    raise ValueError("GROQ_API_KEY non définie dans .env")
+
+# Configuration du modèle avec l'outil
+model = ChatGroq(
+    model="llama-3.1-8b-instant",
+    temperature=0.3,  # Bas pour plus de cohérence
+    max_tokens=2048*2,
+    api_key=api_key
+)
+
+# Fonction helper pour mettre à jour le model_call
+def create_enhanced_model_call():
+    """Crée la fonction model_call améliorée avec le nouveau prompt"""
+    
+    from langchain_core.messages import SystemMessage
+    
+    def model_call_enhanced(state):
+        """Nœud LLM amélioré avec système de mémoire"""
+        
+        system_message = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
+        messages = state["messages"]
+        
+        # Vérifier si l'utilisateur demande l'historique ou la mémoire
+        last_user_msg = ""
+        for msg in reversed(messages):
+            if hasattr(msg, 'type') and msg.type == 'human':
+                last_user_msg = msg.content.lower()
+                break
+        
+        # Ajouter un hint si l'utilisateur semble demander quelque chose déjà recherché
+        memory_hints = ['rappelle', 'déjà', 'précédent', 'avant', 'historique', 'recherches']
+        if any(hint in last_user_msg for hint in memory_hints):
+            hint_msg = SystemMessage(content=
+                "💡 L'utilisateur semble se référer à des informations passées. "
+                "Considère utiliser search_in_memory ou get_research_history avant une nouvelle recherche."
+            )
+            messages = [system_message, hint_msg] + messages
+        else:
+            messages = [system_message] + messages
+        
+        response = model.invoke(messages)
+        return {"messages": [response]}
+    
+    return model_call_enhanced
+
+# Exporter
+print("✅ Prompt système amélioré créé")

src/graph.py

@@ -0,0 +1,294 @@
+# """
+# Script de test complet pour le système de mémoire
+# """
+
+# from langchain_groq import ChatGroq
+# from langgraph.graph import StateGraph, END
+# from langgraph.prebuilt import ToolNode
+# from typing import TypedDict, Sequence, Annotated
+# from langchain_core.messages import BaseMessage
+# from langgraph.graph.message import add_messages
+# from dotenv import load_dotenv
+# import os
+
+# # Importer les composants
+# # from memory_integration import tools_with_memory
+# # from enhanced_system_prompt import create_enhanced_model_call, ENHANCED_SYSTEM_PROMPT
+
+# # ============================================================================
+# # CONFIGURATION
+# # ============================================================================
+
+# class AgentState(TypedDict):
+#     messages: Annotated[Sequence[BaseMessage], add_messages]
+
+# load_dotenv()
+# api_key = os.getenv("GROQ_API_KEY")
+# if not api_key:
+#     raise ValueError("GROQ_API_KEY non définie")
+
+# model = ChatGroq(
+#     model="llama-3.1-8b-instant",
+#     temperature=0.3,
+#     max_tokens=2048,
+#     api_key=api_key
+# ).bind_tools(tools_with_memory)
+
+# # ============================================================================
+# # CONSTRUCTION DU GRAPHE AMÉLIORÉ
+# # ============================================================================
+
+# def should_continue(state: AgentState) -> str:
+#     messages = state["messages"]
+#     last_message = messages[-1]
+    
+#     if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
+#         return "continue"
+#     else:
+#         return "end"
+
+# # Créer le graphe
+# graph = StateGraph(AgentState)
+
+# # Ajouter les nœuds
+# model_call_enhanced = create_enhanced_model_call()
+# graph.add_node("llm", model_call_enhanced)
+
+# tool_node = ToolNode(tools=tools_with_memory)
+# graph.add_node("tools", tool_node)
+
+# # Définir les connexions
+# graph.set_entry_point("llm")
+# graph.add_conditional_edges(
+#     "llm",
+#     should_continue,
+#     {
+#         "continue": "tools",
+#         "end": END,
+#     },
+# )
+# graph.add_edge("tools", "llm")
+
+# # Compiler
+# app_with_memory = graph.compile()
+
+# # ============================================================================
+# # FONCTIONS UTILITAIRES
+# # ============================================================================
+
+# def print_stream(stream, show_tool_calls=True):
+#     """Affiche le flux de messages de manière élégante"""
+#     print("\n" + "="*70)
+    
+#     for i, s in enumerate(stream):
+#         message = s["messages"][-1]
+        
+#         if hasattr(message, 'content') and message.content:
+#             print(f"\n{'─'*70}")
+#             if hasattr(message, 'type'):
+#                 if message.type == 'human':
+#                     print("👤 UTILISATEUR:")
+#                 elif message.type == 'ai':
+#                     print("🤖 ASSISTANT:")
+#                 elif message.type == 'tool':
+#                     if show_tool_calls:
+#                         print("🔧 RÉSULTAT OUTIL:")
+            
+#             content = message.content
+#             if isinstance(content, str):
+#                 # Limiter l'affichage si trop long
+#                 if len(content) > 1000:
+#                     print(content[:1000] + "\n... (contenu tronqué)")
+#                 else:
+#                     print(content)
+#             else:
+#                 print(content)
+        
+#         if hasattr(message, 'tool_calls') and message.tool_calls and show_tool_calls:
+#             print("\n🔧 APPELS D'OUTILS:")
+#             for tool_call in message.tool_calls:
+#                 print(f"  → {tool_call.get('name', 'unknown')}({tool_call.get('args', {})})")
+    
+#     print("\n" + "="*70)
+
+# def run_test(user_query: str, test_name: str = ""):
+#     """Exécute un test avec affichage formaté"""
+#     if test_name:
+#         print(f"\n\n{'#'*70}")
+#         print(f"# TEST: {test_name}")
+#         print(f"{'#'*70}")
+    
+#     inputs = {"messages": [("user", user_query)]}
+#     print_stream(app_with_memory.stream(inputs, stream_mode="values"))
+
+# # ============================================================================
+# # SUITE DE TESTS
+# # ============================================================================
+
+# def run_all_tests():
+#     """Exécute tous les tests du système"""
+    
+#     print("\n" + "="*70)
+#     print(" 🧪 SUITE DE TESTS - SYSTÈME DE MÉMOIRE INTELLIGENT")
+#     print("="*70)
+    
+#     # Test 1: Première recherche (création du cache)
+#     run_test(
+#         "Fais-moi un résumé complet sur l'impact de l'intelligence artificielle sur le marché du travail",
+#         "Test 1 - Première recherche (cache vide)"
+#     )
+    
+#     # Test 2: Même sujet (utilisation du cache)
+#     run_test(
+#         "Peux-tu me redonner les infos sur l'IA et l'emploi ?",
+#         "Test 2 - Recherche dans le cache"
+#     )
+    
+#     # Test 3: Recherche dans la mémoire
+#     run_test(
+#         "Qu'est-ce que tu as trouvé sur l'intelligence artificielle ?",
+#         "Test 3 - Recherche sémantique dans la mémoire"
+#     )
+    
+#     # Test 4: Historique
+#     run_test(
+#         "Montre-moi l'historique de mes recherches",
+#         "Test 4 - Consultation de l'historique"
+#     )
+    
+#     # Test 5: Nouvelle recherche différente
+#     run_test(
+#         "Fais une analyse sur les énergies renouvelables",
+#         "Test 5 - Nouvelle recherche (sujet différent)"
+#     )
+    
+#     # Test 6: Question simple (pas de recherche)
+#     run_test(
+#         "Bonjour, comment ça va ?",
+#         "Test 6 - Conversation simple (sans recherche)"
+#     )
+    
+#     # Test 7: Recherche croisée
+#     run_test(
+#         "Compare ce que tu as trouvé sur l'IA et les énergies renouvelables",
+#         "Test 7 - Recherche croisée dans la mémoire"
+#     )
+    
+#     print("\n\n" + "="*70)
+#     print(" ✅ TOUS LES TESTS TERMINÉS")
+#     print("="*70)
+
+
+# def demo_memory_stats():
+#     """Affiche les statistiques de la mémoire"""
+#     from memory_system import memory_system
+    
+#     print("\n" + "="*70)
+#     print(" 📊 STATISTIQUES DU SYSTÈME DE MÉMOIRE")
+#     print("="*70)
+    
+#     # Stats vectorielles
+#     vector_count = memory_system.vector_memory.collection.count()
+#     print(f"\n🗄️ Base Vectorielle:")
+#     print(f"   Documents stockés: {vector_count}")
+#     print(f"   Hashes en cache: {len(memory_system.vector_memory.content_hashes)}")
+    
+#     # Stats agent
+#     conv_count = len(memory_system.agent_memory.conversation_history)
+#     research_count = len(memory_system.agent_memory.research_cache)
+    
+#     print(f"\n🧠 Mémoire Agent:")
+#     print(f"   Conversations: {conv_count}")
+#     print(f"   Recherches en cache: {research_count}")
+#     print(f"   Topics mémorisés: {len(memory_system.agent_memory.topic_keywords)}")
+    
+#     if research_count > 0:
+#         print(f"\n📚 Topics en cache:")
+#         for topic in list(memory_system.agent_memory.research_cache.keys())[:5]:
+#             print(f"   • {topic}")
+    
+#     print("\n" + "="*70)
+
+
+# # ============================================================================
+# # MENU INTERACTIF
+# # ============================================================================
+
+# def interactive_menu():
+#     """Menu interactif pour tester le système"""
+    
+#     while True:
+#         print("\n" + "="*70)
+#         print(" 🎯 ASSISTANT DE RECHERCHE INTELLIGENT")
+#         print("="*70)
+#         print("\n Options:")
+#         print("  1. Poser une question / Lancer une recherche")
+#         print("  2. Rechercher dans la mémoire")
+#         print("  3. Voir l'historique")
+#         print("  4. Statistiques de la mémoire")
+#         print("  5. Lancer la suite de tests")
+#         print("  6. Réinitialiser la mémoire")
+#         print("  0. Quitter")
+        
+#         choice = input("\n👉 Votre choix: ").strip()
+        
+#         if choice == "1":
+#             query = input("\n💬 Votre question: ")
+#             run_test(query, "Recherche utilisateur")
+        
+#         elif choice == "2":
+#             query = input("\n🔍 Recherche dans la mémoire: ")
+#             run_test(f"Cherche dans ta mémoire: {query}", "Recherche mémoire")
+        
+#         elif choice == "3":
+#             run_test("Montre-moi mon historique de recherches", "Historique")
+        
+#         elif choice == "4":
+#             demo_memory_stats()
+        
+#         elif choice == "5":
+#             run_all_tests()
+        
+#         elif choice == "6":
+#             confirm = input("\n⚠️ Êtes-vous sûr de vouloir réinitialiser ? (oui/non): ")
+#             if confirm.lower() == "oui":
+#                 from memory_system import memory_system
+#                 memory_system.agent_memory.clear_all()
+#                 print("✅ Mémoire réinitialisée")
+#             else:
+#                 print("❌ Annulé")
+        
+#         elif choice == "0":
+#             print("\n👋 Au revoir!")
+#             break
+        
+#         else:
+#             print("\n❌ Choix invalide")
+
+
+# # ============================================================================
+# # POINT D'ENTRÉE
+# # ============================================================================
+
+# if __name__ == "__main__":
+#     import sys
+    
+#     print("\n" + "🚀"*35)
+#     print(" SYSTÈME DE RECHERCHE INTELLIGENT AVEC MÉMOIRE")
+#     print("🚀"*35 + "\n")
+    
+#     if len(sys.argv) > 1:
+#         if sys.argv[1] == "test":
+#             # Mode test automatique
+#             run_all_tests()
+#             demo_memory_stats()
+#         elif sys.argv[1] == "stats":
+#             # Afficher uniquement les stats
+#             demo_memory_stats()
+#         else:
+#             # Exécuter une requête directe
+#             query = " ".join(sys.argv[1:])
+#             run_test(query, "Requête CLI")
+#     else:
+#         # Mode interactif
+#         interactive_menu()

src/memory_integration.py

@@ -0,0 +1,285 @@
+"""
+Intégration du système de mémoire dans l'outil de recherche
+"""
+
+from langchain_core.tools import tool
+from typing import Union
+import asyncio
+
+from src.agents.researcher_agent import ResearcherAgent
+from src.agents.content_extractor_agent import ContentExtractorAgent
+from src.agents.summarizer_agent import SummarizerAgent
+from src.agents.global_synthesizer_agent import GlobalSynthesizerAgent
+
+from src.models.research_models import ResearchQuery
+# ------------ AGENTS ------------
+researcher_agent = ResearcherAgent()
+content_extractor_agent = ContentExtractorAgent()
+summarizer_agent = SummarizerAgent()
+global_synthesizer_agent = GlobalSynthesizerAgent()
+
+# Importer le système de mémoire
+from .memory_integration import memory_system
+
+# ============================================================================
+# OUTIL AMÉLIORÉ AVEC MÉMOIRE
+# ============================================================================
+
+@tool
+def research_complete_pipeline_with_memory(topic: str, max_results: Union[int, str] = 3, use_cache: bool = True) -> str:
+    """Exécute un pipeline de recherche complet avec système de mémoire intégré.
+    
+    Ce tool intelligent :
+    1. Vérifie si des recherches similaires existent en cache
+    2. Utilise la mémoire vectorielle pour enrichir le contexte
+    3. Exécute le pipeline complet de recherche si nécessaire
+    4. Stocke tous les résultats pour réutilisation future
+    5. Déduplique automatiquement les documents
+    
+    Args:
+        topic: Le sujet de recherche
+        max_results: Nombre de sources à analyser (2-10, défaut: 3)
+        use_cache: Utiliser le cache si disponible (défaut: True)
+    
+    Returns:
+        Un rapport complet enrichi par la mémoire contextuelle
+    """
+    # Conversion et validation
+    if isinstance(max_results, str):
+        try:
+            max_results = int(max_results)
+        except ValueError:
+            max_results = 3
+    max_results = max(2, min(max_results, 10))
+    
+    async def run_pipeline_with_memory():
+        print(f"\n{'='*60}")
+        print(f"🚀 PIPELINE DE RECHERCHE INTELLIGENT")
+        print(f"📋 Sujet: {topic}")
+        print(f"💾 Cache activé: {use_cache}")
+        print(f"{'='*60}\n")
+        
+        # ===== PHASE 1: RÉCUPÉRATION DU CONTEXTE =====
+        print("🧠 [Phase 1] Récupération du contexte mémoriel...")
+        context = memory_system.retrieve_context_for_query(topic, use_cache=use_cache)
+        
+        # Vérifier si on a un résultat en cache
+        if context['cached_result'] and use_cache:
+            print("✅ Résultat trouvé en cache (< 24h)")
+            print("📊 Utilisation du résultat mémorisé")
+            
+            cached_report = context['cached_result']
+            if hasattr(cached_report, 'final_report'):
+                return cached_report.final_report.formatted_outputs.get('markdown', str(cached_report))
+        
+        # Afficher le contexte sémantique si disponible
+        if context['semantic_context']:
+            print(f"📚 Contexte sémantique récupéré ({len(context['semantic_context'])} caractères)")
+        
+        if context['related_topics']:
+            print(f"🔗 Topics similaires trouvés: {', '.join(context['related_topics'][:3])}")
+        
+        # ===== PHASE 2: EXÉCUTION DU PIPELINE =====
+        print(f"\n{'='*60}")
+        print("🔬 [Phase 2] Exécution du pipeline de recherche")
+        print(f"{'='*60}\n")
+        
+        # ÉTAPE 1: Recherche
+        print("🔍 [1/4] Recherche web en cours...")
+        query = ResearchQuery(
+            topic=topic,
+            keywords=await researcher_agent.extract_keywords_with_llm(topic),
+            max_results=max_results,
+            search_depth="basic"
+        )
+        research_data = await researcher_agent.process(query)
+        print(f"✅ Trouvé {research_data.total_found} sources")
+        
+        # ÉTAPE 2: Extraction avec déduplication
+        print("\n📄 [2/4] Extraction du contenu (avec déduplication)...")
+        extraction_data = await content_extractor_agent.process_from_research_output(
+            research_output=research_data
+        )
+        print(f"✅ Extrait {extraction_data.successful_extractions} documents")
+        
+        # Vérifier les doublons
+        if extraction_data.documents:
+            new_docs = []
+            duplicates = 0
+            for doc in extraction_data.documents:
+                if not memory_system.vector_memory.is_duplicate(doc.content):
+                    new_docs.append(doc)
+                else:
+                    duplicates += 1
+            
+            if duplicates > 0:
+                print(f"ℹ️ {duplicates} documents en doublon ignorés")
+                # Mettre à jour extraction_data avec seulement les nouveaux docs
+                extraction_data.documents = new_docs
+        
+        # ÉTAPE 3: Résumés
+        print("\n📝 [3/4] Création des résumés...")
+        summarization_data = await summarizer_agent.process_from_extraction_result(
+            extraction_result=extraction_data
+        )
+        print(f"✅ Généré {summarization_data.total_documents} résumés")
+        
+        # ÉTAPE 4: Synthèse globale enrichie
+        print("\n🎯 [4/4] Synthèse globale (enrichie par le contexte)...")
+        
+        # Enrichir avec le contexte sémantique si disponible
+        if context['semantic_context']:
+            print("📚 Enrichissement avec le contexte mémoriel...")
+        
+        global_synthesis = await global_synthesizer_agent.process_from_summarization_output(
+            summarization_output=summarization_data
+        )
+        print(f"✅ Rapport final généré ({global_synthesis.final_report.word_count} mots)")
+        
+        # ===== PHASE 3: STOCKAGE EN MÉMOIRE =====
+        print(f"\n{'='*60}")
+        print("💾 [Phase 3] Stockage en mémoire")
+        print(f"{'='*60}\n")
+        
+        memory_system.process_research_result(
+            topic=topic,
+            extraction_result=extraction_data,
+            summarization_result=summarization_data,
+            global_synthesis=global_synthesis
+        )
+        
+        # Ajouter à l'historique des conversations
+        final_report_text = global_synthesis.final_report.formatted_outputs.get('text', '')[:200]
+        memory_system.agent_memory.add_conversation(
+            user_message=f"Recherche sur: {topic}",
+            assistant_response=final_report_text,
+            metadata={'max_results': max_results, 'sources': research_data.total_found}
+        )
+        
+        print(f"\n{'='*60}")
+        print("✨ PIPELINE TERMINÉ AVEC SUCCÈS")
+        print(f"📊 Statistiques:")
+        print(f"   - Sources analysées: {research_data.total_found}")
+        print(f"   - Documents stockés: {extraction_data.successful_extractions}")
+        print(f"   - Résumés générés: {summarization_data.total_documents}")
+        print(f"   - Mots du rapport: {global_synthesis.final_report.word_count}")
+        print(f"{'='*60}\n")
+        
+        # Retourner le rapport en markdown
+        return global_synthesis.final_report.formatted_outputs.get('markdown',
+                                                                   global_synthesis.final_report.formatted_outputs.get('text',
+                                                                                                                       str(global_synthesis)))
+    
+    return asyncio.run(run_pipeline_with_memory())
+
+
+# ============================================================================
+# OUTILS SUPPLÉMENTAIRES POUR LA GESTION DE MÉMOIRE
+# ============================================================================
+
+@tool
+def search_in_memory(query: str, top_k: int = 5) -> str:
+    """Recherche sémantique dans la mémoire vectorielle.
+    
+    Utile pour retrouver des informations de recherches précédentes
+    sans relancer une nouvelle recherche complète.
+    
+    Args:
+        query: Requête de recherche
+        top_k: Nombre de résultats à retourner
+    
+    Returns:
+        Contexte pertinent trouvé dans la mémoire
+    """
+    print(f"🔍 Recherche dans la mémoire: '{query}'")
+    
+    results = memory_system.vector_memory.semantic_search(query, k=top_k)
+    
+    if not results:
+        return "Aucun résultat trouvé dans la mémoire."
+    
+    output = f"📚 {len(results)} résultats trouvés dans la mémoire:\n\n"
+    
+    for i, (doc, score) in enumerate(results, 1):
+        output += f"[Résultat {i} - Pertinence: {score:.2%}]\n"
+        output += f"Titre: {doc.metadata.get('title', 'N/A')}\n"
+        output += f"Source: {doc.metadata.get('source', 'N/A')}\n"
+        output += f"Contenu:\n{doc.page_content[:300]}...\n\n"
+    
+    return output
+
+
+@tool
+def get_research_history(n_last: int = 5) -> str:
+    """Récupère l'historique des dernières recherches effectuées.
+    
+    Args:
+        n_last: Nombre de conversations récentes à retourner
+    
+    Returns:
+        Historique formaté des recherches
+    """
+    print(f"📜 Récupération des {n_last} dernières recherches...")
+    
+    history = list(memory_system.agent_memory.conversation_history)[-n_last:]
+    
+    if not history:
+        return "Aucun historique de recherche disponible."
+    
+    output = f"📚 Historique des {len(history)} dernières recherches:\n\n"
+    
+    for i, conv in enumerate(history, 1):
+        timestamp = conv.get('timestamp', 'N/A')
+        user_msg = conv.get('user', '')[:100]
+        metadata = conv.get('metadata', {})
+        
+        output += f"[Recherche {i}] - {timestamp}\n"
+        output += f"Topic: {user_msg}\n"
+        if metadata:
+            output += f"Détails: {metadata}\n"
+        output += "\n"
+    
+    return output
+
+
+@tool
+def clear_memory(confirm: bool = False) -> str:
+    """Réinitialise complètement le système de mémoire.
+    
+    ⚠️ ATTENTION: Cette action est irréversible!
+    
+    Args:
+        confirm: Doit être True pour confirmer l'action
+    
+    Returns:
+        Message de confirmation
+    """
+    if not confirm:
+        return "⚠️ Action non confirmée. Passez confirm=True pour réinitialiser la mémoire."
+    
+    print("🗑️ Réinitialisation de la mémoire...")
+    memory_system.agent_memory.clear_all()
+    
+    # Note: On ne clear pas la base vectorielle car elle peut contenir des données précieuses
+    # Si vraiment nécessaire, utiliser memory_system.vector_memory.collection.delete(where={})
+    
+    return "✅ Mémoire de conversation réinitialisée. Base vectorielle préservée."
+
+
+# ============================================================================
+# LISTE DES OUTILS MISE À JOUR
+# ============================================================================
+
+# Mettre à jour la liste des outils dans votre code principal
+tools_with_memory = [
+    research_complete_pipeline_with_memory,
+    search_in_memory,
+    get_research_history,
+    clear_memory
+]
+
+print("✅ Outils avec mémoire initialisés:")
+print("   1. research_complete_pipeline_with_memory - Pipeline complet avec cache")
+print("   2. search_in_memory - Recherche dans la mémoire vectorielle")
+print("   3. get_research_history - Historique des recherches")
+print("   4. clear_memory - Réinitialisation de la mémoire")

src/memory_system.py

@@ -0,0 +1,547 @@
+"""
+Système de Mémoire et Stockage Vectoriel pour l'Assistant de Recherche
+Gère : embeddings, recherche sémantique, historique et déduplication
+"""
+
+import chromadb
+from chromadb.config import Settings
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import Chroma
+from langchain_core.documents import Document
+from typing import List, Dict, Optional, Tuple
+from datetime import datetime
+import hashlib
+import json
+import pickle
+from pathlib import Path
+from collections import deque
+
+# ============================================================================
+# GESTIONNAIRE DE MÉMOIRE VECTORIELLE
+# ============================================================================
+
+class VectorMemoryManager:
+    """Gère le stockage vectoriel des documents et résumés"""
+    
+    def __init__(self, 
+                 persist_directory: str = "./chroma_db",
+                 collection_name: str = "research_documents",
+                 embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2"):
+        """
+        Initialise le gestionnaire de mémoire vectorielle
+        
+        Args:
+            persist_directory: Dossier de persistance de ChromaDB
+            collection_name: Nom de la collection ChromaDB
+            embedding_model: Modèle d'embeddings HuggingFace
+        """
+        self.persist_directory = Path(persist_directory)
+        self.persist_directory.mkdir(parents=True, exist_ok=True)
+        
+        print(f"🔧 Initialisation du système de mémoire vectorielle...")
+        
+        # Configuration des embeddings
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name=embedding_model,
+            model_kwargs={'device': 'cpu'},
+            encode_kwargs={'normalize_embeddings': True}
+        )
+        
+        # Configuration ChromaDB
+        self.client = chromadb.PersistentClient(
+            path=str(self.persist_directory),
+            settings=Settings(
+                anonymized_telemetry=False,
+                allow_reset=True
+            )
+        )
+        
+        # Créer ou récupérer la collection
+        try:
+            self.collection = self.client.get_collection(collection_name)
+            print(f"✅ Collection '{collection_name}' récupérée ({self.collection.count()} documents)")
+        except:
+            self.collection = self.client.create_collection(
+                name=collection_name,
+                metadata={"hnsw:space": "cosine"}
+            )
+            print(f"✅ Nouvelle collection '{collection_name}' créée")
+        
+        # Initialiser le vectorstore LangChain
+        self.vectorstore = Chroma(
+            client=self.client,
+            collection_name=collection_name,
+            embedding_function=self.embeddings
+        )
+        
+        # Cache pour déduplication rapide
+        self.content_hashes = set()
+        self._load_existing_hashes()
+    
+    def _load_existing_hashes(self):
+        """Charge les hashes des documents existants pour déduplication"""
+        try:
+            results = self.collection.get(include=['metadatas'])
+            for metadata in results['metadatas']:
+                if 'content_hash' in metadata:
+                    self.content_hashes.add(metadata['content_hash'])
+            print(f"📋 {len(self.content_hashes)} hashes chargés pour déduplication")
+        except Exception as e:
+            print(f"⚠️ Erreur lors du chargement des hashes: {e}")
+    
+    def _compute_hash(self, content: str) -> str:
+        """Calcule le hash MD5 d'un contenu"""
+        return hashlib.md5(content.encode('utf-8')).hexdigest()
+    
+    def is_duplicate(self, content: str) -> bool:
+        """Vérifie si un document est un doublon"""
+        content_hash = self._compute_hash(content)
+        return content_hash in self.content_hashes
+    
+    def add_documents(self, 
+                     documents: List[Dict[str, any]], 
+                     source: str = "research",
+                     check_duplicates: bool = True) -> Dict[str, int]:
+        """
+        Ajoute des documents au vectorstore
+        
+        Args:
+            documents: Liste de dicts avec 'content', 'title', 'url', etc.
+            source: Source des documents (research, summary, synthesis)
+            check_duplicates: Vérifier les doublons avant ajout
+        
+        Returns:
+            Dict avec statistiques d'ajout
+        """
+        print(f"\n📥 Ajout de {len(documents)} documents (source: {source})...")
+        
+        added = 0
+        skipped = 0
+        
+        docs_to_add = []
+        metadatas_to_add = []
+        ids_to_add = []
+        
+        for doc in documents:
+            content = doc.get('content', '')
+            
+            # Vérification des doublons
+            if check_duplicates and self.is_duplicate(content):
+                skipped += 1
+                continue
+            
+            # Création du document LangChain
+            content_hash = self._compute_hash(content)
+            doc_id = f"{source}_{content_hash[:8]}_{datetime.now().timestamp()}"
+            
+            metadata = {
+                'title': doc.get('title', 'Sans titre'),
+                'url': doc.get('url', ''),
+                'source': source,
+                'timestamp': datetime.now().isoformat(),
+                'content_hash': content_hash,
+                'word_count': len(content.split())
+            }
+            
+            docs_to_add.append(content)
+            metadatas_to_add.append(metadata)
+            ids_to_add.append(doc_id)
+            self.content_hashes.add(content_hash)
+            added += 1
+        
+        # Ajout batch à ChromaDB
+        if docs_to_add:
+            self.collection.add(
+                documents=docs_to_add,
+                metadatas=metadatas_to_add,
+                ids=ids_to_add
+            )
+        
+        stats = {
+            'added': added,
+            'skipped': skipped,
+            'total_in_db': self.collection.count()
+        }
+        
+        print(f"✅ Ajoutés: {added} | Doublons ignorés: {skipped} | Total DB: {stats['total_in_db']}")
+        return stats
+    
+    def semantic_search(self, 
+                       query: str, 
+                       k: int = 5,
+                       filter_dict: Optional[Dict] = None) -> List[Tuple[Document, float]]:
+        """
+        Recherche sémantique dans le vectorstore
+        
+        Args:
+            query: Requête de recherche
+            k: Nombre de résultats à retourner
+            filter_dict: Filtres sur les métadonnées (ex: {'source': 'research'})
+        
+        Returns:
+            Liste de tuples (Document, score)
+        """
+        print(f"\n🔍 Recherche sémantique: '{query}' (top-{k})")
+        
+        results = self.vectorstore.similarity_search_with_score(
+            query=query,
+            k=k,
+            filter=filter_dict
+        )
+        
+        print(f"✅ {len(results)} résultats trouvés")
+        return results
+    
+    def get_relevant_context(self, 
+                            query: str, 
+                            k: int = 3,
+                            source_filter: Optional[str] = None) -> str:
+        """
+        Récupère le contexte pertinent pour une requête
+        
+        Args:
+            query: Requête
+            k: Nombre de documents à récupérer
+            source_filter: Filtrer par source (research, summary, etc.)
+        
+        Returns:
+            Contexte formaté en string
+        """
+        filter_dict = {"source": source_filter} if source_filter else None
+        results = self.semantic_search(query, k=k, filter_dict=filter_dict)
+        
+        if not results:
+            return ""
+        
+        context_parts = []
+        for i, (doc, score) in enumerate(results, 1):
+            context_parts.append(
+                f"[Source {i} - Pertinence: {score:.2f}]\n"
+                f"Titre: {doc.metadata.get('title', 'N/A')}\n"
+                f"{doc.page_content[:500]}...\n"
+            )
+        
+        return "\n---\n".join(context_parts)
+    
+    def clear_old_documents(self, days: int = 30) -> int:
+        """
+        Supprime les documents plus anciens que X jours
+        
+        Args:
+            days: Nombre de jours de rétention
+        
+        Returns:
+            Nombre de documents supprimés
+        """
+        print(f"\n🧹 Nettoyage des documents > {days} jours...")
+        
+        from datetime import timedelta
+        cutoff_date = datetime.now() - timedelta(days=days)
+        
+        results = self.collection.get(include=['metadatas'])
+        ids_to_delete = []
+        
+        for doc_id, metadata in zip(results['ids'], results['metadatas']):
+            timestamp_str = metadata.get('timestamp', '')
+            try:
+                doc_date = datetime.fromisoformat(timestamp_str)
+                if doc_date < cutoff_date:
+                    ids_to_delete.append(doc_id)
+                    hash_to_remove = metadata.get('content_hash')
+                    if hash_to_remove:
+                        self.content_hashes.discard(hash_to_remove)
+            except:
+                continue
+        
+        if ids_to_delete:
+            self.collection.delete(ids=ids_to_delete)
+        
+        print(f"✅ {len(ids_to_delete)} documents supprimés")
+        return len(ids_to_delete)
+
+
+# ============================================================================
+# GESTIONNAIRE DE MÉMOIRE D'AGENT
+# ============================================================================
+
+class AgentMemoryManager:
+    """Gère l'historique des conversations et résumés"""
+    
+    def __init__(self, 
+                 memory_file: str = "./agent_memory.pkl",
+                 max_history: int = 100,
+                 compression_threshold: int = 50):
+        """
+        Initialise le gestionnaire de mémoire d'agent
+        
+        Args:
+            memory_file: Fichier de sauvegarde de la mémoire
+            max_history: Nombre maximum d'entrées dans l'historique
+            compression_threshold: Seuil pour compression de mémoire
+        """
+        self.memory_file = Path(memory_file)
+        self.max_history = max_history
+        self.compression_threshold = compression_threshold
+        
+        # Structures de données
+        self.conversation_history = deque(maxlen=max_history)
+        self.research_cache = {}  # topic -> result
+        self.summary_cache = {}    # topic -> summary
+        self.topic_keywords = {}   # topic -> keywords
+        
+        print(f"🧠 Initialisation du gestionnaire de mémoire d'agent...")
+        self._load_memory()
+    
+    def _load_memory(self):
+        """Charge la mémoire depuis le fichier"""
+        if self.memory_file.exists():
+            try:
+                with open(self.memory_file, 'rb') as f:
+                    data = pickle.load(f)
+                    self.conversation_history = data.get('conversation_history', deque(maxlen=self.max_history))
+                    self.research_cache = data.get('research_cache', {})
+                    self.summary_cache = data.get('summary_cache', {})
+                    self.topic_keywords = data.get('topic_keywords', {})
+                print(f"✅ Mémoire chargée: {len(self.conversation_history)} conversations, "
+                      f"{len(self.research_cache)} recherches en cache")
+            except Exception as e:
+                print(f"⚠️ Erreur lors du chargement de la mémoire: {e}")
+        else:
+            print("ℹ️ Nouvelle mémoire initialisée")
+    
+    def _save_memory(self):
+        """Sauvegarde la mémoire dans le fichier"""
+        try:
+            data = {
+                'conversation_history': self.conversation_history,
+                'research_cache': self.research_cache,
+                'summary_cache': self.summary_cache,
+                'topic_keywords': self.topic_keywords
+            }
+            with open(self.memory_file, 'wb') as f:
+                pickle.dump(data, f)
+        except Exception as e:
+            print(f"⚠️ Erreur lors de la sauvegarde de la mémoire: {e}")
+    
+    def add_conversation(self, user_message: str, assistant_response: str, metadata: Optional[Dict] = None):
+        """Ajoute une conversation à l'historique"""
+        entry = {
+            'timestamp': datetime.now().isoformat(),
+            'user': user_message,
+            'assistant': assistant_response,
+            'metadata': metadata or {}
+        }
+        self.conversation_history.append(entry)
+        
+        # Compression si nécessaire
+        if len(self.conversation_history) >= self.compression_threshold:
+            self._compress_memory()
+        
+        self._save_memory()
+    
+    def add_research_result(self, topic: str, result: any, keywords: List[str]):
+        """Cache un résultat de recherche"""
+        self.research_cache[topic] = {
+            'result': result,
+            'timestamp': datetime.now().isoformat()
+        }
+        self.topic_keywords[topic] = keywords
+        self._save_memory()
+    
+    def get_research_result(self, topic: str, max_age_hours: int = 24) -> Optional[any]:
+        """Récupère un résultat de recherche en cache"""
+        if topic not in self.research_cache:
+            return None
+        
+        cached = self.research_cache[topic]
+        cached_time = datetime.fromisoformat(cached['timestamp'])
+        
+        from datetime import timedelta
+        if datetime.now() - cached_time > timedelta(hours=max_age_hours):
+            print(f"ℹ️ Cache expiré pour '{topic}'")
+            return None
+        
+        print(f"✅ Résultat récupéré du cache pour '{topic}'")
+        return cached['result']
+    
+    def add_summary(self, topic: str, summary: str):
+        """Ajoute un résumé au cache"""
+        self.summary_cache[topic] = {
+            'summary': summary,
+            'timestamp': datetime.now().isoformat()
+        }
+        self._save_memory()
+    
+    def get_conversation_context(self, n_last: int = 5) -> str:
+        """Récupère le contexte des N dernières conversations"""
+        recent = list(self.conversation_history)[-n_last:]
+        
+        if not recent:
+            return ""
+        
+        context = "Contexte des conversations récentes:\n"
+        for i, conv in enumerate(recent, 1):
+            context += f"\n[Conversation {i}]\n"
+            context += f"User: {conv['user'][:100]}...\n"
+            context += f"Assistant: {conv['assistant'][:100]}...\n"
+        
+        return context
+    
+    def _compress_memory(self):
+        """Compresse la mémoire en gardant seulement les éléments importants"""
+        print("🗜️ Compression de la mémoire...")
+        
+        # Supprimer les anciennes recherches en cache (> 7 jours)
+        from datetime import timedelta
+        cutoff = datetime.now() - timedelta(days=7)
+        
+        topics_to_remove = []
+        for topic, data in self.research_cache.items():
+            if datetime.fromisoformat(data['timestamp']) < cutoff:
+                topics_to_remove.append(topic)
+        
+        for topic in topics_to_remove:
+            del self.research_cache[topic]
+            if topic in self.topic_keywords:
+                del self.topic_keywords[topic]
+        
+        print(f"✅ {len(topics_to_remove)} anciennes recherches supprimées")
+        self._save_memory()
+    
+    def get_related_topics(self, topic: str, threshold: float = 0.5) -> List[str]:
+        """Trouve les topics similaires dans l'historique"""
+        from difflib import SequenceMatcher
+        
+        related = []
+        for cached_topic in self.research_cache.keys():
+            similarity = SequenceMatcher(None, topic.lower(), cached_topic.lower()).ratio()
+            if similarity > threshold:
+                related.append((cached_topic, similarity))
+        
+        return [t for t, _ in sorted(related, key=lambda x: x[1], reverse=True)]
+    
+    def clear_all(self):
+        """Réinitialise complètement la mémoire"""
+        print("🗑️ Réinitialisation complète de la mémoire...")
+        self.conversation_history.clear()
+        self.research_cache.clear()
+        self.summary_cache.clear()
+        self.topic_keywords.clear()
+        self._save_memory()
+        print("✅ Mémoire réinitialisée")
+
+
+# ============================================================================
+# GESTIONNAIRE INTÉGRÉ
+# ============================================================================
+
+class IntegratedMemorySystem:
+    """Système de mémoire intégré combinant vectoriel et agent"""
+    
+    def __init__(self):
+        self.vector_memory = VectorMemoryManager()
+        self.agent_memory = AgentMemoryManager()
+        print("✨ Système de mémoire intégré initialisé\n")
+    
+    def process_research_result(self, 
+                               topic: str, 
+                               extraction_result: any,
+                               summarization_result: any,
+                               global_synthesis: any):
+        """
+        Traite et stocke tous les résultats d'une recherche
+        
+        Args:
+            topic: Sujet de la recherche
+            extraction_result: Résultat de l'extraction
+            summarization_result: Résultat des résumés
+            global_synthesis: Synthèse globale
+        """
+        print(f"\n💾 Stockage des résultats pour '{topic}'...")
+        
+        # 1. Stocker les documents extraits dans le vectorstore
+        if extraction_result and hasattr(extraction_result, 'documents'):
+            docs_to_store = []
+            for doc in extraction_result.documents:
+                docs_to_store.append({
+                    'content': doc.content,
+                    'title': doc.title,
+                    'url': str(doc.url)
+                })
+            self.vector_memory.add_documents(docs_to_store, source='research')
+        
+        # 2. Stocker les résumés
+        if summarization_result and hasattr(summarization_result, 'summaries'):
+            summaries_to_store = []
+            for summary in summarization_result.summaries:
+                summaries_to_store.append({
+                    'content': summary.detailed_summary,
+                    'title': summary.title,
+                    'url': str(summary.url)
+                })
+            self.vector_memory.add_documents(summaries_to_store, source='summary')
+        
+        # 3. Stocker la synthèse globale
+        if global_synthesis and hasattr(global_synthesis, 'final_report'):
+            synthesis_text = global_synthesis.final_report.formatted_outputs.get('text', '')
+            self.vector_memory.add_documents([{
+                'content': synthesis_text,
+                'title': f"Synthèse: {topic}",
+                'url': ''
+            }], source='synthesis')
+        
+        # 4. Mettre en cache dans la mémoire agent
+        keywords = []
+        if hasattr(extraction_result, 'documents'):
+            # Extraire quelques mots-clés simples
+            all_text = ' '.join([doc.content[:100] for doc in extraction_result.documents[:3]])
+            keywords = list(set(all_text.split()[:10]))
+        
+        self.agent_memory.add_research_result(topic, global_synthesis, keywords)
+        
+        print("✅ Tous les résultats stockés avec succès")
+    
+    def retrieve_context_for_query(self, query: str, use_cache: bool = True) -> Dict:
+        """
+        Récupère le contexte pertinent pour une requête
+        
+        Args:
+            query: Requête de l'utilisateur
+            use_cache: Utiliser le cache si disponible
+        
+        Returns:
+            Dict avec le contexte vectoriel et conversationnel
+        """
+        context = {
+            'semantic_context': '',
+            'conversation_context': '',
+            'cached_result': None,
+            'related_topics': []
+        }
+        
+        # 1. Vérifier le cache
+        if use_cache:
+            context['cached_result'] = self.agent_memory.get_research_result(query)
+        
+        # 2. Recherche sémantique
+        context['semantic_context'] = self.vector_memory.get_relevant_context(query, k=3)
+        
+        # 3. Contexte conversationnel
+        context['conversation_context'] = self.agent_memory.get_conversation_context(n_last=3)
+        
+        # 4. Topics similaires
+        context['related_topics'] = self.agent_memory.get_related_topics(query)
+        
+        return context
+
+
+# ============================================================================
+# INITIALISATION GLOBALE
+# ============================================================================
+
+# Instance globale du système de mémoire
+memory_system = IntegratedMemorySystem()
+
+print("="*60)
+print("✅ SYSTÈME DE MÉMOIRE PRÊT")
+print("="*60)

src/models/__init__.py

@@ -0,0 +1,64 @@
+"""
+Modèles de données Pydantic pour le système multi-agents.
+"""
+
+from .research_models import (
+    ResearchQuery,
+    SearchResult,
+    ResearchOutput
+)
+from .document_models import (
+    Document,
+    DocumentSummary,
+    SummarizationOutput,
+    KeyPoint,
+    Citation,
+    DocumentType
+)
+from .report_models import (
+    ReportSection,
+    Report,
+    ReportOutput,
+    Reference,
+    ReportFormat,
+    ReportMetadata
+)
+from .state_models import (
+    AgentState,
+    GraphState,
+    AgentType,
+    AgentStatus,
+    ProcessingStep,
+    WorkflowEvent
+)
+
+__all__ = [
+    # Research models
+    "ResearchQuery",
+    "SearchResult", 
+    "ResearchOutput",
+    
+    # Document models
+    "Document",
+    "DocumentSummary",
+    "SummarizationOutput",
+    "KeyPoint",
+    "Citation", 
+    "DocumentType",
+    
+    # Report models
+    "ReportSection",
+    "Report",
+    "ReportOutput",
+    "Reference",
+    "ReportFormat",
+    "ReportMetadata",
+    
+    # State models
+    "AgentState",
+    "GraphState",
+    "AgentType",
+    "AgentStatus",
+    "ProcessingStep",
+    "WorkflowEvent"
+]

src/models/document_models.py

@@ -0,0 +1,232 @@
+"""
+Modèles Pydantic pour l'agent Reader/Summarizer.
+Définit les structures de données pour les documents et leurs résumés.
+"""
+
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field, HttpUrl
+from enum import Enum
+
+
+class DocumentType(str, Enum):
+    """Types de documents supportés."""
+    ARTICLE = "article"
+    BLOG_POST = "blog_post"
+    ACADEMIC_PAPER = "academic_paper"
+    NEWS = "news"
+    REPORT = "report"
+    OTHER = "other"
+
+
+class Document(BaseModel):
+    """
+    Modèle pour un document à analyser.
+    """
+    title: str = Field(..., description="Titre du document")
+    url: HttpUrl = Field(..., description="URL source du document")
+    content: str = Field(..., description="Contenu textuel complet du document")
+    doc_type: DocumentType = Field(default=DocumentType.ARTICLE, description="Type de document")
+    author: Optional[str] = Field(default=None, description="Auteur du document")
+    published_date: Optional[datetime] = Field(default=None, description="Date de publication")
+    source: Optional[str] = Field(default=None, description="Site ou publication source")
+    word_count: int = Field(default=0, ge=0, description="Nombre de mots dans le document")
+    language: str = Field(default="fr", description="Langue du document (code ISO)")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "title": "L'impact de l'IA sur le futur du travail",
+                "url": "https://example.com/article-ia-travail",
+                "content": "L'intelligence artificielle transforme rapidement...",
+                "doc_type": "article",
+                "author": "Marie Martin",
+                "published_date": "2024-01-15T09:30:00Z",
+                "source": "TechMag",
+                "word_count": 1500,
+                "language": "fr"
+            }
+        }
+
+
+class ExtractionInput(BaseModel):
+    """
+    Input pour l'agent Content Extractor.
+    """
+    urls: List[str] = Field(..., description="Liste des URLs à extraire", min_items=1)
+    content_filters: Optional[Dict[str, Any]] = Field(
+        default_factory=dict,
+        description="Filtres à appliquer au contenu extrait"
+    )
+    extraction_options: Optional[Dict[str, Any]] = Field(
+        default_factory=dict,
+        description="Options d'extraction spécifiques"
+    )
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "urls": [
+                    "https://example.com/article1",
+                    "https://example.com/article2.pdf"
+                ],
+                "content_filters": {
+                    "min_content_length": 100,
+                    "max_content_length": 10000,
+                    "language": "fr",
+                    "required_keywords": ["intelligence artificielle"]
+                },
+                "extraction_options": {
+                    "timeout": 30,
+                    "max_retries": 2
+                }
+            }
+        }
+
+
+class ExtractionResult(BaseModel):
+    """
+    Résultat de l'extraction de contenu.
+    """
+    documents: List[Document] = Field(..., description="Documents extraits avec succès")
+    total_urls: int = Field(..., ge=0, description="Nombre total d'URLs traitées")
+    successful_extractions: int = Field(..., ge=0, description="Nombre d'extractions réussies")
+    failed_extractions: int = Field(..., ge=0, description="Nombre d'extractions échouées")
+    failed_urls: List[str] = Field(default_factory=list, description="URLs qui ont échoué lors de l'extraction")
+    execution_time: float = Field(..., ge=0, description="Temps d'exécution en secondes")
+    extraction_stats: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Statistiques détaillées de l'extraction"
+    )
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "documents": [],
+                "total_urls": 5,
+                "successful_extractions": 4,
+                "failed_extractions": 1,
+                "execution_time": 12.5,
+                "extraction_stats": {
+                    "total_words": 5000,
+                    "average_words_per_doc": 1250,
+                    "doc_types": {"article": 3, "pdf": 1},
+                    "languages": {"fr": 4}
+                }
+            }
+        }
+
+
+class KeyPoint(BaseModel):
+    """
+    Modèle pour un point clé extrait d'un document.
+    """
+    title: str = Field(..., description="Titre du point clé")
+    content: str = Field(..., description="Contenu détaillé du point")
+    importance: float = Field(..., ge=0, le=1, description="Score d'importance (0-1)")
+    category: Optional[str] = Field(default=None, description="Catégorie du point clé")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "title": "Automatisation des tâches répétitives",
+                "content": "L'IA permet d'automatiser 30% des tâches actuelles...",
+                "importance": 0.9,
+                "category": "automatisation"
+            }
+        }
+
+
+class Citation(BaseModel):
+    """
+    Modèle pour une citation importante extraite du document.
+    """
+    text: str = Field(..., description="Texte de la citation")
+    author: Optional[str] = Field(default=None, description="Auteur de la citation")
+    context: Optional[str] = Field(default=None, description="Contexte de la citation")
+    page_number: Optional[int] = Field(default=None, description="Numéro de page (si applicable)")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "text": "L'IA ne remplacera pas les humains, elle augmentera leurs capacités",
+                "author": "Dr. Jean Dupont",
+                "context": "Conclusion de l'étude sur l'IA et l'emploi",
+                "page_number": None
+            }
+        }
+
+
+class DocumentSummary(BaseModel):
+    """
+    Modèle pour le résumé d'un document.
+    """
+    document_id: str = Field(..., description="Identifiant unique du document")
+    title: str = Field(..., description="Titre du document original")
+    url: HttpUrl = Field(..., description="URL du document original")
+    
+    # Résumé principal
+    executive_summary: str = Field(..., description="Résumé exécutif (2-3 phrases)")
+    detailed_summary: str = Field(..., description="Résumé détaillé (1-2 paragraphes)")
+    
+    # Points clés
+    key_points: List[KeyPoint] = Field(default_factory=list, description="Points clés extraits")
+    main_arguments: List[str] = Field(default_factory=list, description="Arguments principaux")
+    
+    # Citations et données
+    important_citations: List[Citation] = Field(default_factory=list, description="Citations importantes")
+    statistics: List[str] = Field(default_factory=list, description="Statistiques mentionnées")
+    
+    # Métadonnées d'analyse
+    sentiment: Optional[str] = Field(default=None, description="Sentiment général (positif/neutre/négatif)")
+    bias_assessment: Optional[str] = Field(default=None, description="Évaluation des biais potentiels")
+    credibility_score: Optional[float] = Field(default=None, ge=0, le=1, description="Score de crédibilité (0-1)")
+    
+    # Informations de traitement
+    processed_at: datetime = Field(default_factory=datetime.now, description="Horodatage du traitement")
+    processing_time: float = Field(default=0.0, ge=0, description="Temps de traitement en secondes")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "document_id": "doc_123",
+                "title": "L'impact de l'IA sur le futur du travail",
+                "url": "https://example.com/article",
+                "executive_summary": "L'IA transformera 60% des emplois d'ici 2030...",
+                "detailed_summary": "Cette étude approfondie examine...",
+                "key_points": [],
+                "sentiment": "neutre",
+                "credibility_score": 0.8,
+                "processed_at": "2024-01-15T10:15:00Z",
+                "processing_time": 5.2
+            }
+        }
+
+
+class SummarizationOutput(BaseModel):
+    """
+    Modèle pour l'output complet de l'agent Reader/Summarizer.
+    """
+    summaries: List[DocumentSummary] = Field(..., description="Liste des résumés de documents")
+    total_documents: int = Field(..., ge=0, description="Nombre total de documents traités")
+    total_processing_time: float = Field(..., ge=0, description="Temps total de traitement")
+    average_credibility: Optional[float] = Field(default=None, ge=0, le=1, description="Score de crédibilité moyen")
+    
+    # Analyse globale
+    common_themes: List[str] = Field(default_factory=list, description="Thèmes récurrents identifiés")
+    consensus_points: List[str] = Field(default_factory=list, description="Points de consensus entre les sources")
+    conflicting_views: List[str] = Field(default_factory=list, description="Points de vue conflictuels")
+    
+    timestamp: datetime = Field(default_factory=datetime.now, description="Horodatage de l'analyse")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "summaries": [],
+                "total_documents": 5,
+                "total_processing_time": 25.6,
+                "average_credibility": 0.75,
+                "common_themes": ["automatisation", "formation", "adaptation"],
+                "timestamp": "2024-01-15T10:30:00Z"
+            }
+        }

src/models/report_models.py

@@ -0,0 +1,221 @@
+"""
+Modèles Pydantic pour l'agent Writer/Reporter.
+Définit les structures de données pour la génération de rapports.
+"""
+
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field
+from enum import Enum
+
+
+class ReportFormat(str, Enum):
+    """Formats de rapport supportés."""
+    MARKDOWN = "markdown"
+    PDF = "pdf"
+    HTML = "html"
+    DOCX = "docx"
+
+
+class SectionType(str, Enum):
+    """Types de sections dans un rapport."""
+    INTRODUCTION = "introduction"
+    EXECUTIVE_SUMMARY = "executive_summary"
+    MAIN_FINDINGS = "main_findings"
+    DETAILED_ANALYSIS = "detailed_analysis"
+    CONCLUSIONS = "conclusions"
+    RECOMMENDATIONS = "recommendations"
+    BIBLIOGRAPHY = "bibliography"
+    APPENDIX = "appendix"
+
+
+class Reference(BaseModel):
+    """
+    Modèle pour une référence bibliographique.
+    """
+    title: str = Field(..., description="Titre de la source")
+    url: str = Field(..., description="URL de la source")
+    author: Optional[str] = Field(default=None, description="Auteur de la source")
+    published_date: Optional[datetime] = Field(default=None, description="Date de publication")
+    source: Optional[str] = Field(default=None, description="Publication ou site source")
+    accessed_date: datetime = Field(default_factory=datetime.now, description="Date d'accès")
+    
+    def to_citation(self, style: str = "apa") -> str:
+        """
+        Génère une citation formatée selon le style demandé.
+        """
+        if style.lower() == "apa":
+            parts = []
+            if self.author:
+                parts.append(f"{self.author}")
+            if self.published_date:
+                parts.append(f"({self.published_date.year})")
+            parts.append(f"{self.title}")
+            if self.source:
+                parts.append(f"{self.source}")
+            parts.append(f"Récupéré de {self.url}")
+            return ". ".join(parts) + "."
+        return f"{self.title} - {self.url}"
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "title": "L'IA et l'emploi : défis et opportunités",
+                "url": "https://example.com/article",
+                "author": "Dr. Marie Dubois",
+                "published_date": "2024-01-10T00:00:00Z",
+                "source": "Revue Technologique",
+                "accessed_date": "2024-01-15T10:00:00Z"
+            }
+        }
+
+
+class ReportSection(BaseModel):
+    """
+    Modèle pour une section de rapport.
+    """
+    title: str = Field(..., description="Titre de la section")
+    content: str = Field(..., description="Contenu de la section en markdown")
+    section_type: SectionType = Field(..., description="Type de section")
+    subsections: List['ReportSection'] = Field(default_factory=list, description="Sous-sections")
+    references: List[Reference] = Field(default_factory=list, description="Références citées dans cette section")
+    order: int = Field(default=0, description="Ordre d'affichage de la section")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "title": "Introduction",
+                "content": "L'intelligence artificielle transforme rapidement...",
+                "section_type": "introduction",
+                "subsections": [],
+                "references": [],
+                "order": 1
+            }
+        }
+
+
+class ReportMetadata(BaseModel):
+    """
+    Métadonnées du rapport.
+    """
+    title: str = Field(..., description="Titre du rapport")
+    subtitle: Optional[str] = Field(default=None, description="Sous-titre du rapport")
+    author: str = Field(default="AI Research Assistant", description="Auteur du rapport")
+    creation_date: datetime = Field(default_factory=datetime.now, description="Date de création")
+    version: str = Field(default="1.0", description="Version du rapport")
+    
+    # Informations sur la recherche
+    research_topic: str = Field(..., description="Sujet de recherche original")
+    sources_count: int = Field(default=0, ge=0, description="Nombre de sources utilisées")
+    
+    # Tags et classification
+    keywords: List[str] = Field(default_factory=list, description="Mots-clés du rapport")
+    categories: List[str] = Field(default_factory=list, description="Catégories du rapport")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "title": "Impact de l'Intelligence Artificielle sur l'Emploi",
+                "subtitle": "Analyse des tendances actuelles et perspectives d'avenir",
+                "author": "AI Research Assistant",
+                "research_topic": "impact de l'IA sur l'emploi",
+                "sources_count": 8,
+                "keywords": ["IA", "emploi", "automatisation"],
+                "categories": ["technologie", "économie"]
+            }
+        }
+
+
+class Report(BaseModel):
+    """
+    Modèle complet pour un rapport de recherche.
+    """
+    metadata: ReportMetadata = Field(..., description="Métadonnées du rapport")
+    sections: List[ReportSection] = Field(..., description="Sections du rapport")
+    bibliography: List[Reference] = Field(..., description="Bibliographie complète")
+    
+    # Configuration de formatage
+    format_config: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Configuration de formatage spécifique au format de sortie"
+    )
+    
+    # Statistiques du rapport
+    word_count: int = Field(default=0, ge=0, description="Nombre de mots total")
+    reading_time_minutes: int = Field(default=0, ge=0, description="Temps de lecture estimé en minutes")
+    
+    def calculate_word_count(self) -> int:
+        """Calcule le nombre de mots total du rapport."""
+        total_words = 0
+        for section in self.sections:
+            total_words += len(section.content.split())
+            # Récursif pour les sous-sections
+            def count_subsection_words(subsections):
+                words = 0
+                for subsection in subsections:
+                    words += len(subsection.content.split())
+                    words += count_subsection_words(subsection.subsections)
+                return words
+            total_words += count_subsection_words(section.subsections)
+        return total_words
+    
+    def calculate_reading_time(self, words_per_minute: int = 200) -> int:
+        """Calcule le temps de lecture estimé."""
+        if self.word_count == 0:
+            self.word_count = self.calculate_word_count()
+        return max(1, self.word_count // words_per_minute)
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "metadata": {
+                    "title": "Impact de l'IA sur l'Emploi",
+                    "research_topic": "impact de l'IA sur l'emploi",
+                    "sources_count": 5
+                },
+                "sections": [],
+                "bibliography": [],
+                "word_count": 2500,
+                "reading_time_minutes": 12
+            }
+        }
+
+
+class ReportOutput(BaseModel):
+    """
+    Modèle pour l'output de l'agent Writer/Reporter.
+    """
+    report: Report = Field(..., description="Le rapport généré")
+    output_format: ReportFormat = Field(..., description="Format de sortie demandé")
+    file_path: Optional[str] = Field(default=None, description="Chemin du fichier généré")
+    
+    # Informations de génération
+    generation_time: float = Field(default=0.0, ge=0, description="Temps de génération en secondes")
+    llm_calls: int = Field(default=0, ge=0, description="Nombre d'appels au LLM")
+    
+    # Qualité du rapport
+    quality_score: Optional[float] = Field(default=None, ge=0, le=1, description="Score de qualité estimé")
+    completeness_score: Optional[float] = Field(default=None, ge=0, le=1, description="Score de complétude")
+    
+    timestamp: datetime = Field(default_factory=datetime.now, description="Horodatage de la génération")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "report": {
+                    "metadata": {
+                        "title": "Impact de l'IA sur l'Emploi"
+                    }
+                },
+                "output_format": "markdown",
+                "file_path": "./output/rapport_ia_emploi.md",
+                "generation_time": 15.3,
+                "llm_calls": 3,
+                "quality_score": 0.85,
+                "timestamp": "2024-01-15T11:00:00Z"
+            }
+        }
+
+
+# Mise à jour des références pour éviter les erreurs de forward reference
+ReportSection.model_rebuild()

src/models/research_models.py

@@ -0,0 +1,86 @@
+"""
+Modèles Pydantic pour l'agent Researcher.
+Définit les structures de données pour les requêtes de recherche et les résultats.
+"""
+
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field, HttpUrl
+
+
+#Passer par llm --> to Retreive keywords
+class ResearchQuery(BaseModel):
+    """
+    Modèle pour une requête de recherche.
+    """
+    topic: str = Field(..., description="Le sujet de recherche principal")
+    keywords: List[str] = Field(default_factory=list, description="Mots-clés spécifiques à rechercher")
+    max_results: int = Field(default=5, ge=1, le=20, description="Nombre maximum de résultats à retourner")
+    search_depth: str = Field(default="basic", description="Profondeur de la recherche: 'basic' ou 'advanced'")
+    date_range: Optional[str] = Field(default=None, description="Période de recherche (ex: 'last_year', 'last_month')")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "topic": "impact de l'intelligence artificielle sur l'emploi",
+                "keywords": ["IA", "automatisation", "marché du travail"],
+                "max_results": 5,
+                "search_depth": "basic",
+                "date_range": "last_year" # Faire l'intégration de year also in the research agent
+            }
+        }
+
+
+class SearchResult(BaseModel):
+    """
+    Modèle pour un résultat de recherche individuel.
+    """
+    title: str = Field(..., description="Titre de l'article ou de la page")
+    url: HttpUrl = Field(..., description="URL de la source")
+    snippet: str = Field(..., description="Extrait ou résumé court du contenu")
+    published_date: Optional[datetime] = Field(default=None, description="Date de publication")
+    author: Optional[str] = Field(default=None, description="Auteur de l'article")
+    source: Optional[str] = Field(default=None, description="Site source (ex: 'lemonde.fr')")
+    score: Optional[float] = Field(default=None, ge=0, le=1, description="Score de pertinence (0-1)")
+    tags: List[str] = Field(default_factory=list, description="Tags ou catégories associées")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "title": "L'IA transforme le marché de l'emploi",
+                "url": "https://example.com/article",
+                "snippet": "Une étude récente montre que l'intelligence artificielle...",
+                "published_date": "2024-01-15T10:00:00Z",
+                "author": "Jean Dupont",
+                "source": "example.com",
+                "score": 0.85,
+                "tags": ["technologie", "emploi"]
+            }
+        }
+
+
+class ResearchOutput(BaseModel):
+    """
+    Modèle pour l'output complet de l'agent Researcher.
+    """
+    query: ResearchQuery = Field(..., description="La requête originale")
+    results: List[SearchResult] = Field(..., description="Liste des résultats trouvés")
+    total_found: int = Field(..., ge=0, description="Nombre total de résultats trouvés")
+    search_time: float = Field(..., ge=0, description="Temps de recherche en secondes")
+    search_engine: str = Field(..., description="Moteur de recherche utilisé (ex: 'tavily', 'serper')")
+    timestamp: datetime = Field(default_factory=datetime.now, description="Horodatage de la recherche")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "query": {
+                    "topic": "impact de l'IA sur l'emploi",
+                    "max_results": 5
+                },
+                "results": [],
+                "total_found": 15,
+                "search_time": 2.3,
+                "search_engine": "tavily",
+                "timestamp": "2024-01-15T10:00:00Z"
+            }
+        }

src/models/state_models.py

@@ -0,0 +1,212 @@
+"""
+Modèles d'état pour l'orchestration LangGraph.
+Définit l'état global du système et les états des agents.
+"""
+
+from typing import List, Optional, Dict, Any, Union
+from datetime import datetime
+from pydantic import BaseModel, Field
+from enum import Enum
+
+from .research_models import ResearchQuery, ResearchOutput
+from .document_models import SummarizationOutput
+from .report_models import ReportOutput
+
+
+class AgentType(str, Enum):
+    """Types d'agents dans le système."""
+    RESEARCHER = "researcher"
+    CONTENT_EXTRACTOR = "content_extractor"
+    READER = "reader"
+    WRITER = "writer"
+
+
+class AgentStatus(str, Enum):
+    """Statuts possibles d'un agent."""
+    IDLE = "idle"
+    WORKING = "working"
+    COMPLETED = "completed"
+    ERROR = "error"
+    TIMEOUT = "timeout"
+
+
+class ProcessingStep(str, Enum):
+    """Étapes du processus de recherche."""
+    INIT = "init"
+    RESEARCH = "research"
+    READING = "reading" 
+    WRITING = "writing"
+    COMPLETED = "completed"
+    ERROR = "error"
+
+
+class AgentState(BaseModel):
+    """
+    État individuel d'un agent.
+    """
+    agent_type: AgentType = Field(..., description="Type de l'agent")
+    status: AgentStatus = Field(default=AgentStatus.IDLE, description="Statut actuel")
+    
+    # Informations de timing
+    start_time: Optional[datetime] = Field(default=None, description="Heure de début d'exécution")
+    end_time: Optional[datetime] = Field(default=None, description="Heure de fin d'exécution")
+    duration: Optional[float] = Field(default=None, description="Durée d'exécution en secondes")
+    
+    # Gestion des erreurs
+    error_message: Optional[str] = Field(default=None, description="Message d'erreur si applicable")
+    retry_count: int = Field(default=0, ge=0, description="Nombre de tentatives")
+    max_retries: int = Field(default=3, ge=0, description="Nombre maximum de tentatives")
+    
+    # Métadonnées spécifiques à l'agent
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Données spécifiques à l'agent")
+    
+    def start_execution(self):
+        """Marque le début de l'exécution."""
+        self.status = AgentStatus.WORKING
+        self.start_time = datetime.now()
+        self.end_time = None
+    
+    def complete_execution(self):
+        """Marque la fin réussie de l'exécution."""
+        self.status = AgentStatus.COMPLETED
+        self.end_time = datetime.now()
+        if self.start_time:
+            self.duration = (self.end_time - self.start_time).total_seconds()
+    
+    def mark_error(self, error_message: str):
+        """Marque l'agent en erreur."""
+        self.status = AgentStatus.ERROR
+        self.error_message = error_message
+        self.end_time = datetime.now()
+        if self.start_time:
+            self.duration = (self.end_time - self.start_time).total_seconds()
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "agent_type": "researcher",
+                "status": "completed",
+                "start_time": "2024-01-15T10:00:00Z",
+                "end_time": "2024-01-15T10:02:30Z",
+                "duration": 150.0,
+                "retry_count": 0,
+                "metadata": {"search_engine": "tavily"}
+            }
+        }
+
+
+class GraphState(BaseModel):
+    """
+    État global du graph LangGraph.
+    Contient toutes les données partagées entre les agents.
+    """
+    # Identification de la session
+    session_id: str = Field(..., description="Identifiant unique de la session")
+    current_step: ProcessingStep = Field(default=ProcessingStep.INIT, description="Étape actuelle du processus")
+    
+    # Requête initiale
+    original_query: Optional[ResearchQuery] = Field(default=None, description="Requête de recherche originale")
+    
+    # États des agents
+    agents: Dict[AgentType, AgentState] = Field(
+        default_factory=lambda: {
+            AgentType.RESEARCHER: AgentState(agent_type=AgentType.RESEARCHER),
+            AgentType.READER: AgentState(agent_type=AgentType.READER),
+            AgentType.WRITER: AgentState(agent_type=AgentType.WRITER)
+        },
+        description="État de chaque agent"
+    )
+    
+    # Données partagées entre agents
+    research_output: Optional[ResearchOutput] = Field(default=None, description="Résultats de recherche")
+    summarization_output: Optional[SummarizationOutput] = Field(default=None, description="Résultats de synthèse")
+    report_output: Optional[ReportOutput] = Field(default=None, description="Rapport final")
+    
+    # Métadonnées globales
+    start_time: datetime = Field(default_factory=datetime.now, description="Heure de début du processus")
+    end_time: Optional[datetime] = Field(default=None, description="Heure de fin du processus")
+    total_duration: Optional[float] = Field(default=None, description="Durée totale en secondes")
+    
+    # Configuration et paramètres
+    config: Dict[str, Any] = Field(default_factory=dict, description="Configuration du processus")
+    user_preferences: Dict[str, Any] = Field(default_factory=dict, description="Préférences utilisateur")
+    
+    # Gestion des erreurs globales
+    global_errors: List[str] = Field(default_factory=list, description="Erreurs globales du processus")
+    is_successful: bool = Field(default=False, description="Indique si le processus s'est terminé avec succès")
+    
+    # Informations de débogage
+    debug_info: Dict[str, Any] = Field(default_factory=dict, description="Informations de débogage")
+    
+    def get_current_agent(self) -> Optional[AgentType]:
+        """Retourne l'agent actuellement en cours d'exécution."""
+        for agent_type, agent_state in self.agents.items():
+            if agent_state.status == AgentStatus.WORKING:
+                return agent_type
+        return None
+    
+    def is_agent_completed(self, agent_type: AgentType) -> bool:
+        """Vérifie si un agent a terminé son exécution."""
+        return self.agents[agent_type].status == AgentStatus.COMPLETED
+    
+    def all_agents_completed(self) -> bool:
+        """Vérifie si tous les agents ont terminé."""
+        return all(
+            agent.status == AgentStatus.COMPLETED 
+            for agent in self.agents.values()
+        )
+    
+    def has_errors(self) -> bool:
+        """Vérifie s'il y a des erreurs dans le processus."""
+        return (
+            len(self.global_errors) > 0 or
+            any(agent.status == AgentStatus.ERROR for agent in self.agents.values())
+        )
+    
+    def complete_process(self):
+        """Marque le processus comme terminé."""
+        self.end_time = datetime.now()
+        self.total_duration = (self.end_time - self.start_time).total_seconds()
+        self.current_step = ProcessingStep.COMPLETED
+        self.is_successful = not self.has_errors()
+    
+    def add_global_error(self, error_message: str):
+        """Ajoute une erreur globale."""
+        self.global_errors.append(error_message)
+        self.current_step = ProcessingStep.ERROR
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "session_id": "session_123",
+                "current_step": "research",
+                "original_query": {
+                    "topic": "impact de l'IA sur l'emploi"
+                },
+                "start_time": "2024-01-15T10:00:00Z",
+                "is_successful": False,
+                "global_errors": []
+            }
+        }
+
+
+class WorkflowEvent(BaseModel):
+    """
+    Événement dans le workflow LangGraph.
+    """
+    event_id: str = Field(..., description="Identifiant unique de l'événement")
+    event_type: str = Field(..., description="Type d'événement")
+    agent_type: Optional[AgentType] = Field(default=None, description="Agent concerné")
+    timestamp: datetime = Field(default_factory=datetime.now, description="Horodatage de l'événement")
+    data: Dict[str, Any] = Field(default_factory=dict, description="Données associées à l'événement")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "event_id": "evt_001",
+                "event_type": "agent_started",
+                "agent_type": "researcher",
+                "timestamp": "2024-01-15T10:00:00Z",
+                "data": {"query": "impact IA emploi"}
+            }
+        }

src/models/synthesis_models.py

@@ -0,0 +1,306 @@
+"""
+Modèles Pydantic pour l'agent Global Synthesizer.
+Définit les structures de données pour la synthèse finale et le rapport global.
+"""
+
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field
+from enum import Enum
+
+from src.models.document_models import DocumentSummary, SummarizationOutput
+
+
+class ReportType(str, Enum):
+    """Types de rapports de synthèse finale."""
+    EXECUTIVE = "executive"  # Rapport exécutif court
+    DETAILED = "detailed"   # Rapport détaillé complet
+    ACADEMIC = "academic"   # Rapport de style académique
+    BUSINESS = "business"   # Rapport orienté business
+
+
+class ReportFormat(str, Enum):
+    """Formats de sortie du rapport."""
+    MARKDOWN = "markdown"
+    HTML = "html"
+    TEXT = "text"
+
+
+class GlobalSynthesisInput(BaseModel):
+    """
+    Input pour l'agent Global Synthesizer.
+    """
+    summarization_output: SummarizationOutput = Field(
+        ..., 
+        description="Sortie complète de l'agent Summarizer avec tous les résumés"
+    )
+    original_topic: str = Field(
+        ..., 
+        description="Sujet de recherche original"
+    )
+    synthesis_options: Optional[Dict[str, Any]] = Field(
+        default_factory=dict,
+        description="Options de configuration pour la synthèse"
+    )
+    
+    # Options configurables avec valeurs par défaut
+    report_type: ReportType = Field(
+        default=ReportType.DETAILED,
+        description="Type de rapport à générer"
+    )
+    report_format: ReportFormat = Field(
+        default=ReportFormat.MARKDOWN,
+        description="Format de sortie du rapport"
+    )
+    include_methodology: bool = Field(
+        default=True,
+        description="Inclure la section méthodologie"
+    )
+    include_sources: bool = Field(
+        default=True,
+        description="Inclure les références des sources"
+    )
+    include_limitations: bool = Field(
+        default=True,
+        description="Inclure les limitations de l'analyse"
+    )
+    max_report_length: int = Field(
+        default=5000,
+        description="Longueur maximale du rapport en mots"
+    )
+    target_audience: str = Field(
+        default="general",
+        description="Audience cible (general, business, academic, policy_makers)"
+    )
+    
+    def __init__(self, **data):
+        # Extraire les options de synthesis_options si présentes
+        synthesis_options = data.get('synthesis_options', {})
+        
+        # Appliquer les options aux champs correspondants
+        if 'report_type' in synthesis_options:
+            data['report_type'] = synthesis_options['report_type']
+        if 'report_format' in synthesis_options:
+            data['report_format'] = synthesis_options['report_format']
+        if 'include_methodology' in synthesis_options:
+            data['include_methodology'] = synthesis_options['include_methodology']
+        if 'include_sources' in synthesis_options:
+            data['include_sources'] = synthesis_options['include_sources']
+        if 'include_limitations' in synthesis_options:
+            data['include_limitations'] = synthesis_options['include_limitations']
+        if 'max_report_length' in synthesis_options:
+            data['max_report_length'] = synthesis_options['max_report_length']
+        if 'target_audience' in synthesis_options:
+            data['target_audience'] = synthesis_options['target_audience']
+        
+        super().__init__(**data)
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "original_topic": "impact de l'intelligence artificielle sur l'emploi",
+                "synthesis_options": {
+                    "report_type": "detailed",
+                    "report_format": "markdown",
+                    "include_methodology": True,
+                    "include_sources": True,
+                    "target_audience": "business"
+                }
+            }
+        }
+
+
+class ExecutiveSummary(BaseModel):
+    """Résumé exécutif du rapport final."""
+    
+    key_findings: List[str] = Field(
+        default_factory=list,
+        description="3-5 conclusions principales"
+    )
+    main_insights: List[str] = Field(
+        default_factory=list,
+        description="Insights et découvertes principales"
+    )
+    recommendations: List[str] = Field(
+        default_factory=list,
+        description="Recommandations basées sur l'analyse"
+    )
+    summary_text: str = Field(
+        ...,
+        description="Texte de synthèse exécutive (2-3 paragraphes)"
+    )
+
+
+class ReportSection(BaseModel):
+    """Section individuelle du rapport."""
+    
+    title: str = Field(..., description="Titre de la section")
+    content: str = Field(..., description="Contenu de la section")
+    subsections: List['ReportSection'] = Field(
+        default_factory=list,
+        description="Sous-sections"
+    )
+    order: int = Field(default=0, description="Ordre d'affichage")
+
+
+class SourceReference(BaseModel):
+    """Référence bibliographique d'une source."""
+    
+    title: str = Field(..., description="Titre du document source")
+    url: str = Field(..., description="URL du document")
+    author: Optional[str] = Field(default=None, description="Auteur")
+    publication_date: Optional[datetime] = Field(default=None, description="Date de publication")
+    credibility_score: Optional[float] = Field(default=None, description="Score de crédibilité")
+    citation_count: int = Field(default=0, description="Nombre de fois citée dans le rapport")
+
+
+class Methodology(BaseModel):
+    """Description de la méthodologie utilisée."""
+    
+    research_approach: str = Field(..., description="Approche de recherche utilisée")
+    sources_count: int = Field(..., description="Nombre de sources analysées")
+    analysis_methods: List[str] = Field(
+        default_factory=list,
+        description="Méthodes d'analyse utilisées"
+    )
+    limitations: List[str] = Field(
+        default_factory=list,
+        description="Limitations de l'étude"
+    )
+    data_quality_assessment: str = Field(
+        ...,
+        description="Évaluation de la qualité des données"
+    )
+
+
+class FinalReport(BaseModel):
+    """
+    Modèle pour le rapport final de synthèse globale.
+    """
+    
+    # Métadonnées du rapport
+    report_id: str = Field(..., description="Identifiant unique du rapport")
+    title: str = Field(..., description="Titre du rapport")
+    topic: str = Field(..., description="Sujet de recherche original")
+    generated_at: datetime = Field(default_factory=datetime.now, description="Date de génération")
+    report_type: ReportType = Field(default=ReportType.DETAILED, description="Type de rapport")
+    report_format: ReportFormat = Field(default=ReportFormat.MARKDOWN, description="Format du rapport")
+    
+    # Contenu principal
+    executive_summary: ExecutiveSummary = Field(..., description="Résumé exécutif")
+    introduction: str = Field(..., description="Introduction du rapport")
+    main_sections: List[ReportSection] = Field(
+        default_factory=list,
+        description="Sections principales du rapport"
+    )
+    conclusion: str = Field(..., description="Conclusion du rapport")
+    
+    # Analyses transversales
+    key_themes: List[str] = Field(
+        default_factory=list,
+        description="Thèmes principaux identifiés"
+    )
+    consensus_points: List[str] = Field(
+        default_factory=list,
+        description="Points de consensus entre les sources"
+    )
+    conflicting_viewpoints: List[str] = Field(
+        default_factory=list,
+        description="Points de vue contradictoires"
+    )
+    emerging_trends: List[str] = Field(
+        default_factory=list,
+        description="Tendances émergentes identifiées"
+    )
+    
+    # Métadonnées d'analyse
+    methodology: Methodology = Field(..., description="Méthodologie utilisée")
+    sources: List[SourceReference] = Field(
+        default_factory=list,
+        description="Sources utilisées avec références"
+    )
+    
+    # Métriques de qualité
+    confidence_score: float = Field(
+        default=0.0,
+        ge=0.0,
+        le=1.0,
+        description="Score de confiance global (0-1)"
+    )
+    completeness_score: float = Field(
+        default=0.0,
+        ge=0.0,
+        le=1.0,
+        description="Score de complétude de l'analyse (0-1)"
+    )
+    
+    # Statistiques de traitement
+    total_sources_analyzed: int = Field(default=0, description="Nombre total de sources analysées")
+    processing_time: float = Field(default=0.0, description="Temps de traitement en secondes")
+    word_count: int = Field(default=0, description="Nombre de mots du rapport")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "report_id": "rpt_20241115_001",
+                "title": "Impact de l'Intelligence Artificielle sur l'Emploi - Rapport de Synthèse",
+                "topic": "impact de l'intelligence artificielle sur l'emploi",
+                "report_type": "detailed",
+                "executive_summary": {
+                    "key_findings": [
+                        "L'IA transformera 60% des emplois d'ici 2030",
+                        "Nouveaux emplois créés dans la tech et supervision IA"
+                    ],
+                    "summary_text": "Analyse complète de l'impact de l'IA..."
+                },
+                "confidence_score": 0.85,
+                "total_sources_analyzed": 5
+            }
+        }
+
+
+class GlobalSynthesisOutput(BaseModel):
+    """
+    Modèle pour l'output de l'agent Global Synthesizer.
+    """
+    
+    final_report: FinalReport = Field(..., description="Rapport final de synthèse")
+    synthesis_metadata: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Métadonnées sur le processus de synthèse"
+    )
+    processing_stats: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Statistiques de traitement"
+    )
+    
+    # Formats alternatifs du rapport
+    formatted_outputs: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Rapport formaté dans différents formats (markdown, html, etc.)"
+    )
+    
+    timestamp: datetime = Field(
+        default_factory=datetime.now,
+        description="Horodatage de la synthèse"
+    )
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "synthesis_metadata": {
+                    "llm_model_used": "groq/llama-3.1-8b-instant",
+                    "synthesis_strategy": "comprehensive",
+                    "quality_checks_passed": True
+                },
+                "processing_stats": {
+                    "input_summaries": 5,
+                    "synthesis_time": 15.3,
+                    "final_report_words": 2500
+                }
+            }
+        }
+
+
+# Configuration forward reference pour les modèles imbriqués
+ReportSection.model_rebuild()

src/services/__init__.py

@@ -0,0 +1,19 @@
+"""
+Package des services du système.
+"""
+
+from .search_api import (
+    SearchAPIManager,
+    TavilySearchAPI,
+    SerperSearchAPI,
+    SearchAPIError,
+    BaseSearchAPI
+)
+
+__all__ = [
+    "SearchAPIManager",
+    "TavilySearchAPI", 
+    "SerperSearchAPI",
+    "SearchAPIError",
+    "BaseSearchAPI"
+]

src/services/content_extraction.py

@@ -0,0 +1,462 @@
+"""
+Service d'extraction de contenu web.
+Supporte HTML, PDF et autres formats de documents.
+"""
+
+import aiohttp
+import asyncio
+from typing import Optional, List, Dict, Any, TYPE_CHECKING
+from urllib.parse import urljoin, urlparse
+from datetime import datetime
+import re
+import mimetypes
+
+from asyncssh import logger
+
+from src.core.logging import setup_logger
+from src.models.document_models import Document, DocumentType
+
+# Import conditionnel des dépendances
+try:
+    from bs4 import BeautifulSoup
+    BEAUTIFULSOUP_AVAILABLE = True
+except ImportError:
+    BEAUTIFULSOUP_AVAILABLE = False
+
+if TYPE_CHECKING:
+    from bs4 import BeautifulSoup
+
+try:
+    import PyPDF2
+    PDF_AVAILABLE = True
+except ImportError:
+    PDF_AVAILABLE = False
+    PyPDF2 = None
+
+try:
+    import requests
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+    requests = None
+
+
+class ContentExtractionError(Exception):
+    """Exception pour les erreurs d'extraction de contenu."""
+    pass
+
+
+class WebContentExtractor:
+    """
+    Extracteur de contenu web avec support multi-format.
+    """
+    
+    def __init__(self, timeout: int = 30, max_content_length: int = 10_000_000):
+        self.logger = setup_logger("content_extractor")
+        self.timeout = timeout
+        self.max_content_length = max_content_length
+        
+        # Headers pour simuler un navigateur réel
+        self.headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'fr-FR,fr;q=0.9,en;q=0.8',
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+        }
+        
+        # Vérification des dépendances
+        self._check_dependencies()
+    
+    def _check_dependencies(self):
+        """Vérifie que les dépendances nécessaires sont installées."""
+        if not BEAUTIFULSOUP_AVAILABLE:
+            self.logger.warning("BeautifulSoup4 non installé - extraction HTML limitée")
+        if not PDF_AVAILABLE:
+            self.logger.warning("PyPDF2 non installé - extraction PDF non disponible")
+        if not REQUESTS_AVAILABLE:
+            self.logger.warning("requests non installé - extraction synchrone non disponible")
+    
+    async def extract_content(self, url: str) -> Document:
+        """
+        Extrait le contenu d'une URL.
+        
+        Args:
+            url: URL à extraire
+            
+        Returns:
+            Document avec le contenu extrait
+            
+        Raises:
+            ContentExtractionError: Si l'extraction échoue
+        """
+        self.logger.info(f"Extraction de contenu: {url}")
+        
+        try:
+            # Détecter le type de contenu
+            content_type = await self._detect_content_type(url)
+            
+            if content_type.startswith('application/pdf'):
+                return await self._extract_pdf_content(url)
+            elif content_type.startswith('text/html') or 'html' in content_type:
+                return await self._extract_html_content(url)
+            else:
+                # Tentative d'extraction générique
+                #################### faire aussi l'extraction en fonction de l'extension du fichier et le js ####################
+                return await self._extract_generic_content(url)
+                
+        except Exception as e:
+            self.logger.error(f"Erreur lors de l'extraction de {url}: {str(e)}")
+            raise ContentExtractionError(f"Impossible d'extraire le contenu de {url}: {str(e)}")
+    
+    async def _detect_content_type(self, url: str) -> str:
+        """Détecte le type de contenu d'une URL."""
+        try:
+            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+                async with session.head(url, headers=self.headers) as response:
+                    content_type = response.headers.get('content-type', '').lower()
+                    if content_type:
+                        return content_type.split(';')[0]  # Enlever le charset
+                    
+            # Fallback: détecter par extension
+            parsed_url = urlparse(url)
+            content_type, _ = mimetypes.guess_type(parsed_url.path)
+            return content_type or 'text/html'
+            
+        except Exception as e:
+            self.logger.warning(f"Impossible de détecter le type de contenu pour {url}: {e}")
+            return 'text/html'  # Default fallback
+    
+    async def _extract_html_content(self, url: str) -> Document:
+        """Extrait le contenu d'une page HTML."""
+        if not BEAUTIFULSOUP_AVAILABLE:
+            raise ContentExtractionError("BeautifulSoup4 non installé pour l'extraction HTML")
+        
+        async with aiohttp.ClientSession(
+            timeout=aiohttp.ClientTimeout(total=self.timeout)
+        ) as session:
+            async with session.get(url, headers=self.headers) as response:
+                if response.status != 200:
+                    raise ContentExtractionError(f"Erreur HTTP {response.status} pour {url}")
+                
+                # Vérifier la taille du contenu
+                content_length = response.headers.get('content-length')
+                if content_length and int(content_length) > self.max_content_length:
+                    raise ContentExtractionError(f"Contenu trop volumineux: {content_length} bytes")
+                
+                html_content = await response.text()
+        
+        # Parser avec BeautifulSoup
+        from bs4 import BeautifulSoup
+        soup = BeautifulSoup(html_content, 'html.parser')
+        
+        # Extraire le titre
+        title = self._extract_title(soup)
+        
+        # Extraire le contenu principal
+        content = self._extract_main_content(soup)
+        # Vérifier la longueur du contenu
+        if len(content) > self.max_content_length:
+            raise ContentExtractionError(f"Contenu extrait trop volumineux: {len(content)} caractères")
+        # Afficher le contenu
+        # self.logger.info(f"Contenu extrait ({len(content)} caractères)")
+        
+        # Extraire les métadonnées
+        author = self._extract_author(soup)
+        publish_date = self._extract_publish_date(soup)
+        
+        return Document(
+            title=title,
+            url=url,
+            content=content,
+            doc_type=DocumentType.ARTICLE,
+            author=author,
+            published_date=publish_date,
+            word_count=len(content.split()),
+            language='fr'  ############################################# Détection automatique à implémenter ###################
+        )
+    
+    def _extract_title(self, soup: "BeautifulSoup") -> str:
+        """Extrait le titre de la page."""
+        # Priorité: title tag, h1, og:title, première heading
+        
+        # Title tag
+        title_tag = soup.find('title')
+        if title_tag and title_tag.get_text().strip():
+            return title_tag.get_text().strip()
+        
+        # Meta og:title
+        og_title = soup.find('meta', {'property': 'og:title'})
+        if og_title and og_title.get('content'):
+            return og_title.get('content').strip()
+        
+        # Premier h1
+        h1 = soup.find('h1')
+        if h1 and h1.get_text().strip():
+            return h1.get_text().strip()
+        
+        # Fallback
+        return "Titre non trouvé"
+    
+    def _extract_main_content(self, soup: "BeautifulSoup") -> str:
+        """Extrait le contenu principal de la page."""
+        # Supprimer les éléments indésirables
+        for element in soup.find_all(['script', 'style', 'nav', 'header', 'footer', 'aside', 'form']):
+            element.decompose()
+        
+        # Supprimer les commentaires
+        for comment in soup.find_all(string=lambda text: isinstance(text, str) and text.strip().startswith('<!--')):
+            comment.extract()
+        
+        # Chercher le contenu principal dans l'ordre de priorité
+        content_selectors = [
+            'article',
+            '[role="main"]',
+            'main',
+            '.content',
+            '.post-content',
+            '.entry-content',
+            '.article-content',
+            '#content',
+            '.main-content'
+        ]
+        
+        main_content = None
+        for selector in content_selectors:
+            element = soup.select_one(selector)
+            if element:
+                main_content = element
+                break
+        
+        # Fallback: tout le body
+        if not main_content:
+            main_content = soup.find('body') or soup
+        
+        # Extraire le texte en gardant la structure
+        return self._clean_text(main_content.get_text())
+    
+    def _clean_text(self, text: str) -> str:
+        """Nettoie et formate le texte extrait."""
+        if not text:
+            return ""
+        
+        # Supprimer les espaces multiples et les sauts de ligne excessifs
+        text = re.sub(r'\s+', ' ', text)
+        text = re.sub(r'\n\s*\n', '\n\n', text)
+        
+        # Supprimer les espaces en début et fin
+        text = text.strip()
+        
+        # Limiter la longueur si nécessaire
+        if len(text) > 50000:  # 50k caractères max
+            text = text[:50000] + "... [Contenu tronqué]"
+        
+        return text
+    
+    def _extract_author(self, soup: "BeautifulSoup") -> Optional[str]:
+        """Extrait l'auteur de l'article."""
+        # Meta author
+        author_meta = soup.find('meta', {'name': 'author'})
+        if author_meta and author_meta.get('content'):
+            return author_meta.get('content').strip()
+        
+        # Schema.org author
+        author_schema = soup.find(attrs={'itemprop': 'author'})
+        if author_schema:
+            return author_schema.get_text().strip()
+        
+        # Recherche par classe CSS commune
+        author_selectors = [
+            '.author',
+            '.byline',
+            '.post-author',
+            '.article-author'
+        ]
+        
+        for selector in author_selectors:
+            element = soup.select_one(selector)
+            if element:
+                author_text = element.get_text().strip()
+                if author_text and len(author_text) < 100:  # Limite raisonnable
+                    return author_text
+        
+        return None
+    
+    def _extract_publish_date(self, soup: "BeautifulSoup") -> Optional[datetime]:
+        """Extrait la date de publication."""
+        # Meta published_time
+        time_meta = soup.find('meta', {'property': 'article:published_time'})
+        if time_meta and time_meta.get('content'):
+            try:
+                from dateutil.parser import parse
+                return parse(time_meta.get('content'))
+            except:
+                pass
+        
+        # Schema.org datePublished
+        date_schema = soup.find(attrs={'itemprop': 'datePublished'})
+        if date_schema:
+            date_str = date_schema.get('datetime') or date_schema.get_text()
+            try:
+                from dateutil.parser import parse
+                return parse(date_str)
+            except:
+                pass
+        
+        return None
+    
+    async def _extract_pdf_content(self, url: str) -> Document:
+        """Extrait le contenu d'un PDF."""
+        if not PDF_AVAILABLE:
+            raise ContentExtractionError("PyPDF2 non installé pour l'extraction PDF")
+        
+        # Télécharger le PDF
+        async with aiohttp.ClientSession(
+            timeout=aiohttp.ClientTimeout(total=self.timeout)
+        ) as session:
+            async with session.get(url, headers=self.headers) as response:
+                if response.status != 200:
+                    raise ContentExtractionError(f"Erreur HTTP {response.status} pour {url}")
+                
+                pdf_content = await response.read()
+        
+        # Extraire le texte du PDF
+        try:
+            import io
+            pdf_file = io.BytesIO(pdf_content)
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
+            
+            title = "Document PDF"
+            content = ""
+            
+            # Extraire le texte de toutes les pages
+            for page in pdf_reader.pages:
+                page_text = page.extract_text()
+                content += page_text + "\n"
+            
+            # Nettoyer le contenu
+            content = self._clean_text(content)
+            
+            return Document(
+                title=title,
+                url=url,
+                content=content,
+                doc_type=DocumentType.ACADEMIC_PAPER,
+                word_count=len(content.split()),
+                language='fr'  ############################################# Détection automatique à implémenter ###################
+            )
+            
+        except Exception as e:
+            raise ContentExtractionError(f"Erreur lors de l'extraction PDF: {str(e)}")
+    
+    async def _extract_generic_content(self, url: str) -> Document:
+        """Extraction générique pour les autres types de contenu."""
+        async with aiohttp.ClientSession(
+            timeout=aiohttp.ClientTimeout(total=self.timeout)
+        ) as session:
+            async with session.get(url, headers=self.headers) as response:
+                if response.status != 200:
+                    raise ContentExtractionError(f"Erreur HTTP {response.status} pour {url}")
+                
+                content = await response.text()
+        
+        # Nettoyage basique
+        content = self._clean_text(content)
+        
+        return Document(
+            title=f"Document depuis {urlparse(url).netloc}",
+            url=url,
+            content=content,
+            doc_type=DocumentType.OTHER,
+            word_count=len(content.split()),
+            language='fr'
+        )
+
+
+class ContentExtractionManager:
+    """
+    Gestionnaire d'extraction de contenu avec gestion des erreurs et retry.
+    """
+    
+    def __init__(self, max_concurrent: int = 5, max_retries: int = 2):
+        self.logger = setup_logger("extraction_manager")
+        self.extractor = WebContentExtractor()
+        self.max_concurrent = max_concurrent
+        self.max_retries = max_retries
+        self.semaphore = asyncio.Semaphore(max_concurrent)
+    
+    async def extract_multiple(self, urls: List[str]) -> List[Document]:
+        """
+        Extrait le contenu de plusieurs URLs en parallèle.
+        
+        Args:
+            urls: Liste des URLs à extraire
+            
+        Returns:
+            Liste des documents extraits (peut contenir moins d'éléments en cas d'erreur)
+        """
+        self.logger.info(f"Extraction de contenu pour {len(urls)} URLs")
+        
+        # Créer les tâches d'extraction
+        tasks = [self._extract_with_retry(url) for url in urls]
+        
+        # Exécuter en parallèle avec limite de concurrence
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Filtrer les résultats valides
+        documents = []
+        for i, result in enumerate(results):
+            if isinstance(result, Document):
+                documents.append(result)
+            elif isinstance(result, Exception):
+                self.logger.error(f"Échec d'extraction pour {urls[i]}: {str(result)}")
+            else:
+                self.logger.warning(f"Résultat inattendu pour {urls[i]}: {type(result)}")
+        
+        self.logger.info(f"Extraction terminée: {len(documents)}/{len(urls)} succès")
+        return documents
+    
+    async def _extract_with_retry(self, url: str) -> Document:
+        """Extrait le contenu d'une URL avec retry automatique."""
+        async with self.semaphore:
+            last_error = None
+            
+            for attempt in range(self.max_retries + 1):
+                try:
+                    if attempt > 0:
+                        # Attendre entre les tentatives
+                        await asyncio.sleep(2 ** attempt)
+                        self.logger.info(f"Tentative {attempt + 1}/{self.max_retries + 1} pour {url}")
+                    
+                    return await self.extractor.extract_content(url)
+                    
+                except Exception as e:
+                    last_error = e
+                    if attempt < self.max_retries:
+                        self.logger.warning(f"Tentative {attempt + 1} échouée pour {url}: {str(e)}")
+                    else:
+                        self.logger.error(f"Toutes les tentatives ont échoué pour {url}: {str(e)}")
+            
+            # Si toutes les tentatives échouent
+            raise last_error or ContentExtractionError(f"Échec d'extraction pour {url}")
+        
+
+
+
+
+##########################################################""        
+# Exemple d'utilisation (à exécuter dans un contexte asynchrone)
+async def main():
+    extractor_manager = ContentExtractionManager(max_concurrent=3, max_retries=2)
+    urls = [
+        'https://www.iana.org/help/example-domains',
+        'https://documents1.worldbank.org/curated/en/691261636143890139/pdf/Taxing-Pollution.pdf'
+    ]
+    documents = await extractor_manager.extract_multiple(urls)
+    for doc in documents:
+        print(f"Title: {doc.title}, URL: {doc.url}, Word Count: {doc.word_count}, Language: {doc.language}, Content Length: {len(doc.content)}, \nContenu tronqué: {doc.content[:500]}")
+        logger.error("⚠️   pytest n'est pas installé. Impossible de tester les erreurs de validation.")
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/services/llm_service.py

@@ -0,0 +1,488 @@
+"""
+Service LLM pour l'intégration avec Groq et autres fournisseurs.
+Gère les appels aux modèles de langage pour le résumé et l'analyse.
+"""
+
+import asyncio
+import aiohttp
+import json
+from typing import List, Dict, Any, Optional, Union
+from datetime import datetime
+import time
+
+from config.settings import api_config
+from src.core.logging import setup_logger
+import traceback
+
+
+class LLMError(Exception):
+    """Exception pour les erreurs LLM."""
+    pass
+
+
+class LLMRateLimitError(LLMError):
+    """Exception pour les erreurs de limite de taux."""
+    pass
+
+
+class LLMService:
+    """
+    Service pour les appels aux modèles de langage.
+    
+    Fonctionnalités:
+    - Support de Groq API
+    - Gestion des limites de taux
+    - Retry automatique avec backoff
+    - Streaming optionnel
+    - Validation des réponses
+    """
+    
+    def __init__(self):
+        self.config = api_config
+        self.logger = setup_logger("llm_service")
+        
+        # Configuration Groq
+        self.groq_api_key = self.config.GROQ_API_KEY
+        self.groq_base_url = "https://api.groq.com/openai/v1"
+        self.default_model = getattr(self.config, 'GROQ_MODEL', "llama-3.1-8b-instant")
+        
+        # Gestion des limites de taux
+        self.rate_limit_requests = 30  # Requêtes par minute
+        self.rate_limit_tokens = 6000  # Tokens par minute
+        self.request_timestamps = []
+        
+        # Configuration par défaut
+        self.default_params = {
+            "temperature": 0.3,
+            "max_tokens": 2000,
+            "top_p": 0.9,
+            "frequency_penalty": 0.1,
+            "presence_penalty": 0.1
+        }
+        
+        # Headers pour les requêtes
+        self.headers = {
+            "Authorization": f"Bearer {self.groq_api_key}",
+            "Content-Type": "application/json"
+        }
+    
+    async def generate_completion(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """
+        Génère une complétion de texte.
+        
+        Args:
+            prompt: Prompt utilisateur
+            system_prompt: Prompt système optionnel
+            model: Modèle à utiliser (défaut: config)
+            **kwargs: Paramètres supplémentaires pour l'API
+            
+        Returns:
+            Réponse générée par le modèle
+            
+        Raises:
+            LLMError: En cas d'erreur API
+            LLMRateLimitError: En cas de dépassement de limite
+        """
+        # Préparer les messages
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+        
+        # Paramètres de la requête
+        params = {**self.default_params, **kwargs}
+        payload = {
+            "model": model or self.default_model,
+            "messages": messages,
+            **params
+        }
+        
+        # Gestion des limites de taux
+        await self._check_rate_limits()
+        
+        # Appel API avec retry
+        return await self._make_api_call(payload)
+    
+    async def generate_batch_completions(
+        self,
+        prompts: List[str],
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        max_concurrent: int = 3,
+        **kwargs
+    ) -> List[str]:
+        """
+        Génère plusieurs complétions en parallèle.
+        
+        Args:
+            prompts: Liste des prompts
+            system_prompt: Prompt système optionnel
+            model: Modèle à utiliser
+            max_concurrent: Nombre maximum de requêtes simultanées
+            **kwargs: Paramètres supplémentaires
+            
+        Returns:
+            Liste des réponses dans le même ordre que les prompts
+        """
+        self.logger.info(f"Génération batch de {len(prompts)} complétions")
+        
+        # Créer un semaphore pour limiter la concurrence
+        semaphore = asyncio.Semaphore(max_concurrent)
+        
+        async def generate_single(prompt: str, index: int) -> tuple:
+            async with semaphore:
+                try:
+                    # Délai pour éviter le rate limiting
+                    await asyncio.sleep(index * 0.5)
+                    
+                    result = await self.generate_completion(
+                        prompt, system_prompt, model, **kwargs
+                    )
+                    return index, result
+                except Exception as e:
+                    self.logger.error(f"Erreur completion {index}: {e}")
+                    return index, f"ERREUR: {str(e)}"
+        
+        # Lancer toutes les tâches
+        tasks = [generate_single(prompt, i) for i, prompt in enumerate(prompts)]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Réorganiser les résultats dans l'ordre
+        ordered_results = [""] * len(prompts)
+        for result in results:
+            if isinstance(result, tuple):
+                index, content = result
+                ordered_results[index] = content
+            else:
+                # Exception - la placer à la fin
+                ordered_results.append(f"EXCEPTION: {str(result)}")
+        
+        success_count = sum(1 for r in ordered_results if not r.startswith("ERREUR"))
+        self.logger.info(f"Batch terminé: {success_count}/{len(prompts)} succès")
+        
+        return ordered_results
+    
+    async def _make_api_call(self, payload: Dict[str, Any], max_retries: int = 3) -> str:
+        """Effectue l'appel API avec retry automatique."""
+        url = f"{self.groq_base_url}/chat/completions"
+        
+        for attempt in range(max_retries + 1):
+            try:
+                async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=60)) as session:
+                    async with session.post(url, json=payload, headers=self.headers) as response:
+                        
+                        # Enregistrer la requête pour rate limiting
+                        self.request_timestamps.append(time.time())
+                        
+                        if response.status == 200:
+                            data = await response.json()
+                            content = data["choices"][0]["message"]["content"]
+                            
+                            # Validation de base
+                            if not content or content.strip() == "":
+                                raise LLMError("Réponse vide du modèle")
+                            
+                            return content.strip()
+                            
+                        elif response.status == 429:
+                            # Rate limit atteint
+                            retry_after = int(response.headers.get("retry-after", 60))
+                            self.logger.warning(f"Rate limit atteint, attente {retry_after}s")
+                            
+                            if attempt < max_retries:
+                                await asyncio.sleep(retry_after)
+                                continue
+                            else:
+                                raise LLMRateLimitError("Limite de taux API dépassée")
+                                
+                        else:
+                            # Autres erreurs HTTP
+                            error_text = await response.text()
+                            error_msg = f"Erreur API {response.status}: {error_text}"
+                            
+                            if attempt < max_retries:
+                                self.logger.warning(f"{error_msg} - Tentative {attempt + 1}/{max_retries}")
+                                await asyncio.sleep(2 ** attempt)  # Backoff exponentiel
+                                continue
+                            else:
+                                raise LLMError(error_msg)
+                                
+            except asyncio.TimeoutError:
+                if attempt < max_retries:
+                    self.logger.warning(f"Timeout API - Tentative {attempt + 1}/{max_retries}")
+                    await asyncio.sleep(2 ** attempt)
+                    continue
+                else:
+                    raise LLMError("Timeout API après plusieurs tentatives")
+                    
+            except Exception as e:
+                if attempt < max_retries:
+                    self.logger.warning(f"Erreur réseau: {e} - Tentative {attempt + 1}/{max_retries}")
+                    await asyncio.sleep(2 ** attempt)
+                    continue
+                else:
+                    raise LLMError(f"Erreur de connexion: {str(e)}")
+        
+        raise LLMError("Toutes les tentatives ont échoué")
+    
+    async def _check_rate_limits(self):
+        """Vérifie et applique les limites de taux."""
+        current_time = time.time()
+        
+        # Nettoyer les timestamps anciens (plus de 1 minute)
+        self.request_timestamps = [
+            ts for ts in self.request_timestamps 
+            if current_time - ts < 60
+        ]
+        
+        # Vérifier si on dépasse la limite
+        if len(self.request_timestamps) >= self.rate_limit_requests:
+            oldest_request = min(self.request_timestamps)
+            wait_time = 60 - (current_time - oldest_request)
+            
+            if wait_time > 0:
+                self.logger.info(f"Rate limit: attente {wait_time:.1f}s")
+                await asyncio.sleep(wait_time)
+    
+    def estimate_tokens(self, text: str) -> int:
+        """Estime le nombre de tokens dans un texte."""
+        # Approximation: 1 token ≈ 4 caractères pour l'anglais/français
+        return len(text) // 4
+    
+    def validate_input_length(self, text: str, max_tokens: int = 6000) -> bool:
+        """Valide que le texte ne dépasse pas la limite de tokens."""
+        estimated_tokens = self.estimate_tokens(text)
+        return estimated_tokens <= max_tokens
+    
+    def truncate_text(self, text: str, max_tokens: int = 6000) -> str:
+        """Tronque un texte pour respecter la limite de tokens."""
+        estimated_tokens = self.estimate_tokens(text)
+        
+        if estimated_tokens <= max_tokens:
+            return text
+        
+        # Calculer le ratio de troncature
+        ratio = max_tokens / estimated_tokens
+        target_length = int(len(text) * ratio * 0.9)  # Marge de sécurité
+        
+        # Tronquer en préservant les phrases
+        sentences = text.split('. ')
+        truncated = ""
+        
+        for sentence in sentences:
+            if len(truncated) + len(sentence) + 2 <= target_length:
+                truncated += sentence + ". "
+            else:
+                break
+        
+        self.logger.info(f"Texte tronqué: {len(text)} → {len(truncated)} caractères")
+        return truncated.strip()
+    
+    async def test_connection(self) -> bool:
+        """Teste la connexion à l'API."""
+        try:
+            result = await self.generate_completion(
+                "Test de connexion. Réponds juste 'OK'.",
+                system_prompt="Tu es un assistant de test."
+            )
+            
+            if "ok" in result.lower():
+                self.logger.info("Test de connexion LLM réussi")
+                return True
+            else:
+                self.logger.warning(f"Test de connexion étrange: {result}")
+                return False
+                
+        except Exception as e:
+            self.logger.error(f"Test de connexion LLM échoué: {e}")
+            return False
+
+
+class LLMManager:
+    """
+    Gestionnaire de services LLM avec stratégies multiples.
+    """
+    
+    def __init__(self):
+        self.logger = setup_logger("llm_manager")
+        self.primary_service = LLMService()
+        self.services = {
+            "groq": self.primary_service
+        }
+    
+    async def get_completion(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        service: str = "groq",
+        **kwargs
+    ) -> str:
+        """
+        Obtient une complétion en utilisant le service spécifié.
+        
+        Args:
+            prompt: Prompt utilisateur
+            system_prompt: Prompt système
+            service: Service LLM à utiliser
+            **kwargs: Paramètres supplémentaires
+            
+        Returns:
+            Réponse du modèle
+        """
+        if service not in self.services:
+            raise ValueError(f"Service LLM inconnu: {service}")
+        
+        llm_service = self.services[service]
+        return await llm_service.generate_completion(prompt, system_prompt, **kwargs)
+    
+    async def get_batch_completions(
+        self,
+        prompts: List[str],
+        system_prompt: Optional[str] = None,
+        service: str = "groq",
+        **kwargs
+    ) -> List[str]:
+        """Obtient des complétions en batch."""
+        if service not in self.services:
+            raise ValueError(f"Service LLM inconnu: {service}")
+        
+        llm_service = self.services[service]
+        return await llm_service.generate_batch_completions(
+            prompts, system_prompt, **kwargs
+        )
+    
+    async def test_all_services(self) -> Dict[str, bool]:
+        """Teste tous les services LLM disponibles."""
+        results = {}
+        
+        for name, service in self.services.items():
+            try:
+                results[name] = await service.test_connection()
+            except Exception as e:
+                self.logger.error(f"Test service {name} échoué: {e}")
+                results[name] = False
+        
+        return results
+    
+# Exemple d'utilisation du service LLM
+
+async def example_usage():
+    """Exemple d'utilisation du service LLM."""
+    
+    # 1. Test de connexion simple
+    print("=== Test de connexion ===")
+    llm_service = LLMService()
+    
+    connection_ok = await llm_service.test_connection()
+    print(f"Connexion LLM: {'✓ OK' if connection_ok else '✗ Échec'}")
+    
+    if not connection_ok:
+        print("Impossible de continuer sans connexion")
+        return
+    
+    # 2. Génération simple
+    print("\n=== Génération simple ===")
+    try:
+        response = await llm_service.generate_completion(
+            prompt="Explique-moi en 2 phrases ce qu'est l'intelligence artificielle.",
+            system_prompt="Tu es un expert en IA qui explique simplement."
+        )
+        print(f"Réponse: {response}")
+    except Exception as e:
+        print(f"Erreur: {e}")
+    
+    # 3. Génération avec paramètres personnalisés
+    print("\n=== Génération avec paramètres ===")
+    try:
+        response = await llm_service.generate_completion(
+            prompt="Écris un haiku sur la technologie.",
+            system_prompt="Tu es un poète spécialisé dans les haikus.",
+            temperature=0.8,
+            max_tokens=100
+        )
+        print(f"Haiku: {response}")
+    except Exception as e:
+        print(f"Erreur: {e}")
+    
+    # 4. Génération en batch
+    print("\n=== Génération en batch ===")
+    prompts = [
+        "Qu'est-ce que Python?",
+        "Qu'est-ce que JavaScript?",
+        "Qu'est-ce que Rust?"
+    ]
+    
+    try:
+        responses = await llm_service.generate_batch_completions(
+            prompts=prompts,
+            system_prompt="Réponds en une phrase courte.",
+            max_concurrent=2
+        )
+        
+        for i, (prompt, response) in enumerate(zip(prompts, responses)):
+            print(f"{i+1}. {prompt}")
+            print(f"   → {response}\n")
+    except Exception as e:
+        print(f"Erreur batch: {e}")
+    
+    # 5. Test des utilitaires
+    print("\n=== Test des utilitaires ===")
+    long_text = "Ceci est un texte très long. " * 1000
+    print(f"Texte original: {len(long_text)} caractères")
+    print(f"Tokens estimés: {llm_service.estimate_tokens(long_text)}")
+
+    is_valid = llm_service.validate_input_length(long_text, max_tokens=7000)
+    print(f"Texte valide (7000 tokens max): {is_valid}")
+    
+    if not is_valid:
+        truncated = llm_service.truncate_text(long_text, max_tokens=7000)
+        print(f"Texte tronqué: {len(truncated)} caractères")
+        print(f"Contenu: {truncated[:200]}...")
+
+# Test avec le gestionnaire LLM
+async def example_manager_usage():
+    """Exemple d'utilisation du gestionnaire LLM."""
+    
+    print("\n=== Test du gestionnaire LLM ===")
+    
+    manager = LLMManager()
+    
+    # Test de tous les services
+    service_status = await manager.test_all_services()
+    print("État des services:")
+    for service, status in service_status.items():
+        print(f"  {service}: {'✓' if status else '✗'}")
+    
+    # Utilisation via le gestionnaire
+    try:
+        response = await manager.get_completion(
+            prompt="Salut! Comment ça va?",
+            system_prompt="Tu es un assistant amical.",
+            service="groq"
+        )
+        print(f"\nRéponse du gestionnaire: {response}")
+    except Exception as e:
+        print(f"Erreur gestionnaire: {e}")
+
+# Fonction principale pour tester
+async def main():
+    """Fonction principale de test."""
+    try:
+        await example_usage()
+        await example_manager_usage()
+    except KeyboardInterrupt:
+        print("\n\nTest interrompu par l'utilisateur")
+    except Exception as e:
+        print(f"\nErreur inattendue: {e}")
+        traceback.print_exc()
+
+# Pour exécuter le test
+if __name__ == "__main__":
+    print("🚀 Démarrage du test du service LLM...")
+    asyncio.run(main())

src/services/search_api.py

@@ -0,0 +1,347 @@
+"""
+Services d'API pour la recherche web.
+Intègre les APIs Tavily et Serper pour la recherche d'informations.
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+import requests
+import asyncio
+import aiohttp
+from datetime import datetime
+import json
+
+from src.core.logging import setup_logger
+from src.models.research_models import SearchResult
+
+# Import sécurisé de la configuration
+try:
+    from config.settings import api_config
+except Exception as e:
+    print(f"Erreur lors de l'import de la configuration: {e}")
+    api_config = None
+
+
+class SearchAPIError(Exception):
+    """Exception pour les erreurs d'API de recherche."""
+    pass
+
+
+class BaseSearchAPI(ABC):
+    """Interface de base pour les APIs de recherche."""
+    
+    @abstractmethod
+    async def search(
+        self, 
+        query: str, 
+        max_results: int = 5,
+        **kwargs
+    ) -> List[SearchResult]:
+        """
+        Effectue une recherche.
+        
+        Args:
+            query: Requête de recherche
+            max_results: Nombre maximum de résultats
+            **kwargs: Paramètres spécifiques à l'API
+            
+        Returns:
+            Liste des résultats de recherche
+        """
+        pass
+
+
+class TavilySearchAPI(BaseSearchAPI):
+    """
+    Client pour l'API Tavily.
+    Documentation: https://docs.tavily.com/
+    """
+    
+    def __init__(self, api_key: Optional[str] = None):
+        # Accès sécurisé à la configuration
+        if api_config:
+            self.api_key = api_key or getattr(api_config, 'TAVILY_API_KEY', '')
+        else:
+            self.api_key = api_key or ''
+        self.base_url = "https://api.tavily.com"
+        self.logger = setup_logger("tavily_api")
+        
+        if not self.api_key:
+            raise SearchAPIError("Clé API Tavily manquante")
+    
+    async def search(
+        self, 
+        query: str, 
+        max_results: int = 5,
+        search_depth: str = "basic",
+        include_images: bool = False,
+        include_answer: bool = True,
+        **kwargs
+    ) -> List[SearchResult]:
+        """
+        Recherche avec l'API Tavily.
+        
+        Args:
+            query: Requête de recherche
+            max_results: Nombre de résultats (max 20)
+            search_depth: "basic" ou "advanced"
+            include_images: Inclure les images
+            include_answer: Inclure une réponse IA
+            
+        Returns:
+            Liste des résultats
+        """
+        self.logger.info(f"Recherche Tavily: '{query}' (max: {max_results})")
+        
+        payload = {
+            "api_key": self.api_key,
+            "query": query,
+            "search_depth": search_depth,
+            "max_results": min(max_results, 20),
+            "include_images": include_images,
+            "include_answer": include_answer,
+            "include_raw_content": False
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.post(
+                    f"{self.base_url}/search",
+                    json=payload,
+                    timeout=30
+                ) as response:
+                    
+                    if response.status != 200:
+                        error_text = await response.text()
+                        raise SearchAPIError(f"Erreur Tavily {response.status}: {error_text}")
+                    
+                    data = await response.json()
+                    return self._parse_tavily_results(data)
+                    
+            except aiohttp.ClientTimeout:
+                raise SearchAPIError("Timeout lors de la requête Tavily")
+            except aiohttp.ClientError as e:
+                raise SearchAPIError(f"Erreur de connexion Tavily: {str(e)}")
+    
+    def _parse_tavily_results(self, data: Dict[str, Any]) -> List[SearchResult]:
+        """Parse les résultats de l'API Tavily."""
+        results = []
+        
+        for item in data.get("results", []):
+            try:
+                # Parsing de la date de publication si disponible
+                published_date = None
+                if "published_date" in item and item["published_date"]:
+                    try:
+                        published_date = datetime.fromisoformat(item["published_date"].replace('Z', '+00:00'))
+                    except:
+                        pass
+                
+                result = SearchResult(
+                    title=item.get("title", ""),
+                    url=item.get("url", ""),
+                    snippet=item.get("content", ""),
+                    published_date=published_date,
+                    source=item.get("source", ""),
+                    score=item.get("score", 0.0)
+                )
+                results.append(result)
+                
+            except Exception as e:
+                self.logger.warning(f"Erreur parsing résultat Tavily: {e}")
+                continue
+        
+        self.logger.info(f"Tavily: {len(results)} résultats parsés")
+        return results
+
+
+class SerperSearchAPI(BaseSearchAPI):
+    """
+    Client pour l'API Serper (Google Search).
+    Documentation: https://serper.dev/
+    """
+    
+    def __init__(self, api_key: Optional[str] = None):
+        # Accès sécurisé à la configuration  
+        if api_config:
+            self.api_key = api_key or getattr(api_config, 'SERPER_API_KEY', '')
+        else:
+            self.api_key = api_key or ''
+        self.base_url = "https://google.serper.dev"
+        self.logger = setup_logger("serper_api")
+        
+        if not self.api_key:
+            raise SearchAPIError("Clé API Serper manquante")
+    
+    async def search(
+        self, 
+        query: str, 
+        max_results: int = 5,
+        country: str = "fr",
+        language: str = "fr",
+        search_type: str = "search",
+        **kwargs
+    ) -> List[SearchResult]:
+        """
+        Recherche avec l'API Serper.
+        
+        Args:
+            query: Requête de recherche
+            max_results: Nombre de résultats (max 100)
+            country: Code pays (ex: "fr", "us")
+            language: Code langue (ex: "fr", "en")
+            search_type: Type de recherche ("search", "news", "images")
+            
+        Returns:
+            Liste des résultats
+        """
+        self.logger.info(f"Recherche Serper: '{query}' (max: {max_results})")
+        
+        payload = {
+            "q": query,
+            "num": min(max_results, 100),
+            "gl": country,
+            "hl": language
+        }
+        
+        headers = {
+            "X-API-KEY": self.api_key,
+            "Content-Type": "application/json"
+        }
+        
+        endpoint = f"{self.base_url}/{search_type}"
+        
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.post(
+                    endpoint,
+                    json=payload,
+                    headers=headers,
+                    timeout=30
+                ) as response:
+                    
+                    if response.status != 200:
+                        error_text = await response.text()
+                        raise SearchAPIError(f"Erreur Serper {response.status}: {error_text}")
+                    
+                    data = await response.json()
+                    return self._parse_serper_results(data, search_type)
+                    
+            except aiohttp.ClientTimeout:
+                raise SearchAPIError("Timeout lors de la requête Serper")
+            except aiohttp.ClientError as e:
+                raise SearchAPIError(f"Erreur de connexion Serper: {str(e)}")
+    
+    def _parse_serper_results(self, data: Dict[str, Any], search_type: str) -> List[SearchResult]:
+        """Parse les résultats de l'API Serper."""
+        results = []
+        
+        # Les résultats sont dans différentes clés selon le type de recherche
+        items_key = "organic" if search_type == "search" else "news" if search_type == "news" else "images"
+        items = data.get(items_key, [])
+        
+        for item in items:
+            try:
+                # Parsing de la date pour les news
+                published_date = None
+                if "date" in item:
+                    try:
+                        published_date = datetime.fromisoformat(item["date"])
+                    except:
+                        pass
+                
+                result = SearchResult(
+                    title=item.get("title", ""),
+                    url=item.get("link", ""),
+                    snippet=item.get("snippet", ""),
+                    published_date=published_date,
+                    source=item.get("source", ""),
+                    score=item.get("position", 0) / 100.0  # Position convertie en score
+                )
+                results.append(result)
+                
+            except Exception as e:
+                self.logger.warning(f"Erreur parsing résultat Serper: {e}")
+                continue
+        
+        self.logger.info(f"Serper: {len(results)} résultats parsés")
+        return results
+
+
+class SearchAPIManager:
+    """
+    Gestionnaire des APIs de recherche.
+    Permet de basculer entre les APIs et de gérer les fallbacks.
+    """
+    
+    def __init__(self):
+        self.apis = {}
+        self.logger = setup_logger("search_manager")
+        
+        # Initialisation des APIs disponibles
+        try:
+            if api_config and getattr(api_config, 'TAVILY_API_KEY', ''):
+                self.apis["tavily"] = TavilySearchAPI()
+                self.logger.info("API Tavily initialisée")
+        except Exception as e:
+            self.logger.warning(f"Impossible d'initialiser Tavily: {e}")
+        
+        try:
+            if api_config and getattr(api_config, 'SERPER_API_KEY', ''):
+                self.apis["serper"] = SerperSearchAPI()
+                self.logger.info("API Serper initialisée")
+        except Exception as e:
+            self.logger.warning(f"Impossible d'initialiser Serper: {e}")
+        
+        if not self.apis:
+            raise SearchAPIError("Aucune API de recherche disponible")
+    
+    async def search(
+        self, 
+        query: str, 
+        max_results: int = 5,
+        preferred_api: str = "tavily",
+        **kwargs
+    ) -> List[SearchResult]:
+        """
+        Effectue une recherche avec fallback entre APIs.
+        
+        Args:
+            query: Requête de recherche
+            max_results: Nombre de résultats
+            preferred_api: API préférée ("tavily" ou "serper")
+            
+        Returns:
+            Liste des résultats
+        """
+        # Ordre de priorité des APIs
+        api_order = [preferred_api] + [api for api in self.apis.keys() if api != preferred_api]
+        
+        for api_name in api_order:
+            if api_name not in self.apis:
+                continue
+                
+            try:
+                self.logger.info(f"Tentative de recherche avec {api_name}")
+                results = await self.apis[api_name].search(query, max_results, **kwargs)
+                
+                if results:
+                    self.logger.info(f"Recherche réussie avec {api_name}: {len(results)} résultats")
+                    return results
+                else:
+                    self.logger.warning(f"Aucun résultat avec {api_name}")
+                    
+            except Exception as e:
+                self.logger.warning(f"Erreur avec {api_name}: {e}")
+                continue
+        
+        # Aucune API n'a fonctionné
+        raise SearchAPIError(f"Échec de recherche avec toutes les APIs pour: {query}")
+    
+    def get_available_apis(self) -> List[str]:
+        """Retourne la liste des APIs disponibles."""
+        return list(self.apis.keys())
+    
+    def is_api_available(self, api_name: str) -> bool:
+        """Vérifie si une API est disponible."""
+        return api_name in self.apis

src/services/text_chunking.py

@@ -0,0 +1,404 @@
+"""
+Service de chunking pour la gestion des textes longs.
+Divise intelligemment les documents en chunks pour le traitement par LLM.
+"""
+
+import re
+from typing import List, Dict, Tuple, Optional
+from dataclasses import dataclass
+
+from src.core.logging import setup_logger
+
+
+@dataclass
+class TextChunk:
+    """Représente un chunk de texte avec métadonnées."""
+    content: str
+    start_index: int
+    end_index: int
+    chunk_id: int
+    total_chunks: int
+    word_count: int
+    has_heading: bool = False
+    heading_text: Optional[str] = None
+
+
+class TextChunker:
+    """
+    Service de découpage intelligent de texte pour le traitement par LLM.
+    
+    Fonctionnalités:
+    - Découpage respectant les phrases et paragraphes
+    - Préservation des titres et structure
+    - Gestion du chevauchement entre chunks
+    - Optimisation pour les limites de tokens LLM
+    """
+    
+    def __init__(
+        self,
+        max_chunk_size: int = 4000,  # En caractères
+        overlap_size: int = 200,     # Chevauchement entre chunks
+        min_chunk_size: int = 500    # Taille minimale d'un chunk
+    ):
+        self.max_chunk_size = max_chunk_size
+        self.overlap_size = overlap_size
+        self.min_chunk_size = min_chunk_size
+        self.logger = setup_logger("text_chunker")
+        
+        # Patterns pour identifier la structure
+        self.heading_patterns = [
+            r'^#{1,6}\s+.+$',           # Markdown headings
+            r'^\d+\.\s+.+$',            # Numérotations
+            r'^[A-Z\s]{5,}$',           # Titres en majuscules
+            r'^\w+:$',                  # Labels avec deux-points
+        ]
+        
+        self.sentence_endings = r'[.!?]+(?:\s|$)'
+        self.paragraph_breaks = r'\n\s*\n'
+    
+    def chunk_text(self, text: str, preserve_structure: bool = True) -> List[TextChunk]:
+        """
+        Découpe un texte en chunks intelligents.
+        
+        Args:
+            text: Texte à découper
+            preserve_structure: Préserver la structure (titres, paragraphes)
+            
+        Returns:
+            Liste des chunks créés
+        """
+        if not text or len(text.strip()) == 0:
+            return []
+        
+        # Nettoyage préliminaire
+        text = self._clean_text(text)
+        
+        # Si le texte est assez court, retourner un seul chunk
+        if len(text) <= self.max_chunk_size:
+            return [TextChunk(
+                content=text,
+                start_index=0,
+                end_index=len(text),
+                chunk_id=1,
+                total_chunks=1,
+                word_count=len(text.split())
+            )]
+        
+        # Découpage intelligent
+        if preserve_structure:
+            chunks = self._chunk_with_structure(text)
+        else:
+            chunks = self._chunk_simple(text)
+        
+        # Post-traitement des chunks
+        chunks = self._post_process_chunks(chunks)
+        
+        self.logger.info(f"Texte découpé en {len(chunks)} chunks (taille moyenne: {sum(len(c.content) for c in chunks) // len(chunks)} caractères)")
+        
+        return chunks
+    
+    def _clean_text(self, text: str) -> str:
+        """Nettoie le texte avant découpage."""
+        # Normaliser les espaces
+        text = re.sub(r'\s+', ' ', text)
+        
+        # Normaliser les sauts de ligne
+        text = re.sub(r'\n\s*\n\s*\n+', '\n\n', text)
+        
+        # Supprimer les espaces en début et fin
+        text = text.strip()
+        
+        return text
+    
+    def _chunk_with_structure(self, text: str) -> List[TextChunk]:
+        """Découpage en préservant la structure du document."""
+        chunks = []
+        current_chunk = ""
+        current_start = 0
+        
+        # Diviser en paragraphes
+        paragraphs = re.split(self.paragraph_breaks, text)
+        text_position = 0
+        
+        for paragraph in paragraphs:
+            if not paragraph.strip():
+                continue
+            
+            # Vérifier si le paragraphe contient un titre
+            is_heading, heading_text = self._detect_heading(paragraph)
+            
+            # Si ajouter ce paragraphe dépasse la limite
+            if len(current_chunk) + len(paragraph) > self.max_chunk_size and current_chunk:
+                # Sauvegarder le chunk actuel
+                chunk = self._create_chunk(
+                    current_chunk.strip(),
+                    current_start,
+                    text_position,
+                    len(chunks) + 1
+                )
+                chunks.append(chunk)
+                
+                # Commencer un nouveau chunk avec chevauchement
+                overlap_text = self._get_overlap_text(current_chunk)
+                current_chunk = overlap_text + paragraph
+                current_start = text_position - len(overlap_text)
+            else:
+                # Ajouter le paragraphe au chunk actuel
+                if current_chunk:
+                    current_chunk += "\n\n" + paragraph
+                else:
+                    current_chunk = paragraph
+                    current_start = text_position
+            
+            text_position += len(paragraph) + 2  # +2 pour \n\n
+        
+        # Ajouter le dernier chunk
+        if current_chunk.strip():
+            chunk = self._create_chunk(
+                current_chunk.strip(),
+                current_start,
+                len(text),
+                len(chunks) + 1
+            )
+            chunks.append(chunk)
+        
+        return chunks
+    
+    def _chunk_simple(self, text: str) -> List[TextChunk]:
+        """Découpage simple par phrases."""
+        chunks = []
+        sentences = re.split(self.sentence_endings, text)
+        
+        current_chunk = ""
+        current_start = 0
+        text_position = 0
+        
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if not sentence:
+                continue
+            
+            # Estimer la position dans le texte original
+            sentence_in_text = sentence + "."  # Approximation
+            
+            if len(current_chunk) + len(sentence_in_text) > self.max_chunk_size and current_chunk:
+                # Sauvegarder le chunk actuel
+                chunk = self._create_chunk(
+                    current_chunk.strip(),
+                    current_start,
+                    text_position,
+                    len(chunks) + 1
+                )
+                chunks.append(chunk)
+                
+                # Nouveau chunk avec chevauchement
+                overlap_text = self._get_overlap_text(current_chunk)
+                current_chunk = overlap_text + sentence_in_text
+                current_start = text_position - len(overlap_text)
+            else:
+                if current_chunk:
+                    current_chunk += " " + sentence_in_text
+                else:
+                    current_chunk = sentence_in_text
+                    current_start = text_position
+            
+            text_position += len(sentence_in_text)
+        
+        # Dernier chunk
+        if current_chunk.strip():
+            chunk = self._create_chunk(
+                current_chunk.strip(),
+                current_start,
+                len(text),
+                len(chunks) + 1
+            )
+            chunks.append(chunk)
+        
+        return chunks
+    
+    def _detect_heading(self, paragraph: str) -> Tuple[bool, Optional[str]]:
+        """Détecte si un paragraphe est un titre."""
+        lines = paragraph.strip().split('\n')
+        first_line = lines[0].strip()
+        
+        for pattern in self.heading_patterns:
+            if re.match(pattern, first_line, re.MULTILINE):
+                return True, first_line
+        
+        # Détection heuristique
+        if (len(first_line) < 100 and 
+            len(first_line.split()) < 10 and
+            first_line[0].isupper()):
+            return True, first_line
+        
+        return False, None
+    
+    def _get_overlap_text(self, chunk: str) -> str:
+        """Extrait le texte de chevauchement à la fin d'un chunk."""
+        if len(chunk) <= self.overlap_size:
+            return ""
+        
+        # Prendre les dernières phrases jusqu'à overlap_size
+        sentences = re.split(self.sentence_endings, chunk[-self.overlap_size:])
+        
+        if len(sentences) > 1:
+            # Garder les phrases complètes
+            return ". ".join(sentences[1:]) + ". "
+        else:
+            # Fallback: prendre les derniers mots
+            words = chunk.split()
+            overlap_words = []
+            char_count = 0
+            
+            for word in reversed(words):
+                if char_count + len(word) > self.overlap_size:
+                    break
+                overlap_words.insert(0, word)
+                char_count += len(word) + 1
+            
+            return " ".join(overlap_words) + " " if overlap_words else ""
+    
+    def _create_chunk(self, content: str, start: int, end: int, chunk_id: int) -> TextChunk:
+        """Crée un objet TextChunk avec métadonnées."""
+        is_heading, heading_text = self._detect_heading(content)
+        
+        return TextChunk(
+            content=content,
+            start_index=start,
+            end_index=end,
+            chunk_id=chunk_id,
+            total_chunks=0,  # Sera mis à jour dans post_process
+            word_count=len(content.split()),
+            has_heading=is_heading,
+            heading_text=heading_text
+        )
+    
+    def _post_process_chunks(self, chunks: List[TextChunk]) -> List[TextChunk]:
+        """Post-traitement des chunks."""
+        total_chunks = len(chunks)
+        
+        # Mettre à jour le nombre total de chunks
+        for chunk in chunks:
+            chunk.total_chunks = total_chunks
+        
+        # Fusionner les chunks trop petits
+        merged_chunks = []
+        i = 0
+        
+        while i < len(chunks):
+            current_chunk = chunks[i]
+            
+            # Si le chunk est trop petit et qu'il y a un chunk suivant
+            if (len(current_chunk.content) < self.min_chunk_size and 
+                i + 1 < len(chunks) and
+                len(current_chunk.content) + len(chunks[i + 1].content) <= self.max_chunk_size):
+                
+                # Fusionner avec le chunk suivant
+                next_chunk = chunks[i + 1]
+                merged_content = current_chunk.content + "\n\n" + next_chunk.content
+                
+                merged_chunk = TextChunk(
+                    content=merged_content,
+                    start_index=current_chunk.start_index,
+                    end_index=next_chunk.end_index,
+                    chunk_id=len(merged_chunks) + 1,
+                    total_chunks=0,  # Sera mis à jour à la fin
+                    word_count=len(merged_content.split()),
+                    has_heading=current_chunk.has_heading or next_chunk.has_heading,
+                    heading_text=current_chunk.heading_text or next_chunk.heading_text
+                )
+                
+                merged_chunks.append(merged_chunk)
+                i += 2  # Passer les deux chunks fusionnés
+            else:
+                # Garder le chunk tel quel
+                current_chunk.chunk_id = len(merged_chunks) + 1
+                merged_chunks.append(current_chunk)
+                i += 1
+        
+        # Mettre à jour le nombre total final
+        for chunk in merged_chunks:
+            chunk.total_chunks = len(merged_chunks)
+        
+        return merged_chunks
+    
+    def get_chunking_stats(self, chunks: List[TextChunk]) -> Dict[str, any]:
+        """Calcule les statistiques de découpage."""
+        if not chunks:
+            return {}
+        
+        chunk_sizes = [len(chunk.content) for chunk in chunks]
+        word_counts = [chunk.word_count for chunk in chunks]
+        
+        return {
+            "total_chunks": len(chunks),
+            "total_characters": sum(chunk_sizes),
+            "total_words": sum(word_counts),
+            "average_chunk_size": sum(chunk_sizes) // len(chunks),
+            "average_words_per_chunk": sum(word_counts) // len(chunks),
+            "min_chunk_size": min(chunk_sizes),
+            "max_chunk_size": max(chunk_sizes),
+            "chunks_with_headings": sum(1 for chunk in chunks if chunk.has_heading)
+        }
+
+
+class ChunkingManager:
+    """
+    Gestionnaire de chunking avec différentes stratégies.
+    """
+    
+    def __init__(self):
+        self.logger = setup_logger("chunking_manager")
+        
+        # Chunkers spécialisés
+        self.chunkers = {
+            "default": TextChunker(max_chunk_size=4000, overlap_size=200),
+            "small": TextChunker(max_chunk_size=2000, overlap_size=100),
+            "large": TextChunker(max_chunk_size=20000, overlap_size=300),
+            "precise": TextChunker(max_chunk_size=3000, overlap_size=150, min_chunk_size=800)
+        }
+    
+    def chunk_document(
+        self, 
+        content: str, 
+        strategy: str = "default", 
+        preserve_structure: bool = True
+    ) -> List[TextChunk]:
+        """
+        Découpe un document selon la stratégie spécifiée.
+        
+        Args:
+            content: Contenu à découper
+            strategy: Stratégie de découpage (default, small, large, precise)
+            preserve_structure: Préserver la structure du document
+            
+        Returns:
+            Liste des chunks créés
+        """
+        if strategy not in self.chunkers:
+            self.logger.warning(f"Stratégie inconnue '{strategy}', utilisation de 'default'")
+            strategy = "default"
+        
+        chunker = self.chunkers[strategy]
+        chunks = chunker.chunk_text(content, preserve_structure)
+        
+        # Statistiques
+        stats = chunker.get_chunking_stats(chunks)
+        self.logger.info(f"Chunking '{strategy}': {stats['total_chunks']} chunks créés")
+        
+        return chunks
+    
+    def auto_select_strategy(self, content: str) -> str:
+        """Sélectionne automatiquement la meilleure stratégie de chunking."""
+        content_length = len(content)
+        word_count = len(content.split())
+        
+        # Heuristiques pour sélectionner la stratégie
+        if content_length < 5000:
+            return "small"
+        elif content_length > 20000:
+            return "large"
+        elif word_count > 3000:  # Texte dense
+            return "precise"
+        else:
+            return "default"