Upload 4 files

Dockerfile

@@ -0,0 +1,18 @@
+# Utilise une image Python officielle comme base
+FROM python:3.11-slim-buster
+
+# Définit le répertoire de travail dans le conteneur
+WORKDIR /app
+
+# Copie le fichier requirements.txt et installe les dépendances
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copie le reste de l'application
+COPY . .
+
+# Expose le port 7860
+EXPOSE 7860
+
+# Commande pour lancer l'application Chainlit
+CMD ["chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

agent_collaboratif_avid.py

@@ -0,0 +1,1084 @@
+"""
+Agent Collaboratif LangGraph pour l'Université Gustave Eiffel
+===============================================================
+
+Ce script implémente un agent collaboratif multi-base utilisant LangGraph pour orchestrer
+des recherches dans 4 bases vectorielles Pinecone liées aux thématiques de Ville Durable.
+
+Architecture:
+- Workflow LangGraph avec nodes spécialisés
+- Retrievers Langchain-Pinecone avec similarity search + score
+- Filtrage par catégorie pour chaque base
+- Validation anti-hallucination en boucle
+- Orchestration intelligente des recherches
+
+Prérequis:
+- pip install langgraph langchain langchain-pinecone langchain-openai pinecone
+- Variables d'environnement: PINECONE_API_KEY, OPENAI_API_KEY
+"""
+
+import os
+import json
+from typing import TypedDict, Annotated, List, Dict, Any, Sequence
+from operator import add
+
+from langchain_openai import ChatOpenAI
+from langchain_pinecone import PineconeVectorStore
+from langchain_core.embeddings import Embeddings
+from langchain_core.documents import Document
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import JsonOutputParser
+
+from langgraph.graph import StateGraph, END
+from langgraph.prebuilt import ToolNode
+#from langgraph.checkpoint.memory import MemorySaver
+
+from pinecone import Pinecone
+import asyncio
+
+# =============================================================================
+# CONFIGURATION GLOBALE
+# =============================================================================
+
+# Configuration API
+PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
+#OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+#OPENAI_BASE_URL = os.environ.get("OPENAI_BASE_URL")
+#OPENAI_MODEL_NAME = os.environ.get("OPENAI_MODEL_NAME")
+
+OPENAI_API_KEY="sk-b8b00f8614a2496aa013103aaa53e753"
+OPENAI_MODEL_NAME="mistralai/Mistral-Small-3.1-24B-Instruct-2503"
+OPENAI_BASE_URL="https://ragarenn.eskemm-numerique.fr/sso/ch@t/api"
+
+HUGGINGFACE_MODEL = os.environ.get("HUGGINGFACE_MODEL", "sentence-transformers/all-mpnet-base-v2")
+PINECONE_INDEX_NAME = "all-jdlp"
+
+# Configuration modèle
+MAX_VALIDATION_LOOPS = 1
+SIMILARITY_TOP_K = 10
+SIMILARITY_SCORE_THRESHOLD = 0.5
+
+# Validation des variables d'environnement
+if not PINECONE_API_KEY:
+    raise ValueError("❌ PINECONE_API_KEY non définie. Exécutez: export PINECONE_API_KEY='votre-clé'")
+if not OPENAI_API_KEY:
+    raise ValueError("❌ OPENAI_API_KEY non définie. Exécutez: export OPENAI_API_KEY='votre-clé'")
+
+# =============================================================================
+# EMBEDDINGS HUGGINGFACE
+# =============================================================================
+
+class HuggingFaceEmbeddings(Embeddings):
+    """
+    Classe d'embeddings utilisant HuggingFace Transformers.
+    """
+    
+    def __init__(self, model_name: str = HUGGINGFACE_MODEL):
+        """
+        Initialise les embeddings HuggingFace.
+        
+        Args:
+            model_name: Nom du modèle HuggingFace à utiliser
+        """
+        from sentence_transformers import SentenceTransformer
+        
+        self.model_name = model_name
+        print(f"🤗 Chargement du modèle HuggingFace: {model_name}")
+        self.model = SentenceTransformer(model_name)
+        self.dimension = self.model.get_sentence_embedding_dimension()
+        print(f"✅ Modèle chargé (dimension: {self.dimension})")
+    
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """
+        Génère des embeddings pour une liste de documents.
+        
+        Args:
+            texts: Liste de textes à vectoriser
+            
+        Returns:
+            Liste de vecteurs d'embeddings
+        """
+        embeddings = self.model.encode(texts, convert_to_numpy=True)
+        return embeddings.tolist()
+    
+    def embed_query(self, text: str) -> List[float]:
+        """
+        Génère un embedding pour une requête unique.
+        
+        Args:
+            text: Texte de la requête
+            
+        Returns:
+            Vecteur d'embedding
+        """
+        embedding = self.model.encode(text, convert_to_numpy=True)
+        return embedding.tolist()
+
+# =============================================================================
+# DÉFINITION DE L'ÉTAT DU GRAPHE
+# =============================================================================
+
+class AgentState(TypedDict):
+    """État global du workflow LangGraph."""
+    messages: Annotated[Sequence[BaseMessage], add]
+    user_query: str
+    query_analysis: Dict[str, Any]
+    collected_information: List[Dict[str, Any]]
+    validation_results: List[Dict[str, Any]]
+    final_response: str
+    iteration_count: int
+    errors: List[str]
+    additional_information: List[Dict[str, Any]]  # Nouvelles infos similaires
+
+# =============================================================================
+# INITIALISATION DES RETRIEVERS PINECONE
+# =============================================================================
+
+class PineconeRetrieverManager:
+    """Gestionnaire centralisé des retrievers Pinecone."""
+    
+    def __init__(self):
+        """Initialise le gestionnaire et crée les 4 retrievers spécialisés."""
+        print("🔧 Initialisation du gestionnaire Pinecone...")
+        
+        self.pc = Pinecone(api_key=PINECONE_API_KEY)
+        self.index = self.pc.Index(PINECONE_INDEX_NAME)
+        
+        # Utilisation de HuggingFace Embeddings
+        self.embeddings = HuggingFaceEmbeddings()
+        
+        self.retrievers = {
+            "laboratoires": self._create_retriever(
+                category="FICHELABOTHEMATIQUEAVID",
+                description="Laboratoires et thématiques Ville Durable"
+            ),
+            "formations": self._create_retriever(
+                category="FORMATIONTHEMATIQUEAVID",
+                description="Formations liées à la Ville Durable"
+            ),
+            "recherche": self._create_retriever(
+                category="RECHERCHETHEMATIQUEAVID",
+                description="Axes de recherche et partenariats"
+            ),
+            "publications": self._create_retriever(
+                category="PUBLICATIONTHEMATIQUEAVID",
+                description="Publications scientifiques"
+            )
+        }
+        
+        print("✅ Gestionnaire Pinecone initialisé avec 4 retrievers\n")
+    
+    def _create_retriever(self, category: str, description: str):
+        """Crée un retriever Pinecone avec filtrage par catégorie."""
+        vectorstore = PineconeVectorStore(
+            index=self.index,
+            embedding=self.embeddings,
+            text_key="text",
+            namespace=""
+        )
+        
+        retriever = vectorstore.as_retriever(
+            search_type="similarity_score_threshold",
+            search_kwargs={
+                "k": SIMILARITY_TOP_K,
+                "score_threshold": SIMILARITY_SCORE_THRESHOLD,
+                "filter": {"categorie": {"$eq": category}}
+            }
+        )
+        
+        retriever.metadata = {
+            "category": category,
+            "description": description
+        }
+        
+        return retriever
+    
+    def get_retriever(self, retriever_name: str):
+        """Récupère un retriever par son nom."""
+        return self.retrievers.get(retriever_name)
+    
+    def search_all_databases(self, query: str, exclude_categories: List[str] = None) -> List[Dict[str, Any]]:
+        """
+        Recherche dans toutes les bases pour trouver des informations similaires.
+        
+        Args:
+            query: Requête de recherche
+            exclude_categories: Catégories à exclure de la recherche
+            
+        Returns:
+            Liste des informations similaires trouvées
+        """
+        exclude_categories = exclude_categories or []
+        similar_info = []
+        
+        for db_name, retriever in self.retrievers.items():
+            if retriever.metadata["category"] in exclude_categories:
+                continue
+            
+            try:
+                documents = retriever.get_relevant_documents(query)
+                
+                if documents:
+                    for doc in documents:
+                        similar_info.append({
+                            "database": db_name,
+                            "category": retriever.metadata["category"],
+                            "content": doc.page_content,
+                            "metadata": doc.metadata,
+                            "score": getattr(doc, 'score', None)
+                        })
+            except Exception as e:
+                print(f"⚠️ Erreur recherche similaires dans '{db_name}': {str(e)}")
+        
+        return similar_info
+
+retriever_manager = PineconeRetrieverManager()
+
+# =============================================================================
+# NODE 1: ANALYSE DE LA REQUÊTE
+# =============================================================================
+def analyze_query_node(state: AgentState) -> AgentState:
+    """Node d'analyse de la requête utilisateur."""
+    print(f"\n{'='*80}")
+    print(f"📊 NODE 1: ANALYSE DE LA REQUÊTE")
+    print(f"{'='*80}")
+    print(f"🔍 Requête: {state['user_query']}\n")
+    
+    llm = ChatOpenAI(
+        model=OPENAI_MODEL_NAME,
+        base_url=OPENAI_BASE_URL,
+        api_key=OPENAI_API_KEY,
+        temperature=0
+    )
+    
+    analysis_prompt = ChatPromptTemplate.from_messages([
+        ("system", """Tu es un expert de l'Université Gustave Eiffel spécialisé dans les thématiques de Ville Durable.
+
+Analyse la requête et détermine quelle(s) base(s) de données interroger parmi:
+
+1. **laboratoires** (FICHELABOTHEMATIQUEAVID)
+2. **formations** (FORMATIONTHEMATIQUEAVID)
+3. **recherche** (RECHERCHETHEMATIQUEAVID)
+4. **publications** (PUBLICATIONTHEMATIQUEAVID)
+
+Réponds UNIQUEMENT en JSON valide."""),
+        ("human", """{user_query}
+
+Format de réponse attendu:
+{{
+    "databases_to_query": ["laboratoires", "formations", "recherche", "publications"],
+    "priorities": {{
+        "laboratoires": "high",
+        "formations": "medium",
+        "recherche": "low",
+        "publications": "high"
+    }},
+    "optimized_queries": {{
+        "laboratoires": "requête optimisée",
+        "formations": "requête optimisée",
+        "recherche": "requête optimisée",
+        "publications": "requête optimisée"
+    }},
+    "analysis_summary": "résumé de l'analyse"
+}}""")
+    ])
+    
+    json_parser = JsonOutputParser()
+    analysis_chain = analysis_prompt | llm | json_parser
+    
+    try:
+        query_analysis = analysis_chain.invoke({"user_query": state["user_query"]})
+        
+        print(f"✅ Bases identifiées: {', '.join(query_analysis['databases_to_query'])}")
+        print(f"✅ {query_analysis['analysis_summary']}\n")
+        
+        state["query_analysis"] = query_analysis
+        state["messages"].append(AIMessage(content=f"Analyse terminée: {query_analysis['analysis_summary']}"))
+        
+    except Exception as e:
+        error_msg = f"Erreur lors de l'analyse: {str(e)}"
+        print(f"❌ {error_msg}")
+        state["errors"].append(error_msg)
+        state["query_analysis"] = {
+            "databases_to_query": ["laboratoires"],
+            "priorities": {"laboratoires": "high"},
+            "optimized_queries": {"laboratoires": state["user_query"]},
+            "analysis_summary": "Analyse par défaut suite à erreur"
+        }
+    
+    return state
+
+# =============================================================================
+# NODE 2: COLLECTE D'INFORMATIONS
+# =============================================================================
+
+def collect_information_node(state: AgentState) -> AgentState:
+    """Node de collecte d'informations depuis les bases Pinecone."""
+    print(f"\n{'='*80}")
+    print(f"🔎 NODE 2: COLLECTE D'INFORMATIONS DEPUIS PINECONE")
+    print(f"{'='*80}\n")
+    
+    query_analysis = state["query_analysis"]
+    collected_info = []
+    
+    priorities_order = {"high": 0, "medium": 1, "low": 2}
+    databases = sorted(
+        query_analysis["databases_to_query"],
+        key=lambda db: priorities_order.get(query_analysis["priorities"].get(db, "low"), 2)
+    )
+    
+    for db_name in databases:
+        retriever = retriever_manager.get_retriever(db_name)
+        if not retriever:
+            print(f"⚠️ Retriever '{db_name}' non trouvé, ignoré.")
+            continue
+        
+        query = query_analysis["optimized_queries"].get(db_name, state["user_query"])
+        priority = query_analysis["priorities"].get(db_name, "low")
+        
+        print(f"🔍 Recherche dans '{db_name}' (priorité: {priority})")
+        print(f"   Requête: {query[:80]}...")
+        
+        try:
+            documents = retriever.get_relevant_documents(query)
+            
+            if documents:
+                print(f"   ✅ {len(documents)} résultat(s) trouvé(s)")
+                
+                results = []
+                for doc in documents:
+                    results.append({
+                        "content": doc.page_content,
+                        "metadata": doc.metadata,
+                        "score": getattr(doc, 'score', None)
+                    })
+                
+                collected_info.append({
+                    "database": db_name,
+                    "category": retriever.metadata["category"],
+                    "query": query,
+                    "priority": priority,
+                    "results_count": len(results),
+                    "results": results
+                })
+            else:
+                print(f"   ℹ️ Aucun résultat")
+                
+        except Exception as e:
+            error_msg = f"Erreur lors de la recherche dans '{db_name}': {str(e)}"
+            print(f"   ❌ {error_msg}")
+            state["errors"].append(error_msg)
+    
+    print(f"\n✅ Collecte terminée: {len(collected_info)} base(s) interrogée(s)\n")
+    
+    state["collected_information"] = collected_info
+    state["messages"].append(AIMessage(
+        content=f"Collecte terminée depuis {len(collected_info)} bases Pinecone"
+    ))
+    
+    return state
+
+# =============================================================================
+# NODE 3: GÉNÉRATION DE LA RÉPONSE
+# =============================================================================
+
+def generate_response_node(state: AgentState) -> AgentState:
+    """Node de génération de la réponse finale."""
+    print(f"\n{'='*80}")
+    print(f"✏️ NODE 3: GÉNÉRATION DE LA RÉPONSE")
+    print(f"{'='*80}\n")
+    
+    llm = ChatOpenAI(
+        model=OPENAI_MODEL_NAME,
+        base_url=OPENAI_BASE_URL,
+        api_key=OPENAI_API_KEY,
+        temperature=0.3
+    )
+    
+    context_parts = []
+    for info in state["collected_information"]:
+        context_parts.append(f"\n### Base: {info['database']} (Catégorie: {info['category']})")
+        context_parts.append(f"Requête: {info['query']}")
+        context_parts.append(f"Résultats: {info['results_count']}")
+        
+        for idx, result in enumerate(info['results'], 1):
+            context_parts.append(f"\nRésultat {idx}:")
+            context_parts.append(f"Score: {result.get('score', 'N/A')}")
+            context_parts.append(f"Contenu: {result['content'][:500]}...")
+            if result['metadata']:
+                context_parts.append(f"Métadonnées: {json.dumps(result['metadata'], ensure_ascii=False)}")
+    
+    context = "\n".join(context_parts)
+    
+    generation_prompt = ChatPromptTemplate.from_messages([
+        ("system", """Tu es un assistant expert de l'Université Gustave Eiffel spécialisé en Ville Durable.
+
+RÈGLES STRICTES:
+1. Base ta réponse EXCLUSIVEMENT sur les informations fournies dans le contexte Pinecone
+2. Ne JAMAIS inventer ou extrapoler d'informations
+3. Cite précisément les sources (nom de la base, catégorie Pinecone)
+4. Si une information n'est pas dans les sources, indique-le clairement
+5. Structure ta réponse de manière claire et professionnelle
+6. Mentionne les métadonnées pertinentes (laboratoires, formations, auteurs, etc.)"""),
+        ("human", """REQUÊTE UTILISATEUR:
+{user_query}
+
+CONTEXTE PINECONE (SOURCES VÉRIFIÉES):
+{context}
+
+Génère une réponse professionnelle basée uniquement sur ces sources.""")
+    ])
+    
+    generation_chain = generation_prompt | llm
+    
+    try:
+        response = generation_chain.invoke({
+            "user_query": state["user_query"],
+            "context": context
+        })
+        
+        final_response = response.content
+        print(f"✅ Réponse générée ({len(final_response)} caractères)\n")
+        
+        state["final_response"] = final_response
+        state["messages"].append(AIMessage(content=final_response))
+        
+    except Exception as e:
+        error_msg = f"Erreur lors de la génération: {str(e)}"
+        print(f"❌ {error_msg}")
+        state["errors"].append(error_msg)
+        state["final_response"] = f"Erreur lors de la génération de la réponse: {str(e)}"
+    
+    return state
+
+# =============================================================================
+# NODE 4: VALIDATION ANTI-HALLUCINATION
+# =============================================================================
+
+def validate_response_node(state: AgentState) -> AgentState:
+    """Node de validation anti-hallucination."""
+    print(f"\n{'='*80}")
+    print(f"✅ NODE 4: VALIDATION ANTI-HALLUCINATION")
+    print(f"{'='*80}")
+    
+    iteration = state["iteration_count"] + 1
+    print(f"🔄 Itération {iteration}/{MAX_VALIDATION_LOOPS}\n")
+    
+    llm = ChatOpenAI(
+        model=OPENAI_MODEL_NAME,
+        base_url=OPENAI_BASE_URL,
+        api_key=OPENAI_API_KEY,
+        temperature=0
+    )
+    
+    validation_prompt = ChatPromptTemplate.from_messages([
+        ("system", """Tu es un validateur strict pour l'Université Gustave Eiffel.
+
+Vérifie que CHAQUE élément de la réponse est STRICTEMENT basé sur les sources Pinecone fournies.
+
+Sois IMPITOYABLE: mieux vaut rejeter une bonne réponse que laisser passer une hallucination."""),
+        ("human", """RÉPONSE À VALIDER:
+{response}
+
+SOURCES PINECONE (VÉRITÉ ABSOLUE):
+{sources}
+
+Réponds en JSON valide:
+{{
+    "is_valid": true/false,
+    "confidence_score": 0-100,
+    "hallucinations_detected": ["liste précise des hallucinations"],
+    "missing_information": ["informations manquantes si dans sources"],
+    "incorrect_facts": ["faits incorrects ou mal attribués"],
+    "validation_message": "message détaillé avec recommandations"
+}}""")
+    ])
+    
+    json_parser = JsonOutputParser()
+    validation_chain = validation_prompt | llm | json_parser
+    
+    try:
+        sources_json = json.dumps(
+            state["collected_information"],
+            ensure_ascii=False,
+            indent=2
+        )
+        
+        validation_result = validation_chain.invoke({
+            "response": state["final_response"],
+            "sources": sources_json
+        })
+        
+        print(f"📊 Confiance: {validation_result['confidence_score']}%")
+        print(f"📊 Valide: {validation_result['is_valid']}")
+        
+        if validation_result['hallucinations_detected']:
+            print(f"⚠️ Hallucinations détectées: {len(validation_result['hallucinations_detected'])}")
+            for hall in validation_result['hallucinations_detected']:
+                print(f"   - {hall}")
+        else:
+            print(f"✅ Aucune hallucination détectée")
+        
+        state["validation_results"].append(validation_result)
+        state["iteration_count"] = iteration
+        
+    except Exception as e:
+        error_msg = f"Erreur lors de la validation: {str(e)}"
+        print(f"❌ {error_msg}")
+        state["errors"].append(error_msg)
+        
+        validation_result = {
+            "is_valid": False,
+            "confidence_score": 0,
+            "hallucinations_detected": [f"Erreur de validation: {str(e)}"],
+            "missing_information": [],
+            "incorrect_facts": [],
+            "validation_message": "Erreur lors de la validation"
+        }
+        state["validation_results"].append(validation_result)
+        state["iteration_count"] = iteration
+    
+    print()
+    return state
+
+# =============================================================================
+# NODE 5: REFINEMENT
+# =============================================================================
+
+def refine_response_node(state: AgentState) -> AgentState:
+    """Node de refinement de la réponse."""
+    print(f"\n{'='*80}")
+    print(f"⚙️ NODE 5: REFINEMENT (CORRECTION)")
+    print(f"{'='*80}\n")
+    
+    last_validation = state["validation_results"][-1]
+    
+    print(f"🔧 Correction des problèmes détectés:")
+    print(f"   - Hallucinations: {len(last_validation['hallucinations_detected'])}")
+    print(f"   - Faits incorrects: {len(last_validation['incorrect_facts'])}")
+    print(f"   - Infos manquantes: {len(last_validation['missing_information'])}\n")
+    
+    llm = ChatOpenAI(
+        model=OPENAI_MODEL_NAME,
+        base_url=OPENAI_BASE_URL,
+        api_key=OPENAI_API_KEY,
+        temperature=0.2
+    )
+    
+    refinement_prompt = ChatPromptTemplate.from_messages([
+        ("system", """Tu es un correcteur expert pour l'Université Gustave Eiffel.
+
+Corrige la réponse précédente en éliminant TOUTES les hallucinations et erreurs."""),
+        ("human", """RÉPONSE PRÉCÉDENTE (AVEC ERREURS):
+{previous_response}
+
+PROBLÈMES DÉTECTÉS:
+{validation_issues}
+
+SOURCES PINECONE (VÉRITÉ ABSOLUE):
+{sources}
+
+Génère une réponse corrigée, précise et vérifiable.""")
+    ])
+    
+    refinement_chain = refinement_prompt | llm
+    
+    try:
+        validation_issues = json.dumps({
+            "hallucinations": last_validation['hallucinations_detected'],
+            "incorrect_facts": last_validation['incorrect_facts'],
+            "missing_information": last_validation['missing_information'],
+            "validation_message": last_validation['validation_message']
+        }, ensure_ascii=False, indent=2)
+        
+        sources_json = json.dumps(
+            state["collected_information"],
+            ensure_ascii=False,
+            indent=2
+        )
+        
+        response = refinement_chain.invoke({
+            "previous_response": state["final_response"],
+            "validation_issues": validation_issues,
+            "sources": sources_json
+        })
+        
+        refined_response = response.content
+        print(f"✅ Réponse corrigée générée ({len(refined_response)} caractères)\n")
+        
+        state["final_response"] = refined_response
+        state["messages"].append(AIMessage(
+            content=f"Réponse corrigée (itération {state['iteration_count']})"
+        ))
+        
+    except Exception as e:
+        error_msg = f"Erreur lors du refinement: {str(e)}"
+        print(f"❌ {error_msg}")
+        state["errors"].append(error_msg)
+    
+    return state
+
+# =============================================================================
+# NODE 6: COLLECTE D'INFORMATIONS SIMILAIRES
+# =============================================================================
+
+def collect_similar_information_node(state: AgentState) -> AgentState:
+    """
+    Node de collecte d'informations similaires depuis les autres bases.
+    """
+    print(f"\n{'='*80}")
+    print(f"🔗 NODE 6: COLLECTE D'INFORMATIONS SIMILAIRES")
+    print(f"{'='*80}\n")
+    
+    # Catégories déjà utilisées
+    used_categories = [info["category"] for info in state["collected_information"]]
+    
+    # Recherche dans les autres bases
+    print(f"🔍 Recherche d'informations similaires dans les bases non consultées...")
+    similar_info = retriever_manager.search_all_databases(
+        query=state["user_query"],
+        exclude_categories=used_categories
+    )
+    
+    # Recherche aussi basée sur la réponse finale
+    if state.get("final_response"):
+        print(f"🔍 Recherche basée sur la réponse finale...")
+        response_based_info = retriever_manager.search_all_databases(
+            query=state["final_response"][:500],  # Limiter la taille
+            exclude_categories=used_categories
+        )
+        
+        # Fusionner et dédupliquer
+        for info in response_based_info:
+            if info not in similar_info:
+                similar_info.append(info)
+    
+    print(f"✅ {len(similar_info)} information(s) similaire(s) trouvée(s)\n")
+    
+    state["additional_information"] = similar_info
+    
+    return state
+
+# =============================================================================
+# FONCTIONS DE ROUTAGE
+# =============================================================================
+
+def should_collect_information(state: AgentState) -> str:
+    if state.get("query_analysis") and state["query_analysis"].get("databases_to_query"):
+        return "collect"
+    return "end"
+
+def should_generate_response(state: AgentState) -> str:
+    if state.get("collected_information") and len(state["collected_information"]) > 0:
+        return "generate"
+    return "end"
+
+def should_validate(state: AgentState) -> str:
+    if state.get("final_response") and state["final_response"]:
+        return "validate"
+    return "end"
+
+def should_refine_or_collect_similar(state: AgentState) -> str:
+    if not state.get("validation_results") or len(state["validation_results"]) == 0:
+        return "collect_similar"
+    
+    last_validation = state["validation_results"][-1]
+    iteration = state["iteration_count"]
+    
+    is_valid = last_validation.get("is_valid", False)
+    confidence = last_validation.get("confidence_score", 0)
+    
+    if is_valid and confidence >= 85:
+        print(f"✅ Validation réussie (confiance: {confidence}%) - Collecte d'infos similaires\n")
+        return "collect_similar"
+    
+    if iteration >= MAX_VALIDATION_LOOPS:
+        print(f"⚠️ Nombre maximum d'itérations atteint ({MAX_VALIDATION_LOOPS}) - Collecte d'infos similaires\n")
+        return "collect_similar"
+    
+    print(f"🔄 Refinement nécessaire (confiance: {confidence}%, itération {iteration}/{MAX_VALIDATION_LOOPS})\n")
+    return "refine"
+
+# =============================================================================
+# CONSTRUCTION DU WORKFLOW
+# =============================================================================
+
+def create_agent_workflow() -> StateGraph:
+    """Crée et configure le workflow LangGraph complet."""
+    print("\n🗺️ Construction du workflow LangGraph...")
+    
+    workflow = StateGraph(AgentState)
+    
+    workflow.add_node("analyze_query", analyze_query_node)
+    workflow.add_node("collect_information", collect_information_node)
+    workflow.add_node("generate_response", generate_response_node)
+    workflow.add_node("validate_response", validate_response_node)
+    workflow.add_node("refine_response", refine_response_node)
+    workflow.add_node("collect_similar_information", collect_similar_information_node)
+    
+    workflow.set_entry_point("analyze_query")
+    
+    workflow.add_conditional_edges(
+        "analyze_query",
+        should_collect_information,
+        {
+            "collect": "collect_information",
+            "end": END
+        }
+    )
+    
+    workflow.add_conditional_edges(
+        "collect_information",
+        should_generate_response,
+        {
+            "generate": "generate_response",
+            "end": END
+        }
+    )
+    
+    workflow.add_conditional_edges(
+        "generate_response",
+        should_validate,
+        {
+            "validate": "validate_response",
+            "end": END
+        }
+    )
+    
+    workflow.add_conditional_edges(
+        "validate_response",
+        should_refine_or_collect_similar,
+        {
+            "refine": "refine_response",
+            "collect_similar": "collect_similar_information"
+        }
+    )
+    
+    workflow.add_edge("refine_response", "validate_response")
+    workflow.add_edge("collect_similar_information", END)
+    
+    #memory = MemorySaver()
+    #app = workflow.compile(checkpointer=memory)
+    app = workflow.compile()
+    
+    
+    print("✅ Workflow LangGraph construit avec succès\n")
+    
+    return app
+
+# =============================================================================
+# FONCTION D'EXÉCUTION
+# =============================================================================
+
+async def run_collaborative_agent(user_query: str) -> Dict[str, Any]:
+    """Exécute le workflow complet de l'agent collaboratif."""
+    print(f"\n{'='*80}")
+    print(f"🚀 AGENT COLLABORATIF - UNIVERSITÉ GUSTAVE EIFFEL")
+    print(f"{'='*80}")
+    print(f"🔍 Requête: {user_query}\n")
+    
+    app = create_agent_workflow()
+    
+    initial_state = {
+        "messages": [HumanMessage(content=user_query)],
+        "user_query": user_query,
+        "query_analysis": {},
+        "collected_information": [],
+        "validation_results": [],
+        "final_response": "",
+        "iteration_count": 0,
+        "errors": [],
+        "additional_information": []
+    }
+    
+    print(f"{'='*80}")
+    print(f"⚙️ EXÉCUTION DU WORKFLOW")
+    print(f"{'='*80}\n")
+    
+    try:
+        final_state = await app.ainvoke(initial_state)
+        
+        print(f"\n{'='*80}")
+        print(f"✨ PROCESSUS TERMINÉ")
+        print(f"{'='*80}\n")
+        
+        result = {
+            "query": user_query,
+            "query_analysis": final_state.get("query_analysis", {}),
+            "collected_information": final_state.get("collected_information", []),
+            "validation_results": final_state.get("validation_results", []),
+            "final_response": final_state.get("final_response", ""),
+            "iteration_count": final_state.get("iteration_count", 0),
+            "errors": final_state.get("errors", []),
+            "additional_information": final_state.get("additional_information", []),
+            "sources_used": [
+                info["database"] 
+                for info in final_state.get("collected_information", [])
+            ],
+            "pinecone_index": PINECONE_INDEX_NAME
+        }
+        
+        return result
+        
+    except Exception as e:
+        error_msg = f"Erreur lors de l'exécution du workflow: {str(e)}"
+        print(f"\n❌ {error_msg}\n")
+        
+        return {
+            "query": user_query,
+            "query_analysis": {},
+            "collected_information": [],
+            "validation_results": [],
+            "final_response": f"Erreur: {error_msg}",
+            "iteration_count": 0,
+            "errors": [error_msg],
+            "additional_information": [],
+            "sources_used": [],
+            "pinecone_index": PINECONE_INDEX_NAME
+        }
+
+# =============================================================================
+# FONCTION D'AFFICHAGE DES RÉSULTATS
+# =============================================================================
+
+def display_results(result: Dict[str, Any]) -> None:
+    """
+    Affiche les résultats de manière formatée et lisible.
+    
+    Args:
+        result: Dictionnaire des résultats du workflow
+    """
+    print(f"\n{'='*80}")
+    print(f"📋 RÉPONSE FINALE")
+    print(f"{'='*80}")
+    print(result["final_response"])
+    
+    print(f"\n{'='*80}")
+    print(f"📊 MÉTADONNÉES DU TRAITEMENT")
+    print(f"{'='*80}")
+    print(f"🗄️ Index Pinecone: {result['pinecone_index']}")
+    print(f"📚 Sources consultées: {', '.join(result['sources_used']) if result['sources_used'] else 'Aucune'}")
+    print(f"🔄 Itérations de validation: {result['iteration_count']}")
+    
+    if result['validation_results']:
+        last_validation = result['validation_results'][-1]
+        print(f"✅ Score de confiance final: {last_validation.get('confidence_score', 0)}%")
+        print(f"✅ Validation finale: {'Réussie' if last_validation.get('is_valid') else 'Échouée'}")
+        
+        hallucinations = last_validation.get('hallucinations_detected', [])
+        print(f"⚠️ Hallucinations détectées: {len(hallucinations)}")
+        
+        if hallucinations:
+            print(f"\n⚠️ HALLUCINATIONS CORRIGÉES:")
+            for i, hall in enumerate(hallucinations, 1):
+                print(f"   {i}. {hall}")
+    
+    if result['errors']:
+        print(f"\n❌ ERREURS RENCONTRÉES:")
+        for i, error in enumerate(result['errors'], 1):
+            print(f"   {i}. {error}")
+    
+    print(f"\n{'='*80}")
+    print(f"📈 DÉTAILS DE LA COLLECTE")
+    print(f"{'='*80}")
+    for info in result['collected_information']:
+        print(f"\n📦 Base: {info['database']}")
+        print(f"   Catégorie: {info['category']}")
+        print(f"   Priorité: {info['priority']}")
+        print(f"   Résultats: {info['results_count']}")
+        print(f"   Requête: {info['query'][:80]}...")
+    
+    # Nouvelle section : Informations similaires
+    if result.get('additional_information') and len(result['additional_information']) > 0:
+        print(f"\n{'='*80}")
+        print(f"💡 LES INFORMATIONS QUI AURAIENT PU VOUS INTÉRESSER")
+        print(f"{'='*80}")
+        print(f"\nInformations similaires ou apparentées trouvées dans d'autres bases:\n")
+        
+        # Regrouper par base de données
+        grouped_info = {}
+        for info in result['additional_information']:
+            db_name = info['database']
+            if db_name not in grouped_info:
+                grouped_info[db_name] = []
+            grouped_info[db_name].append(info)
+        
+        # Afficher par base
+        for db_name, items in grouped_info.items():
+            print(f"\n{'─'*80}")
+            print(f"📚 Base: {db_name.upper()}")
+            print(f"   Catégorie Pinecone: {items[0]['category']}")
+            print(f"   Nombre de résultats: {len(items)}")
+            print(f"{'─'*80}\n")
+            
+            for idx, item in enumerate(items, 1):
+                print(f"   Résultat {idx}:")
+                print(f"   ├─ Score de similarité: {item['score']:.4f}" if item.get('score') else "   ├─ Score: N/A")
+                
+                # Affichage du contenu (limité)
+                content_preview = item['content'][:300]
+                if len(item['content']) > 300:
+                    content_preview += "..."
+                print(f"   ├─ Contenu: {content_preview}")
+                
+                # Affichage des métadonnées détaillées
+                if item.get('metadata'):
+                    metadata = item['metadata']
+                    print(f"   └─ Sources complètes:")
+                    
+                    # Extraire et afficher les métadonnées pertinentes
+                    if 'titre' in metadata or 'title' in metadata:
+                        titre = metadata.get('titre') or metadata.get('title')
+                        print(f"      • Titre: {titre}")
+                    
+                    if 'laboratoire' in metadata:
+                        print(f"      • Laboratoire: {metadata['laboratoire']}")
+                    
+                    if 'formation' in metadata:
+                        print(f"      • Formation: {metadata['formation']}")
+                    
+                    if 'auteur' in metadata or 'auteurs' in metadata or 'authors' in metadata:
+                        auteurs = metadata.get('auteur') or metadata.get('auteurs') or metadata.get('authors')
+                        print(f"      • Auteur(s): {auteurs}")
+                    
+                    if 'date' in metadata or 'annee' in metadata or 'year' in metadata:
+                        date = metadata.get('date') or metadata.get('annee') or metadata.get('year')
+                        print(f"      • Date/Année: {date}")
+                    
+                    if 'thematique' in metadata or 'thematiques' in metadata:
+                        them = metadata.get('thematique') or metadata.get('thematiques')
+                        print(f"      • Thématique(s): {them}")
+                    
+                    if 'niveau' in metadata:
+                        print(f"      • Niveau: {metadata['niveau']}")
+                    
+                    if 'competences' in metadata:
+                        print(f"      • Compétences: {metadata['competences']}")
+                    
+                    if 'equipements' in metadata:
+                        print(f"      • Équipements: {metadata['equipements']}")
+                    
+                    if 'axe_recherche' in metadata:
+                        print(f"      • Axe de recherche: {metadata['axe_recherche']}")
+                    
+                    if 'partenaires' in metadata or 'collaborations' in metadata:
+                        part = metadata.get('partenaires') or metadata.get('collaborations')
+                        print(f"      • Partenaires/Collaborations: {part}")
+                    
+                    if 'url' in metadata or 'lien' in metadata:
+                        url = metadata.get('url') or metadata.get('lien')
+                        print(f"      • Lien: {url}")
+                    
+                    if 'doi' in metadata:
+                        print(f"      • DOI: {metadata['doi']}")
+                    
+                    if 'source' in metadata:
+                        print(f"      • Source document: {metadata['source']}")
+                    
+                    # Métadonnées additionnelles
+                    displayed_keys = ['titre', 'title', 'laboratoire', 'formation', 'auteur', 'auteurs', 
+                                     'authors', 'date', 'annee', 'year', 'thematique', 'thematiques',
+                                     'niveau', 'competences', 'equipements', 'axe_recherche', 
+                                     'partenaires', 'collaborations', 'url', 'lien', 'doi', 'source',
+                                     'categorie', 'text']
+                    
+                    other_metadata = {k: v for k, v in metadata.items() if k not in displayed_keys}
+                    if other_metadata:
+                        print(f"      • Autres informations: {json.dumps(other_metadata, ensure_ascii=False, indent=8)}")
+                
+                print()  # Ligne vide entre les résultats
+        
+        print(f"\n{'='*80}")
+        print(f"💬 INTERPRÉTATION DES RÉSULTATS SIMILAIRES")
+        print(f"{'='*80}")
+        print("Ces informations proviennent de bases qui n'ont pas été prioritaires pour")
+        print("votre requête initiale, mais qui contiennent des éléments apparentés.")
+        print("Elles peuvent enrichir votre compréhension du sujet ou vous orienter")
+        print("vers des domaines connexes intéressants.\n")
+
+# =============================================================================
+# FONCTION MAIN
+# =============================================================================
+
+async def main():
+    """Fonction principale de l'application."""
+    
+    exemples_requetes = [
+        "Quels sont les laboratoires de l'université Gustave Eiffel travaillant sur la mobilité urbaine durable?",
+        "Je cherche des formations en master sur l'aménagement urbain et le développement durable",
+        "Quels laboratoires ont des axes de recherche similaires en énergie et pourraient collaborer?",
+        "Liste les équipements disponibles dans les laboratoires travaillant sur la qualité de l'air",
+        "Trouve des publications récentes sur la transition énergétique dans les villes",
+        "Qui sont les auteurs qui publient sur la mobilité douce et dans quels laboratoires?",
+        "Quelles publications traitent de l'urbanisme durable et quand ont-elles été publiées?",
+        "Compare les formations et les laboratoires sur le thème de la ville intelligente",
+        "Identifie les opportunités de partenariats entre laboratoires sur la résilience urbaine",
+        "Quelles sont les compétences enseignées dans les formations liées à l'économie circulaire?"
+    ]
+    
+    print(f"\n{'='*80}")
+    print(f"🎓 AGENT COLLABORATIF - UNIVERSITÉ GUSTAVE EIFFEL")
+    print(f"{'='*80}")
+    print(f"🗄️ Index Pinecone: {PINECONE_INDEX_NAME}")
+    print(f"🤖 Modèle: {OPENAI_MODEL_NAME}")
+    print(f"🌐 Base URL: {OPENAI_BASE_URL}")
+    print(f"🤗 Embeddings: {HUGGINGFACE_MODEL}")
+    print(f"🔄 Max itérations: {MAX_VALIDATION_LOOPS}")
+    print(f"🎯 Top K résultats: {SIMILARITY_TOP_K}")
+    print(f"📊 Seuil de similarité: {SIMILARITY_SCORE_THRESHOLD}")
+    print(f"{'='*80}\n")
+    
+    print("📚 EXEMPLES DE REQUÊTES DISPONIBLES:")
+    print("="*80)
+    for i, req in enumerate(exemples_requetes, 1):
+        print(f"{i:2d}. {req}")
+    print("="*80 + "\n")
+    
+    selected_query = exemples_requetes[0]
+    
+    print(f"🎯 Requête sélectionnée: {selected_query}\n")
+    
+    result = await run_collaborative_agent(selected_query)
+    
+    display_results(result)
+    
+    print(f"\n{'='*80}")
+    print(f"✅ TRAITEMENT TERMINÉ AVEC SUCCÈS")
+    print(f"{'='*80}\n")
+    
+    return result
+
+# =============================================================================
+# POINT D'ENTRÉE DU SCRIPT
+# =============================================================================
+
+if __name__ == "__main__":
+    """
+    Point d'entrée principal du script.
+    
+    Configuration requise:
+    1. Variables d'environnement:
+       export PINECONE_API_KEY="votre-clé-pinecone"
+       export OPENAI_API_KEY="votre-clé-openai"
+       export OPENAI_BASE_URL="https://votre-endpoint.com/v1"  # Optionnel
+       export OPENAI_MODEL_NAME="gpt-4"  # Optionnel
+       export HUGGINGFACE_MODEL="sentence-transformers/all-mpnet-base-v2"  # Optionnel
+    
+    2. Dépendances:
+       pip install langgraph langchain langchain-pinecone langchain-openai pinecone-client sentence-transformers
+    
+    3. Structure Pinecone:
+       - Index: "all-jdlp"
+       - Dimension: compatible avec le modèle HuggingFace (ex: 768)
+       - Métrique: cosine
+       - Catégories: FICHELABOTHEMATIQUEAVID, FORMATIONTHEMATIQUEAVID,
+                     RECHERCHETHEMATIQUEAVID, PUBLICATIONTHEMATIQUEAVID
+    
+    Utilisation:
+    - Développement: python script.py
+    - Production: Intégrer dans une API FastAPI/Flask
+    - Tests: pytest script.py --asyncio-mode=auto
+    """
+    
+    asyncio.run(main())

chainlit.md

@@ -0,0 +1,14 @@
+# Welcome to Chainlit! 🚀🤖
+
+Hi there, Developer! 👋 We're excited to have you on board. Chainlit is a powerful tool designed to help you prototype, debug and share applications built on top of LLMs.
+
+## Useful Links 🔗
+
+- **Documentation:** Get started with our comprehensive [Chainlit Documentation](https://docs.chainlit.io) 📚
+- **Discord Community:** Join our friendly [Chainlit Discord](https://discord.gg/k73SQ3FyUh) to ask questions, share your projects, and connect with other developers! 💬
+
+We can't wait to see what you create with Chainlit! Happy coding! 💻😊
+
+## Welcome screen
+
+To modify the welcome screen, edit the `chainlit.md` file at the root of your project. If you do not want a welcome screen, just leave this file empty.

requirements.txt

@@ -0,0 +1,74 @@
+# =============================================================================
+# REQUIREMENTS - Agent Collaboratif UGE avec Chainlit 2.8.1
+# =============================================================================
+
+# -----------------------------------------------------------------------------
+# Framework Chainlit
+# -----------------------------------------------------------------------------
+chainlit==2.8.1
+literalai>=0.0.500  # Pour le Data Layer officiel
+
+# -----------------------------------------------------------------------------
+# LangChain Ecosystem
+# -----------------------------------------------------------------------------
+langchain>=0.1.0
+langchain-openai>=0.0.5
+langchain-pinecone>=0.0.3
+langchain-core>=0.1.23
+langgraph>=0.0.25
+
+# -----------------------------------------------------------------------------
+# Vector Stores & Embeddings
+# -----------------------------------------------------------------------------
+#pinecone-client>=3.0.0
+pinecone
+sentence-transformers>=2.3.1
+torch>=2.1.0  # Requis pour sentence-transformers
+numpy>=1.24.0
+
+# -----------------------------------------------------------------------------
+# LLM Providers
+# -----------------------------------------------------------------------------
+openai>=1.12.0
+
+# -----------------------------------------------------------------------------
+# Monitoring & Observability
+# -----------------------------------------------------------------------------
+langsmith>=0.1.0
+python-dotenv>=1.0.0
+
+# -----------------------------------------------------------------------------
+# Database & Data Layer
+# -----------------------------------------------------------------------------
+psycopg2-binary>=2.9.9  # PostgreSQL adapter
+supabase>=2.3.0  # Supabase Python client
+SQLAlchemy>=2.0.0  # ORM pour manipulation DB
+
+# -----------------------------------------------------------------------------
+# Async & Utilities
+# -----------------------------------------------------------------------------
+asyncio>=3.4.3
+aiohttp>=3.9.0
+python-multipart>=0.0.6  # Pour les uploads de fichiers
+
+# -----------------------------------------------------------------------------
+# Data Processing
+# -----------------------------------------------------------------------------
+pydantic>=2.6.0
+python-json-logger>=2.0.7
+
+# -----------------------------------------------------------------------------
+# Development & Testing
+# -----------------------------------------------------------------------------
+pytest>=7.4.0
+pytest-asyncio>=0.21.0
+black>=24.1.0
+flake8>=7.0.0
+mypy>=1.8.0
+
+# -----------------------------------------------------------------------------
+# Production
+# -----------------------------------------------------------------------------
+uvicorn[standard]>=0.27.0
+gunicorn>=21.2.0
+watchfiles>=0.21.0  # Pour le hot-reload en dev