Update app.py

app.py

@@ -57,19 +57,21 @@ def auth_callback(username: str, password: str) -> Optional[cl.User]:
     """
     # Exemple simple (à remplacer par votre logique)
     auth = json.loads(os.environ.get("CHAINLIT_AUTH_LOGIN"))
-    ident = auth[0]['ident']
-    pwd = auth[0]['pwd']
-    resultLogAdmin = bcrypt.checkpw(username.encode('utf-8'), bcrypt.hashpw(ident.encode('utf-8'), bcrypt.gensalt())) 
-    resultPwdAdmin = bcrypt.checkpw(password.encode('utf-8'), bcrypt.hashpw(pwd.encode('utf-8'), bcrypt.gensalt())) 
-    resultRole = auth[0]['role']
-    
-    if resultLogAdmin == True and resultPwdAdmin == True and resultRole == "adminavid":
-        return cl.User(
-            identifier=pwd,
-            metadata={"role": "adminavid", "provider": "credentials"}
-        )
-    else:
-        return None
+    
+    auth_iter = iter(auth)  
+
+    while True:
+        # item will be "end" if iteration is complete
+        connexion = next(auth_iter, "end")
+        if bcrypt.checkpw(username.encode('utf-8'), bcrypt.hashpw(connexion['ident'].encode('utf-8'), bcrypt.gensalt())) == True and bcrypt.checkpw(password.encode('utf-8'), bcrypt.hashpw(connexion['pwd'].encode('utf-8'), bcrypt.gensalt())) == True:
+            print("OK")
+            return cl.User(
+                identifier=connexion['ident'],
+                metadata={"role": connexion['role'], "provider": "credentials"}
+            )
+        if connexion == "end":
+            break
+    return None
 
 @cl.data_layer
 def get_data_layer():
@@ -189,7 +191,6 @@ async def display_similar_info(similar_info: List[Dict[str, Any]]):
         
         # Créer un élément Chainlit
         element = cl.Text(
-            name=f"similar_{db_name}",
             content="\n".join(content_parts),
             display="side"
         )
@@ -201,13 +202,55 @@ async def display_similar_info(similar_info: List[Dict[str, Any]]):
             elements=elements
         ).send()
 
+# =============================================================================
+# FONCTIONS D'AFFICHAGE STREAMING PAR NŒUD
+# =============================================================================
+
+async def stream_response(content: str, msg: cl.Message, chunk_size: int = 50):
+    """Stream du contenu progressivement dans un message."""
+    for i in range(0, len(content), chunk_size):
+        chunk = content[i:i + chunk_size]
+        msg.content += chunk
+        await msg.update()
+        await asyncio.sleep(0.25)  # Petit délai pour un effet visuel
+
+async def display_node_update(node_name: str, state: Dict[str, Any]):
+    """Affiche les mises à jour d'état après l'exécution d'un nœud."""
+    
+    if node_name == "analyze_query":
+        if state.get("query_analysis"):
+            await display_query_analysis(state["query_analysis"])
+    
+    elif node_name == "collect_information":
+        if state.get("collected_information"):
+            await display_collection(state["collected_information"])
+    
+    elif node_name == "generate_response":
+        if state.get("final_response"):
+            content = f"**Réponse générée** ({len(state['final_response'])} caractères)\n\nLa réponse complète sera affichée à la fin du workflow."
+            await send_cot_step("✏️ Génération de la réponse", content, "done")
+    
+    elif node_name == "validate_response":
+        if state.get("validation_results"):
+            iteration = state.get("iteration_count", len(state["validation_results"]))
+            last_validation = state["validation_results"][-1]
+            await display_validation(last_validation, iteration)
+    
+    elif node_name == "refine_response":
+        content = f"**Itération:** {state.get('iteration_count', 0)}\n**Correction en cours...**"
+        await send_cot_step("⚙️ Refinement", content, "done")
+    
+    elif node_name == "collect_similar_information":
+        if state.get("additional_information"):
+            await display_similar_info(state["additional_information"])
+
 # =============================================================================
 # FONCTION PRINCIPALE TRACÉE AVEC LANGSMITH
 # =============================================================================
 
 @traceable(name="agent_collaboratif_query", project_name=LANGSMITH_PROJECT)
 async def process_query_with_tracing(query: str, thread_id: str) -> Dict[str, Any]:
-    """Traite la requête avec traçage LangSmith."""
+    """Traite la requête avec traçage LangSmith et streaming en temps réel."""
     
     # Import du workflow
     from agent_collaboratif_avid import AgentState, create_agent_workflow
@@ -224,30 +267,58 @@ async def process_query_with_tracing(query: str, thread_id: str) -> Dict[str, An
         "final_response": "",
         "iteration_count": 0,
         "errors": [],
-        "additional_information": []
+        "additional_information": [],
+        "similar_info_response":""
     }
     
-    # Analyse de la requête
-    await send_cot_step("🔄 Démarrage", "Initialisation du workflow...", "running")
+    # Message de démarrage
+    await send_cot_step("🔄 Démarrage", "Initialisation du workflow LangGraph...", "done")
     
-    final_state = await app.ainvoke(initial_state)
+    # Variables pour suivre l'état
+    final_state = None
     
-
-    # Affichage progressif
-    if final_state.get("query_analysis"):
-        await display_query_analysis(final_state["query_analysis"])
-    
-    if final_state.get("collected_information"):
-        await send_cot_step("📊 Collecte d'informations", "Collecte d'informations...", "running")
-        await display_collection(final_state["collected_information"])
+    # STREAMING: Utilisation de app.astream() pour obtenir les mises à jour après chaque nœud
+    try:
+        async for event in app.astream(initial_state):
+            # event est un dictionnaire avec les nœuds comme clés
+            for node_name, node_state in event.items():
+                # Ignorer le nœud spécial __start__
+                if node_name == "__start__":
+                    continue
+                
+                # Afficher un message de progression pour le nœud actuel
+                node_display_names = {
+                    "analyze_query": "🔍 Analyse de la requête",
+                    "collect_information": "📊 Collecte d'informations",
+                    "generate_response": "✏️ Génération de la réponse",
+                    "validate_response": "✅ Validation anti-hallucination",
+                    "refine_response": "⚙️ Refinement de la réponse",
+                    "collect_similar_information": "🔗 Collecte d'informations similaires"
+                }
+                
+                display_name = node_display_names.get(node_name, f"⚙️ {node_name}")
+                
+                # Message de progression
+                await send_cot_step(
+                    f"🔄 {display_name}", 
+                    f"Nœud exécuté avec succès", 
+                    "done"
+                )
+                
+                # Afficher les détails spécifiques du nœud
+                await display_node_update(node_name, node_state)
+                
+                # Sauvegarder l'état final
+                final_state = node_state
     
-    if final_state.get("validation_results"):
-        for idx, validation in enumerate(final_state["validation_results"], 1):
-            await display_validation(validation, idx)
+    except Exception as e:
+        error_msg = f"Erreur lors du streaming: {str(e)}"
+        await send_cot_step("❌ Erreur", error_msg, "error")
+        raise
     
-    # Informations similaires
-    if final_state.get("additional_information"):
-        await display_similar_info(final_state["additional_information"])
+    # Si le streaming n'a pas retourné d'état final, utiliser la méthode classique
+    if final_state is None:
+        final_state = initial_state
     
     result = {
         "query": query,
@@ -258,6 +329,7 @@ async def process_query_with_tracing(query: str, thread_id: str) -> Dict[str, An
         "iteration_count": final_state.get("iteration_count", 0),
         "errors": final_state.get("errors", []),
         "additional_information": final_state.get("additional_information", []),
+        "similar_info_response": final_state.get("similar_info_response", ""),
         "sources_used": [
             info["database"] 
             for info in final_state.get("collected_information", [])
@@ -271,41 +343,14 @@ async def process_query_with_tracing(query: str, thread_id: str) -> Dict[str, An
 # CALLBACKS CHAINLIT
 # =============================================================================
 
-#@cl.on_chat_start
-#async def start():
-#    """Initialisation de la session chat."""
-    
-    # Message de bienvenue avec style
-#    welcome_msg = f"""# 🎓 Agent Collaboratif - Université Gustave Eiffel
-
-#Bienvenue ! Je suis votre assistant spécialisé en **Ville Durable**.
-
-## 🔧 Configuration
-#- **Index Pinecone:** `{PINECONE_INDEX_NAME}`
-#- **Modèle:** `{OPENAI_MODEL_NAME}`
-#- **Top K résultats:** `{SIMILARITY_TOP_K}`
-#- **Max validations:** `{MAX_VALIDATION_LOOPS}`
-
-## 💡 Fonctionnalités
-#✅ Recherche multi-bases vectorielles
-#✅ Validation anti-hallucination
-#✅ Suggestions d'informations connexes
-#✅ Traçage LangSmith actif
-
-#**Choisissez un starter ou posez votre question !**
-#"""
-    
-#    await cl.Message(content=welcome_msg).send()
-    
-    # Sauvegarder les métadonnées de session
-#    cl.user_session.set("session_started", True)
-#    cl.user_session.set("query_count", 0)
-
-@cl.set_starters
-async def set_starters():
-    """Configure les starters avec icônes."""
-    #return [cl.Starter(label=s["label"], message=s["message"], icon=s["icon"]) for s in STARTERS]
+@cl.set_chat_profiles
+async def chat_profile(current_user: cl.User):
     return [
+        cl.ChatProfile(
+            name="Avid Agent",
+            markdown_description="🎓 Avid Agent permet de converser avec un agent collaboratif entre 4 bases de données pour extraire les informations pertinentes afin de générer une réponse en réduisant les hallucations, par relecture et redéfinition des éléments.",
+            icon="/public/sparkles-gustaveia.png",
+            starters=[
     cl.Starter(
         label= "🔬 Laboratoires & Mobilité",
         message= "Quels sont les laboratoires de l'université Gustave Eiffel travaillant sur la mobilité urbaine durable?",
@@ -357,6 +402,49 @@ async def set_starters():
         #icon= "/public/icons/circular.svg"
     )
 ]
+        ),cl.ChatProfile(
+            name="Avid Dataviz",
+            markdown_description="💡 Avid Dataviz permet d'avoir recours à des éléments statistiques et de corrélation entre les données laboratoires et les thématiques Ville Durable",
+        )
+    ]
+            
+            
+@cl.on_chat_start
+async def start():
+    """Initialisation de la session chat."""
+    user = cl.user_session.get("user")
+    chat_profile = cl.user_session.get("chat_profile")
+    if chat_profile == "Avid Dataviz":
+        await cl.Message(
+            content=f"Bienvenue {user.identifier}!\n\nL'environnement {chat_profile} vous restitue les données sous forme d'objets statistiques."
+        ).send()
+    
+    # Message de bienvenue avec style
+#    welcome_msg = f"""# 🎓 Agent Collaboratif - Université Gustave Eiffel
+
+#Bienvenue ! Je suis votre assistant spécialisé en **Ville Durable**.
+
+## 🔧 Configuration
+#- **Index Pinecone:** `{PINECONE_INDEX_NAME}`
+#- **Modèle:** `{OPENAI_MODEL_NAME}`
+#- **Top K résultats:** `{SIMILARITY_TOP_K}`
+#- **Max validations:** `{MAX_VALIDATION_LOOPS}`
+
+## 💡 Fonctionnalités
+#✅ Recherche multi-bases vectorielles
+#✅ Validation anti-hallucination
+#✅ Suggestions d'informations connexes
+#✅ Traçage LangSmith actif
+
+#**Choisissez un starter ou posez votre question !**
+#"""
+    
+#    await cl.Message(content=welcome_msg).send()
+    
+    # Sauvegarder les métadonnées de session
+#    cl.user_session.set("session_started", True)
+#    cl.user_session.set("query_count", 0)
+
 
 @cl.on_message
 async def main(message: cl.Message):
@@ -377,9 +465,29 @@ async def main(message: cl.Message):
         # Traitement avec affichage du COT
         result = await process_query_with_tracing(query, thread_id)
         
-        # Réponse finale
+        # Réponse finale en streaming
         final_response = result["final_response"]
         
+        # Afficher un séparateur
+        await send_cot_step("📝 Réponse finale", "Affichage de la réponse complète en streaming...", "done")
+        
+        # Créer un nouveau message pour la réponse finale
+        response_msg = cl.Message(content="")
+        await response_msg.send()
+        
+        # Streamer la réponse complète
+        await stream_response(final_response, response_msg, chunk_size=50)
+
+        # Afficher les informations similaires collectées par le nœud 6
+        if result.get("similar_info_response"):
+            similar_msg = cl.Message(content="")
+            await similar_msg.send()
+        
+            # Streamer la réponse similaire
+            await stream_response(result["similar_info_response"], similar_msg, chunk_size=50)
+        
+            #await display_similar_info(result["similar_info_response"])
+        
         # Métadonnées
         metadata_parts = [
             f"\n\n---\n### 📊 Métadonnées du traitement",
@@ -393,10 +501,12 @@ async def main(message: cl.Message):
         
         metadata_parts.append(f"**Requête n°:** {query_count}")
         
-        full_response = final_response + "\n".join(metadata_parts)
+        # Ajouter les métadonnées en streaming
+        metadata_text = "\n".join(metadata_parts)
+        await stream_response(metadata_text, response_msg, chunk_size=100)
         
-        # Mise à jour du message
-        processing_msg.content = full_response
+        # Supprimer le message de traitement initial vide
+        processing_msg.content = "✅ Traitement terminé"
         await processing_msg.update()
         
         # Sauvegarder dans l'historique de session
@@ -420,6 +530,10 @@ async def main(message: cl.Message):
         #        comment=str(e)
         #    )
 
+@cl.on_shared_thread_view
+async def on_shared_thread_view(thread: ThreadDict, viewer: Optional[cl.User]) -> bool:
+    return True
+    
 @cl.on_chat_resume
 async def on_chat_resume(thread: ThreadDict):
     """Reprise d'une conversation existante."""