Add SynthesisAgent functionality to A3 workflow, including new prompts and payload fields. Introduce synthesis model in A3Payload, update AgentState to include synthesis output, and create synthesis_node for generating executive summaries. Enhance agent service to support specific LLM configurations for synthesis, improving overall data analysis capabilities.

domain/payloads/a3.py

@@ -63,4 +63,11 @@ class A3Payload(BaseAgentPayload):
         description="Modèle LLM spécifique pour le nœud AnalysisAgent. "
                     "Si non spécifié, utilise le modèle par défaut de la requête."
     )
+    
+    # Modèle optionnel pour SynthesisAgent
+    synthesis_model: Optional[str] = Field(
+        default=None,
+        description="Modèle LLM spécifique pour le nœud SynthesisAgent. "
+                    "Si non spécifié, utilise le modèle par défaut de la requête."
+    )
 

graphs/nodes/synthesis_node.py

@@ -0,0 +1,125 @@
+"""SynthesisAgent node for A3 workflow - generates executive summary."""
+from typing import Callable, Dict, Any
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+
+from graphs.state import AgentState
+from graphs.prompts.a3_prompts import SYNTHESIS_SYSTEM_PROMPT, SYNTHESIS_HUMAN_PROMPT
+from graphs.utils.usage import extract_usage_metadata, normalize_usage
+
+
+def _extract_model_name(llm: BaseChatModel) -> str:
+    """Extract model name from LLM instance."""
+    if hasattr(llm, "model_name"):
+        return getattr(llm, "model_name")
+    if hasattr(llm, "model"):
+        model = getattr(llm, "model")
+        if isinstance(model, str):
+            return model
+    return llm.__class__.__name__
+
+
+def create_synthesis_node(llm: BaseChatModel) -> Callable[[AgentState], dict]:
+    """
+    Factory returning a node that produces an executive synthesis of the analysis.
+    
+    This node:
+    1. Takes the analysis_output from the state
+    2. Generates a concise executive summary (300-500 chars)
+    3. Returns the synthesis in the state
+    
+    Args:
+        llm: Language model to use for synthesis
+        
+    Returns:
+        Node function that takes AgentState and returns updated state
+    """
+    
+    def _run(state: AgentState) -> dict:
+        print("\n" + "="*60, flush=True)
+        print("[SYNTHESIS_AGENT] Node started", flush=True)
+        print("="*60, flush=True)
+        
+        payload = state.get("payload", {})
+        analysis_output = state.get("analysis_output", "")
+        
+        concern_name = payload.get("concern_name", "")
+        
+        print(f"[SYNTHESIS_AGENT] Concern: {concern_name}", flush=True)
+        print(f"[SYNTHESIS_AGENT] Analysis output length: {len(analysis_output)} chars", flush=True)
+        
+        # Check if we have an analysis to synthesize
+        if not analysis_output:
+            print("[SYNTHESIS_AGENT] WARNING: No analysis_output found in state", flush=True)
+            return {
+                "synthesis_output": "",
+                "agent_output": state.get("agent_output", {})
+            }
+        
+        # Build messages for synthesis
+        system_content = SYNTHESIS_SYSTEM_PROMPT.format(
+            concern_name=concern_name
+        )
+        
+        human_content = SYNTHESIS_HUMAN_PROMPT.format(
+            concern_name=concern_name,
+            analysis_output=analysis_output
+        )
+        
+        messages = [
+            SystemMessage(content=system_content),
+            HumanMessage(content=human_content)
+        ]
+        
+        # Invoke LLM (no tools needed for synthesis)
+        print(f"[SYNTHESIS_AGENT] Invoking LLM...", flush=True)
+        response = llm.invoke(messages)
+        print(f"[SYNTHESIS_AGENT] LLM response received", flush=True)
+        
+        # Extract usage metadata
+        usage_raw = extract_usage_metadata(response)
+        usage_normalized = normalize_usage(usage_raw)
+        
+        print(f"[SYNTHESIS_AGENT] Usage: {usage_normalized}", flush=True)
+        
+        synthesis_content = response.content
+        print(f"[SYNTHESIS_AGENT] Synthesis length: {len(synthesis_content)} chars", flush=True)
+        
+        # Create response message
+        response_message = AIMessage(
+            content=synthesis_content,
+            usage_metadata=usage_raw if usage_raw else None
+        )
+        
+        # Extract model name
+        model_name = _extract_model_name(llm)
+        
+        # Build updated agent_output with concatenated analysis + synthesis
+        current_agent_output = state.get("agent_output", {})
+        current_analysis = current_agent_output.get("analysis", analysis_output)
+        
+        # Concatenate analysis with synthesis
+        combined_analysis = f"{current_analysis}\n\n---\n\n## Synthèse\n\n{synthesis_content}"
+        
+        updated_agent_output: Dict[str, Any] = {
+            **current_agent_output,
+            "analysis": combined_analysis
+        }
+        
+        result = {
+            "messages": [response_message],
+            "synthesis_output": synthesis_content,
+            "analysis_output": combined_analysis,  # Update analysis_output with combined content
+            "agent_output": updated_agent_output,
+            "total_usage": usage_normalized,
+            "usage_by_model": {model_name: usage_normalized}
+        }
+        
+        print(f"[SYNTHESIS_AGENT] agent_output updated with synthesis", flush=True)
+        print(f"[SYNTHESIS_AGENT] Node completed", flush=True)
+        print("="*60 + "\n", flush=True)
+        
+        return result
+    
+    return _run
+

graphs/prompts/a3_prompts.py

@@ -245,3 +245,45 @@ ANALYSIS_HUMAN_PROMPT = """Identifiant du site : {id_site}
 {indicators_text}
 """
 
+
+# =============================================================================
+# SYNTHESIS PROMPTS
+# =============================================================================
+
+SYNTHESIS_SYSTEM_PROMPT = """# ROLE
+Tu es expert MERITHALLE dans la synthèse d'analyses d'indicateurs clients, spécialisé dans le domaine VITI en France.
+
+# CONTEXTE
+Tu viens de recevoir une analyse détaillée de l'enjeu "{concern_name}" pour un site viticole. Cette analyse contient des observations, des comparaisons N vs N-1, et potentiellement des recommandations.
+
+# OBJECTIF
+Ton objectif est de produire une **synthèse exécutive** concise de l'analyse, permettant une lecture rapide des points clés.
+
+# RÈGLES DE SYNTHÈSE
+
+1. **Concision** : La synthèse doit faire entre 300 et 500 caractères maximum.
+
+2. **Structure** : Organise la synthèse en 3 points clés maximum :
+   - **Tendance principale** : L'évolution globale (amélioration, stabilité, dégradation)
+   - **Points d'attention** : 1-2 éléments critiques à surveiller (si pertinent)
+   - **Données manquantes** : Signaler uniquement si des N/F importants ont été identifiés
+
+3. **Neutralité** : Ne pas répéter l'analyse, mais en extraire l'essentiel.
+
+4. **Format** : 
+   - Pas de titre
+   - Style télégraphique accepté
+   - Utiliser des indicateurs visuels si pertinent (↑ ↓ → pour les tendances)
+
+# SORTIE
+La synthèse doit être en texte brut ou Markdown léger, directement utilisable comme résumé exécutif.
+Ne pas mentionner l'ID du site."""
+
+
+SYNTHESIS_HUMAN_PROMPT = """## Analyse complète de l'enjeu "{concern_name}" :
+
+{analysis_output}
+
+---
+
+Produis maintenant la synthèse exécutive de cette analyse."""

graphs/state.py

@@ -74,3 +74,4 @@ class AgentState(TypedDict, total=False):
     # Intermediate data for multi-node workflows (agent-specific)
     coherence_output: str
     analysis_output: str
+    synthesis_output: str

graphs/workflows/agent_a3.py

@@ -10,35 +10,41 @@ from graphs.tools.batch_calculator import batch_calculator
 from graphs.tools.indicators import get_site_indicators
 from graphs.tools.itineraires import get_itineraires
 from graphs.nodes.analysis_node import create_analysis_node, should_continue_analysis
+from graphs.nodes.synthesis_node import create_synthesis_node
 
 
 def get_agent_a3(
     llm: BaseChatModel,
-    analysis_llm: Optional[BaseChatModel] = None
+    analysis_llm: Optional[BaseChatModel] = None,
+    synthesis_llm: Optional[BaseChatModel] = None
 ):
     """
     Create the A3 workflow - Analyse.
     
-    This workflow consists of one main node:
+    This workflow consists of two main nodes:
     1. AnalysisAgent: Analyzes indicator data for year N against N-1 context and analysis
+    2. SynthesisAgent: Generates an executive summary of the analysis
     
     The workflow also includes a tool executor for the batch_calculator tool.
     
     Flow:
-        analysis_agent -> (tool_executor)* -> END
+        analysis_agent -> (tool_executor)* -> synthesis_agent -> END
         
     Args:
-        llm: Default LLM (used for AnalysisAgent if analysis_llm not provided)
+        llm: Default LLM (used for all nodes if specific LLMs not provided)
         analysis_llm: Optional specific LLM for AnalysisAgent.
                       If not provided, uses the default llm.
+        synthesis_llm: Optional specific LLM for SynthesisAgent.
+                       If not provided, uses the default llm.
                       
     Returns:
         Compiled LangGraph workflow
     """
     workflow = StateGraph(AgentState)
     
-    # Use specific LLM for analysis if provided, otherwise use default
+    # Use specific LLMs if provided, otherwise use default
     analysis_model = analysis_llm or llm
+    synthesis_model = synthesis_llm or llm
     
     # Define tools
     tools = [batch_calculator, get_site_indicators, get_itineraires]
@@ -46,26 +52,32 @@ def get_agent_a3(
     # Create nodes
     analysis_node = create_analysis_node(analysis_model, tools)
     tool_node = ToolNode(tools)
+    synthesis_node = create_synthesis_node(synthesis_model)
     
     # Add nodes to workflow
     workflow.add_node("analysis_agent", analysis_node)
     workflow.add_node("tool_executor", tool_node)
+    workflow.add_node("synthesis_agent", synthesis_node)
     
     # Set entry point
     workflow.set_entry_point("analysis_agent")
     
     # Add conditional edges for tool execution loop
+    # When analysis is done (no more tool calls), go to synthesis
     workflow.add_conditional_edges(
         "analysis_agent",
         should_continue_analysis,
         {
             "tool_executor": "tool_executor",
-            "end": END
+            "end": "synthesis_agent"  # Go to synthesis instead of END
         }
     )
     
     # Tool executor goes back to analysis agent to process results
     workflow.add_edge("tool_executor", "analysis_agent")
     
+    # Synthesis agent goes to END
+    workflow.add_edge("synthesis_agent", END)
+    
     return workflow.compile()
 

services/agent_service.py

@@ -68,10 +68,13 @@ class AgentService:
         # Handle agent-specific LLM configurations
         coherence_llm = self._get_coherence_llm(payload_dict, temperature, max_tokens)
         analysis_llm = self._get_analysis_llm(payload_dict, temperature, max_tokens)
+        synthesis_llm = self._get_synthesis_llm(payload_dict, temperature, max_tokens)
         if coherence_llm:
             print(f"[AGENT_SERVICE] Using specific coherence_model: {payload_dict.get('coherence_model')}", flush=True)
         if analysis_llm:
             print(f"[AGENT_SERVICE] Using specific analysis_model: {payload_dict.get('analysis_model')}", flush=True)
+        if synthesis_llm:
+            print(f"[AGENT_SERVICE] Using specific synthesis_model: {payload_dict.get('synthesis_model')}", flush=True)
         
         # Get agent builder and create graph with appropriate LLMs
         builder = agent_registry.get_builder(agent_type)
@@ -79,8 +82,14 @@ class AgentService:
         # Pass specific LLMs if the agent supports them
         if agent_type == AgentType.A2 and coherence_llm:
             graph = builder(llm, coherence_llm=coherence_llm)
-        elif agent_type == AgentType.A3 and analysis_llm:
-            graph = builder(llm, analysis_llm=analysis_llm)
+        elif agent_type == AgentType.A3:
+            # A3 supports both analysis_llm and synthesis_llm
+            kwargs = {}
+            if analysis_llm:
+                kwargs["analysis_llm"] = analysis_llm
+            if synthesis_llm:
+                kwargs["synthesis_llm"] = synthesis_llm
+            graph = builder(llm, **kwargs) if kwargs else builder(llm)
         else:
             graph = builder(llm)
         
@@ -211,10 +220,13 @@ class AgentService:
         # Handle agent-specific LLM configurations
         coherence_llm = self._get_coherence_llm(payload_dict, temperature, max_tokens, streaming=True)
         analysis_llm = self._get_analysis_llm(payload_dict, temperature, max_tokens, streaming=True)
+        synthesis_llm = self._get_synthesis_llm(payload_dict, temperature, max_tokens, streaming=True)
         if coherence_llm:
             print(f"[AGENT_SERVICE] Using specific coherence_model: {payload_dict.get('coherence_model')}")
         if analysis_llm:
             print(f"[AGENT_SERVICE] Using specific analysis_model: {payload_dict.get('analysis_model')}")
+        if synthesis_llm:
+            print(f"[AGENT_SERVICE] Using specific synthesis_model: {payload_dict.get('synthesis_model')}")
         
         # Get agent builder and create graph with appropriate LLMs
         builder = agent_registry.get_builder(agent_type)
@@ -222,8 +234,14 @@ class AgentService:
         # Pass specific LLMs if the agent supports them
         if agent_type == AgentType.A2 and coherence_llm:
             graph = builder(llm, coherence_llm=coherence_llm)
-        elif agent_type == AgentType.A3 and analysis_llm:
-            graph = builder(llm, analysis_llm=analysis_llm)
+        elif agent_type == AgentType.A3:
+            # A3 supports both analysis_llm and synthesis_llm
+            kwargs = {}
+            if analysis_llm:
+                kwargs["analysis_llm"] = analysis_llm
+            if synthesis_llm:
+                kwargs["synthesis_llm"] = synthesis_llm
+            graph = builder(llm, **kwargs) if kwargs else builder(llm)
         else:
             graph = builder(llm)
         
@@ -459,6 +477,41 @@ class AgentService:
             # Invalid model name, return None to use default
             return None
     
+    def _get_synthesis_llm(
+        self,
+        payload_dict: Dict[str, Any],
+        temperature: float,
+        max_tokens: Optional[int],
+        streaming: bool = False
+    ) -> Optional[BaseChatModel]:
+        """
+        Get a specific LLM for the SynthesisAgent if specified in payload.
+        
+        Args:
+            payload_dict: Payload dictionary
+            temperature: Sampling temperature
+            max_tokens: Max tokens to generate
+            streaming: Whether to enable streaming
+            
+        Returns:
+            LLM instance if synthesis_model is specified, None otherwise
+        """
+        synthesis_model_str = payload_dict.get("synthesis_model")
+        if not synthesis_model_str:
+            return None
+        
+        try:
+            synthesis_model_name = ModelName(synthesis_model_str)
+            return llm_service.get_llm(
+                model_name=synthesis_model_name,
+                temperature=temperature,
+                streaming=streaming,
+                max_tokens=max_tokens
+            )
+        except ValueError:
+            # Invalid model name, return None to use default
+            return None
+    
     def _prepare_messages_from_payload(
         self,
         payload: Dict[str, Any]