Implement V2 workflow for agent orchestration, including new chat tools agent with retrieval capabilities, classifier node enhancements, and summarizer integration. Add detailed documentation for V2 features and prompts, ensuring improved agent interaction and context handling.

docs/AGENT_V2.md

@@ -0,0 +1,225 @@
+# Agent orchestré V2 — Documentation
+
+Ce document décrit le fonctionnement du workflow **V2** : état partagé, prompts Markdown, nœuds d’agents, outils de retrieval, graphe LangGraph, ainsi que l’intégration via le **service d’agents** et le **registry**.
+
+---
+
+## Vue d’ensemble
+
+Le V2 est un graphe LangGraph à **quatre nœuds**, avec un **classificateur** en entrée qui route soit vers un **agent conversationnel avec tools** (recherche sémantique), soit vers une **chaîne de synthèse** (Markdown puis export PDF).
+
+Objectifs principaux par rapport à une approche RAG « tout injecté » :
+
+- Le modèle **décide quand** appeler les retrieveurs (formations, prestations, documents projet).
+- Les prompts métier CAPL sont **versionnés en fichiers** sous `graphs/prompts_v2/`.
+- La branche **SUMMARIZE** produit une synthèse structurée puis un **PDF** (upload optionnel).
+
+Fichier d’entrée du graphe : `graphs/workflows/orchestrated_v2.py` (`create_orchestrated_graph_v2`).
+
+---
+
+## État partagé (`AgentState`)
+
+Le type `AgentState` (`graphs/state.py`) est un `TypedDict` partiellement optionnel : chaque nœud n’écrit que les clés dont il a besoin ; LangGraph fusionne les mises à jour (notamment `messages` via `add_messages`).
+
+Champs utiles pour le V2 :
+
+| Clé | Rôle |
+|-----|------|
+| `messages` | Historique conversationnel (LangChain `BaseMessage`). |
+| `query` | Requête textuelle explicite (souvent le dernier message utilisateur). |
+| `project_id` | Identifiant projet pour `search_project_docs` et messages système contextuels. |
+| `documents` | Liste de dictionnaires (métadonnées « sources ») agrégées lors des appels tools, exploitées côté streaming API. |
+| `classification` | Instance Pydantic `QueryClassification` (sortie du classificateur). |
+| `summary_markdown` | Contenu Markdown produit par le nœud summarizer LLM. |
+| `summary_pdf_path` | Chemin local ou URL après export / upload. |
+
+Les champs historiques RAG (`formation_docs`, `prestation_context`, etc.) restent dans le schéma pour compatibilité avec d’autres workflows ; le V2 s’appuie surtout sur les **tools** et sur `documents` pour la traçabilité côté client.
+
+---
+
+## Workflow LangGraph
+
+### Schéma logique
+
+```mermaid
+flowchart TD
+    START([Entrée]) --> classify[classify]
+    classify -->|CLASSIC| tools_agent[tools_agent]
+    classify -->|SUMMARIZE| summarizer_llm[summarizer_llm]
+    classify -->|UNKNOWN| tools_agent
+    tools_agent --> END1([END])
+    summarizer_llm --> summarizer_export[summarizer_export]
+    summarizer_export --> END2([END])
+```
+
+### Nœuds
+
+1. **`classify`** — Appelle le LLM avec sortie structurée (`QueryClassification`) pour choisir la branche.
+2. **`tools_agent`** — Agent chat avec **bind_tools** : boucle invoke → éventuels `ToolMessage` → réponse finale sans tool calls (ou limite d’appels atteinte).
+3. **`summarizer_llm`** — Génère le Markdown de synthèse à partir de l’historique + prompt système V2.
+4. **`summarizer_export`** — Convertit le Markdown en PDF, écrit un fichier local, tente un upload ; ajoute un `AIMessage` avec métadonnées document (lien, type, horodatage).
+
+### Routage conditionnel
+
+La fonction de routage lit `state["classification"].classification` et mappe :
+
+- `CLASSIC` → `tools_agent`
+- `SUMMARIZE` → `summarizer_llm`
+- `UNKNOWN` → `tools_agent` (comportement prudent : même pipeline que le conseil classique)
+
+Référence : `graphs/workflows/orchestrated_v2.py` (`add_conditional_edges` sur `"classify"`).
+
+### Compilation et checkpointer
+
+`create_orchestrated_graph_v2(llm, checkpointer=None)` :
+
+- Charge les prompts V2 (voir section suivante).
+- Substitute `{{TODAY_DATE}}` dans le prompt chat (date du jour `JJ/MM/AAAA`).
+- Passe des **factories** de nœuds (`classifier_node`, `chat_with_tools_node`, etc.) à `_build_v2_workflow`.
+- Retourne `workflow.compile(checkpointer=checkpointer)`.
+
+Les imports `markdown_to_pdf` et `upload_pdf_to_supabase` sont **lazy** dans la factory pour éviter de charger des dépendances PDF quand ce n’est pas nécessaire (ex. notebooks).
+
+---
+
+## Prompts V2
+
+### Chargement
+
+- Module : `graphs/prompts_v2/loader.py`
+- Fonction : `load_v2_prompt(filename: str) -> str` (lecture UTF-8, mise en cache `lru_cache`).
+- Répertoire : `graphs/prompts_v2/`
+
+### Fichiers et rôles
+
+| Fichier | Injecté dans | Rôle |
+|---------|----------------|------|
+| `classifier_system.md` | Nœud **classify** | Consigne de classification CLASSIC / SUMMARIZE / UNKNOWN + justification courte. |
+| `chat_system.md` | Nœud **tools_agent** (1er `SystemMessage`) | Identité CAPL Pays de la Loire, objectifs win-win, usage catalogues, contraintes (pas d’invention, citations, dates formations, questions de clarification). Placeholder `{{TODAY_DATE}}` remplacé à la compilation du graphe. |
+| `tools_policy.md` | Nœud **tools_agent** (2e `SystemMessage`) | Règles d’usage des tools, priorité `search_project_docs` si `project_id`, limitation des appels redondants. |
+| `summarizer_system.md` | Nœud **summarizer_llm** | Structure Markdown attendue de la synthèse (# Titre, ## Contexte, etc.). |
+
+### Contexte système additionnel (projet)
+
+Si `project_id` est présent dans l’état, `chat_with_tools_agent` ajoute un **troisième** `SystemMessage` : rappel que l’ID est fourni par l’application, interdiction de le demander à l’utilisateur, priorité à `search_project_docs`, et possibilité d’omettre `project_id` dans les arguments de l’outil (injection serveur).
+
+---
+
+## Agents (nœuds)
+
+### Classificateur — `graphs/agents/classifier_agent.py`
+
+- Construit une chaîne `ChatPromptTemplate` → `llm.with_structured_output(QueryClassification)`.
+- Entrées modèle : historique `{messages}` et `{query}`.
+- Résolution de la question : `state["query"]` si non vide, sinon dernier message `human` dans l’historique.
+- En cas d’exception sur l’invoke : classification `UNKNOWN` avec `reasoning` = message d’erreur.
+
+Modèle Pydantic : `graphs/models.py` — `QueryClassification` avec `classification: Literal["CLASSIC","SUMMARIZE","UNKNOWN"]` et `reasoning: str`.
+
+### Agent chat + tools — `graphs/agents/chat_tools_agent.py`
+
+- **Tools** : `search_formations`, `search_prestations`, `search_project_docs` (`graphs/tools/retrieval_tools.py`).
+- `llm.bind_tools(tools)` ; boucle jusqu’à absence de `tool_calls` ou jusqu’à `max_tool_calls_per_turn` (défaut : 3).
+- Pour `search_project_docs`, fusion des args : `tool_args.setdefault("project_id", project_id)` si le modèle ne le passe pas.
+- Résultats d’outil sérialisés en JSON dans des `ToolMessage`.
+- Extraction des **sources** : si le dict retourné par un tool contient une clé `sources` (liste), les éléments sont ajoutés à `state["documents"]` pour l’API (streaming).
+- **Sortie** : `messages` = historique initial **+** dernier `AIMessage` uniquement (pas tout le détail des tours tools dans l’historique persisté du graphe pour ce nœud), plus `documents` et `query`.
+
+### Summarizer — `graphs/agents/summarizer_agent.py`
+
+- **`summarizer_llm_node`** : `[SystemMessage(prompt)] + messages` → réponse LLM ; remplit `summary_markdown` et append un `AIMessage` avec le Markdown.
+- **`summarizer_export_node`** : lit `summary_markdown`, appelle `markdown_to_pdf`, écrit sous `tmp_summaries/`, tente `upload_pdf` ; met à jour `summary_pdf_path` et append un `AIMessage` final avec `metadata["document"]` (lien, nom de fichier, type, date).
+
+---
+
+## Tools de retrieval
+
+Définis dans `graphs/tools/retrieval_tools.py` :
+
+| Tool | Index / filtre | Retour typique |
+|------|----------------|----------------|
+| `search_formations` | `get_retriever("formation", k=...)` | `items`, `context`, `sources`, `count` |
+| `search_prestations` | `get_retriever("prestation", k=...)` | idem |
+| `search_project_docs` | `get_retriever_for("projects", filter={"project_id": ...})` | idem ; si `project_id` manquant, retour avec `error` |
+
+Le paramètre `k` est borné entre 1 et 8. Les documents sont sérialisés avec texte, source, page, type, contact, etc.
+
+---
+
+## Apparté : service d’agents et registry
+
+### Rôle du registry — `services/agent_registry.py`
+
+`AgentRegistry` maintient :
+
+- `_agent_builders` : `dict[str, Callable]` — identifiant **normalisé en minuscules** → fonction qui construit le graphe compilé à partir d’un `BaseChatModel` (et optionnellement d’un checkpointer pour V2).
+- `_descriptions` : texte exposé aux clients via l’API.
+
+Agents enregistrés par défaut :
+
+- `v1` → `create_orchestrated_graph` (`graphs/workflows/orchestrated.py`)
+- `v2` → `create_orchestrated_graph_v2` (`graphs/workflows/orchestrated_v2.py`)
+
+Méthodes importantes :
+
+- **`register_agent(agent, builder, description="")`** — Enregistre ou remplace un builder (`agent` est strip + lower).
+- **`get_builder_for_request(agent=None)`** — Si `agent` est absent, équivalent à `"V2"`. Clé = `agent.strip().lower()`. Lève `ValueError` si l’id est inconnu.
+- **`resolve_agent_id(agent=None)`** — Retourne l’identifiant **canonique** pour les métadonnées API : `(agent or "V2").strip().upper()` (ex. `V2`, `V1`).
+- **`list_agents()`** — Liste triée des agents avec `type`, `name`, `description`, `available`.
+
+Singleton exporté : `agent_registry`.
+
+### Rôle du service — `services/agent_service.py`
+
+`AgentService` fait le lien entre la couche HTTP (ou voice) et LangGraph :
+
+1. Instancie le LLM via `llm_service.get_llm(...)` (streaming ou non).
+2. **`resolved_agent = agent_registry.resolve_agent_id(agent)`** puis **`builder = agent_registry.get_builder_for_request(agent=resolved_agent)`**  
+   — Remarque : `get_builder_for_request` re-normalise en minuscules, donc `V2` et `v2` sont équivalents.
+3. **Mémoire serveur** : si `conversation_id` est fourni, le graphe est compilé avec `MemorySaver` partagé (`_text_checkpointer`) et `config = {"configurable": {"thread_id": conversation_id}}` ; le message courant est seulement un `HumanMessage` (l’historique est repris du checkpointer). Sinon, historique client reconstruit via `_prepare_messages`.
+4. État initial typique : `{"messages": ..., "query": message, "project_id": project_id}`.
+5. Post-traitement : `normalize_usage`, `RunContext`, orchestrateur de post-processing (`build_orchestrator().run(ctx)`), enrichissement de `metadata`.
+
+**Streaming** (`stream`) : modes `["messages", "updates"]` ; agrégation des documents depuis les updates `tools_agent` / métadonnées du dernier message ; chunks texte issus des `AIMessageChunk` uniquement ; chunk final avec usage, latence et métadonnées.
+
+Instance singleton : `agent_service`.
+
+### Exposition HTTP
+
+- Les routes de completion utilisent `agent_service.invoke` / `agent_service.stream` avec le paramètre `agent` (optionnel, défaut implicite V2 côté registry).
+- **`GET /agents`** (`api/routes/models.py`) appelle `agent_registry.list_agents()` pour lister les types enregistrés.
+
+### Voice
+
+`services/voice/voice_agent_service.py` peut cibler explicitement un graphe (ex. `get_builder_for_request("V1")`) selon le pipeline vocal — à distinguer du chemin texte qui suit le paramètre `agent` / défaut V2.
+
+### Ajouter un agent V3 (rappel procédural)
+
+1. Implémenter `create_orchestrated_graph_v3(llm, checkpointer=None)` (ou signature alignée sur le service).
+2. `agent_registry.register_agent("v3", create_orchestrated_graph_v3, description="...")` ou modifier `AgentRegistry.__init__`.
+3. Aucune modification obligatoire des routes si le client passe `agent=v3` et que le builder est enregistré.
+
+---
+
+## Fichiers clés (référence rapide)
+
+| Chemin | Contenu |
+|--------|---------|
+| `graphs/workflows/orchestrated_v2.py` | Construction du graphe V2 et câblage des prompts |
+| `graphs/state.py` | `AgentState` |
+| `graphs/models.py` | `QueryClassification` |
+| `graphs/agents/classifier_agent.py` | Nœud classify |
+| `graphs/agents/chat_tools_agent.py` | Nœud tools_agent |
+| `graphs/agents/summarizer_agent.py` | Nœuds summarizer |
+| `graphs/tools/retrieval_tools.py` | Définitions `@tool` |
+| `graphs/prompts_v2/*.md` | Prompts éditables |
+| `graphs/prompts_v2/loader.py` | Chargement + cache |
+| `services/agent_registry.py` | Registre des graphes |
+| `services/agent_service.py` | Invocation, streaming, mémoire, métadonnées |
+
+---
+
+## Résumé
+
+Le **V2** combine un **router LLM structuré**, un **agent autonome sur les outils de retrieval** (avec politique projet et plafond d’appels), et une **branche synthèse PDF**. Les instructions métier sont externalisées dans **`graphs/prompts_v2/`**. L’**`AgentRegistry`** sélectionne le builder ; l’**`AgentService`** fournit LLM, checkpointer optionnel, état initial et post-traitement uniformes pour l’API.

graphs/agents/chat_tools_agent.py

@@ -0,0 +1,138 @@
+"""V2 chat node with tool-calling retrieval autonomy."""
+import json
+from typing import Any, Callable, Dict, List
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import AIMessage, BaseMessage, SystemMessage, ToolMessage
+
+from graphs.prompts import SYSTEM_PROMPT_TEMPLATE
+from graphs.state import AgentState
+from graphs.tools.retrieval_tools import (
+    search_formations,
+    search_prestations,
+    search_project_docs,
+)
+
+
+def chat_with_tools_node(
+    llm: BaseChatModel,
+    max_tool_calls_per_turn: int = 3,
+    base_system_prompt: str = SYSTEM_PROMPT_TEMPLATE,
+    tools_policy_prompt: str = (
+        "Tu peux utiliser des tools pour recuperer des documents. "
+        "Utilise-les uniquement si necessaire. "
+        "Tools disponibles: search_formations, search_prestations, search_project_docs. "
+        "Si project_id n'est pas disponible, n'utilise pas search_project_docs. "
+        "Reponds avec des recommandations sourcees quand des resultats tools sont utilises."
+    ),
+) -> Callable[[AgentState], AgentState]:
+    """Factory returning a node that lets the model call retrieval tools.
+
+    Tools available:
+    - search_formations
+    - search_prestations
+    - search_project_docs (requires project_id)
+    """
+    tools = [search_formations, search_prestations, search_project_docs]
+    llm_with_tools = llm.bind_tools(tools)
+    tool_by_name = {t.name: t for t in tools}
+
+    def _extract_query(state: AgentState) -> str:
+        q = (state.get("query") or "").strip()
+        if q:
+            return q
+        for msg in reversed(list(state.get("messages", []))):
+            if getattr(msg, "type", "") == "human":
+                return (getattr(msg, "content", "") or "").strip()
+        return ""
+
+    def _run(state: AgentState) -> AgentState:
+        history = list(state.get("messages", []))
+        query = _extract_query(state)
+        project_id = state.get("project_id")
+
+        system_msgs: List[BaseMessage] = [
+            SystemMessage(content=base_system_prompt),
+            SystemMessage(content=tools_policy_prompt),
+        ]
+        if project_id:
+            system_msgs.append(
+                SystemMessage(
+                    content=(
+                        "CONTEXTE SYSTEME - Projet lie a la requete:\n"
+                        f"project_id={project_id}\n\n"
+                        "Ce project_id est deja fourni par l'application. "
+                        "Ne demande JAMAIS a l'utilisateur de le communiquer. "
+                        "Pour toute question sur l'exploitant, le contexte ou les echanges enregistres, "
+                        "utilise en priorite l'outil search_project_docs. "
+                        "Tu peux omettre project_id dans les arguments de l'outil : "
+                        "le serveur l'injecte automatiquement depuis ce contexte."
+                    )
+                )
+            )
+
+        conversation: List[BaseMessage] = system_msgs + history
+        collected_documents: List[Dict[str, Any]] = list(state.get("documents", []))  # type: ignore[arg-type]
+
+        tool_calls_count = 0
+        last_ai: AIMessage
+        while True:
+            ai = llm_with_tools.invoke(conversation)
+            if not isinstance(ai, AIMessage):
+                ai = AIMessage(content=getattr(ai, "content", "") or "")
+            conversation.append(ai)
+            last_ai = ai
+
+            tool_calls = getattr(ai, "tool_calls", None) or []
+            if not tool_calls:
+                break
+            if tool_calls_count >= max_tool_calls_per_turn:
+                break
+
+            for call in tool_calls:
+                if tool_calls_count >= max_tool_calls_per_turn:
+                    break
+                tool_name = call.get("name")
+                tool_args = call.get("args") or {}
+                tool_id = call.get("id") or f"tool_{tool_calls_count}"
+
+                if tool_name not in tool_by_name:
+                    tool_result: Dict[str, Any] = {
+                        "error": f"Unknown tool: {tool_name}",
+                        "tool": tool_name,
+                    }
+                else:
+                    # Inject project_id for project tool when omitted.
+                    if tool_name == "search_project_docs":
+                        tool_args = dict(tool_args)
+                        tool_args.setdefault("project_id", project_id)
+                    try:
+                        tool_result = tool_by_name[tool_name].invoke(tool_args)  # type: ignore[assignment]
+                    except Exception as exc:
+                        tool_result = {"error": str(exc), "tool": tool_name}
+
+                # Keep a compact document trace for API streaming metadata.
+                try:
+                    if isinstance(tool_result, dict):
+                        sources = tool_result.get("sources")
+                        if isinstance(sources, list):
+                            collected_documents.extend(sources)
+                except Exception:
+                    pass
+
+                conversation.append(
+                    ToolMessage(
+                        content=json.dumps(tool_result, ensure_ascii=False),
+                        tool_call_id=tool_id,
+                    )
+                )
+                tool_calls_count += 1
+
+        return {
+            "messages": history + [last_ai],
+            "documents": collected_documents,
+            "query": query,
+        }
+
+    return _run
+

graphs/agents/classifier_agent.py

@@ -9,12 +9,15 @@ from graphs.models import QueryClassification
 from graphs.prompts import CLASSIFIER_SYSTEM_PROMPT
 
 
-def classifier_node(llm: BaseChatModel) -> Callable[[AgentState], AgentState]:
+def classifier_node(
+    llm: BaseChatModel,
+    system_prompt: str = CLASSIFIER_SYSTEM_PROMPT,
+) -> Callable[[AgentState], AgentState]:
     print("Classifier node")
 
     prompt = ChatPromptTemplate.from_messages(
         [
-            ("system", CLASSIFIER_SYSTEM_PROMPT),
+            ("system", system_prompt),
             (
                 "human",
                 "Historique: {messages}\nQuestion: {query}",

graphs/agents/summarizer_agent.py

@@ -15,6 +15,7 @@ from langchain_core.messages import BaseMessage, SystemMessage, AIMessage
 
 def summarizer_llm_node(
     llm: BaseChatModel,
+    system_prompt: str = SUMMARIZER_SYSTEM_PROMPT,
 ):
     """Node: ask the LLM to generate a Markdown summary from the conversation/context.
 
@@ -25,7 +26,7 @@ def summarizer_llm_node(
     def _run(state: AgentState) -> AgentState:
         messages = list(state.get("messages", []))
 
-        sys = SystemMessage(content=SUMMARIZER_SYSTEM_PROMPT)
+        sys = SystemMessage(content=system_prompt)
         response = llm.invoke([sys] + messages)
         summary_markdown = response.content or ""
 

graphs/prompts_v2/__init__.py

@@ -0,0 +1,5 @@
+"""V2 prompts package."""
+from .loader import load_v2_prompt
+
+__all__ = ["load_v2_prompt"]
+

graphs/prompts_v2/chat_system.md

@@ -0,0 +1,42 @@
+CONTEXTE:
+Tu es l'assistant IA des conseillers agricoles de la Chambre d'Agriculture des Pays de la Loire.
+Date du jour: {{TODAY_DATE}}
+
+OBJECTIFS:
+Tu aides les conseillers agricoles a apporter le meilleur conseil pour aider l'agriculteur a atteindre ses objectifs tout en developpant la vente de prestations et formations de la Chambre d'Agriculture des Pays de la Loire.
+
+RESSOURCES : 
+Tu disposes de deux catalogues qui sont les sources uniques que tu dois utiliser.
+- Catalogue SERVICE 2024 2025 : Contient tous les services que tu peux proposer pour atteindre les objectifs
+- Catalogue FORMATION 2025 2026 : Contient toutes les formations que tu peux proposer pour atteindre les objectifs
+Tu peux accéder à ces ressources via les tools : 'search_formations' et 'search_prestations'
+
+CONTEXTE PROJET:
+Quand un projet est lié à la conversation (project_id disponible), les documents projet peuvent contenir:
+- des informations sur l'agriculteur/exploitant et son contexte,
+- des transcriptions d'echanges entre le conseiller et l'agriculteur/exploitant.
+Ces informations sont prioritaires pour comprendre la situation réelle avant de recommander des prestations/formations.
+
+TACHES : 
+1.Tu dois veiller à avoir suffisamment d'informations dans la conversation afin de prescrire le meilleur couple win – win entre objectifs de l'agriculteur et prestations formations de la Chambre d'Agriculture des Pays de la Loire
+2.Tu dois proposer ensuite proposer la liste des services et formations pertinentes pour le contexte que tu auras validé
+
+
+CONTRAINTES:
+- N'invente rien.
+- Tu dois t'appuyer en priorite sur les resultats des tools quand ils sont utilises.
+- Si project_id est disponible, commence par exploiter search_project_docs pour recuperer le contexte projet.
+- Utilise ensuite search_formations et search_prestations pour completer les recommandations selon le contexte projet.
+- Tu organises la liste des recommandations de prestations et de formations selon un ordre logique.
+- Cite la source et la page quand l'information provient des documents recuperes.
+- Reste professionnel, concis et actionnable.
+- Concernant les formations, tu contrôles que les dates des formations proposées sont postérieures à la date du jour. Si oui tu affiches alors la ou les dates, si non tu affiches un libellé « Contacter le service formation pour connaître la prochaine date »
+- Si les informations sont insuffisantes, pose des questions de clarification.
+
+
+FORMAT: 
+Présente les résultats sous forme de deux listes :
+- Rappel des enjeux, besoins, ou problématique de l'agriculteur/exploitant
+- Liste des prestations de services pertinentes avec mention du nom de la prestation, de la page exacte dans le catalogue de services, et le nom et téléphone du contact associé au service.
+- Liste des formations pertinentes avec mention de nom de la formation, son contenu si présent, les dates à venir avec les lieux, le nom et téléphone du contact/service associé à la formation.
+- Propose selon le contexte trois questions pertinentes pour aider le conseiller à maitriser les arguments de la vente

graphs/prompts_v2/classifier_system.md

@@ -0,0 +1,15 @@
+ROLE:
+Tu es un classificateur pour le workflow V2.
+
+TACHE:
+Determiner si la demande utilisateur releve de:
+- CLASSIC: conversation/conseil/recommandations standard
+- SUMMARIZE: demande de synthese, resume, impression/export de synthese
+- UNKNOWN: ambigu ou hors-sujet
+
+SORTIE:
+Retourne strictement une classification parmi : CLASSIC, SUMMARIZE ou UNKNOWN
+et une justification courte.
+
+CONTEXTE:
+Prends en compte l'historique complet et le dernier message utilisateur.

graphs/prompts_v2/loader.py

@@ -0,0 +1,15 @@
+"""Prompt loader for V2 markdown prompts."""
+from functools import lru_cache
+from pathlib import Path
+
+
+_PROMPTS_DIR = Path(__file__).resolve().parent
+
+
+@lru_cache(maxsize=16)
+def load_v2_prompt(filename: str) -> str:
+    path = _PROMPTS_DIR / filename
+    if not path.exists():
+        raise FileNotFoundError(f"V2 prompt file not found: {path}")
+    return path.read_text(encoding="utf-8").strip()
+

graphs/prompts_v2/summarizer_system.md

@@ -0,0 +1,19 @@
+ROLE:
+Tu es un agent de synthese V2.
+
+OBJECTIF:
+Produire une synthese claire et actionnable de la conversation en Markdown structure.
+
+FORMAT ATTENDU:
+- # Titre: Synthese de l'entretien
+- ## Contexte
+- ## Objectifs de l'agriculteur
+- ## Recommandations
+  - Prestations (nom, page, source, contact)
+  - Formations (nom, page, source, contact, prochaine date ou message par defaut)
+- ## Prochaines etapes
+
+CONTRAINTES:
+- N'invente rien.
+- Cite les pages et les sources quand disponibles.
+- Sois concis, professionnel et structure.

graphs/prompts_v2/tools_policy.md

@@ -0,0 +1,17 @@
+POLITIQUE TOOLS (V2):
+
+Tools disponibles:
+- search_formations(query, k)
+- search_prestations(query, k)
+- search_project_docs(query, project_id, k)
+
+Regles d'utilisation:
+- Les tools formations et prestations sont toujours disponibles.
+- Utilise search_project_docs seulement si project_id est disponible.
+- Si un message systeme indique deja un project_id, ne demande jamais ce project_id a l'utilisateur.
+- Si project_id est disponible, utilise search_project_docs en priorite pour etablir le contexte de l'agriculteur/exploitant.
+- Considere les transcriptions de conversation projet comme source de contexte metier prioritaire.
+- Apres recuperation du contexte projet, utilise search_formations/search_prestations pour proposer des recommandations adaptees.
+- N'appelle les tools que lorsque c'est utile pour repondre precisement.
+- Limite le nombre d'appels tools et evite les appels redondants.
+- Quand un tool retourne des sources, appuie ta reponse dessus.

graphs/state.py

@@ -1,5 +1,5 @@
 """Shared state types for LangGraph agents and workflows."""
-from typing import TypedDict, Annotated, Sequence, List, Optional
+from typing import TypedDict, Annotated, Sequence, List, Optional, Dict, Any
 from langchain_core.messages import BaseMessage
 from langgraph.graph.message import add_messages
 from langchain_core.documents import Document
@@ -25,6 +25,8 @@ class AgentState(TypedDict, total=False):
     prestation_context: str
     project_docs: List[Document]
     project_context: str
+    # Documents metadata collected from tool calls (stream/API compatibility)
+    documents: List[Dict[str, Any]]
     # Summarization artifacts
     summary_markdown: str
     summary_pdf_path: str  # local path or URL if uploaded

graphs/tools/__init__.py

@@ -0,0 +1,2 @@
+"""Tools package for graph-level callable tools."""
+

graphs/tools/retrieval_tools.py

@@ -0,0 +1,97 @@
+"""Retriever tools for V2 tool-calling agent."""
+from typing import Any, Dict, List, Optional
+
+from langchain_core.documents import Document
+from langchain_core.tools import tool
+
+from retrievers.supabase import format_documents, get_retriever, get_retriever_for
+
+
+def _clamp_k(k: int, default: int = 8, min_k: int = 1, max_k: int = 8) -> int:
+    try:
+        value = int(k)
+    except Exception:
+        value = default
+    return max(min_k, min(max_k, value))
+
+
+def _serialize_docs(docs: List[Document], max_items: int = 8) -> List[Dict[str, Any]]:
+    items: List[Dict[str, Any]] = []
+    for doc in docs[:max_items]:
+        meta = doc.metadata or {}
+        items.append(
+            {
+                "text": doc.page_content or "",
+                "source": meta.get("source"),
+                "page_number": meta.get("page_number"),
+                "type": meta.get("type"),
+                "contact": meta.get("contact"),
+                "metadata": meta,
+            }
+        )
+    return items
+
+
+@tool("search_formations")
+def search_formations(query: str, k: int = 8) -> Dict[str, Any]:
+    """Search formation catalogue documents by semantic similarity.
+
+    Use when user needs training recommendations or details.
+    """
+    top_k = _clamp_k(k)
+    retriever = get_retriever("formation", k=top_k)
+    docs = retriever.invoke(query or "")
+    return {
+        "tool": "search_formations",
+        "count": len(docs),
+        "items": _serialize_docs(docs, max_items=top_k),
+        "context": format_documents(docs, "formation"),
+        "sources": [d.metadata or {} for d in docs[:top_k]],
+    }
+
+
+@tool("search_prestations")
+def search_prestations(query: str, k: int = 8) -> Dict[str, Any]:
+    """Search service/prestation catalogue documents by semantic similarity.
+
+    Use when user needs service recommendations or details.
+    """
+    top_k = _clamp_k(k)
+    retriever = get_retriever("prestation", k=top_k)
+    docs = retriever.invoke(query or "")
+    return {
+        "tool": "search_prestations",
+        "count": len(docs),
+        "items": _serialize_docs(docs, max_items=top_k),
+        "context": format_documents(docs, "prestation"),
+        "sources": [d.metadata or {} for d in docs[:top_k]],
+    }
+
+
+@tool("search_project_docs")
+def search_project_docs(query: str, project_id: Optional[str], k: int = 8) -> Dict[str, Any]:
+    """Search project-scoped documents by semantic similarity.
+
+    Requires a valid project_id from the request context.
+    """
+    if not project_id:
+        return {
+            "tool": "search_project_docs",
+            "count": 0,
+            "items": [],
+            "context": "",
+            "sources": [],
+            "error": "project_id is required",
+        }
+
+    top_k = _clamp_k(k)
+    retriever = get_retriever_for("projects", k=top_k, filter={"project_id": project_id})
+    docs = retriever.invoke(query or "")
+    return {
+        "tool": "search_project_docs",
+        "count": len(docs),
+        "items": _serialize_docs(docs, max_items=top_k),
+        "context": format_documents(docs, "project"),
+        "sources": [d.metadata or {} for d in docs[:top_k]],
+    }
+

graphs/workflows/orchestrated_v2.py

@@ -1,41 +1,28 @@
-"""Orchestrated V2 workflow.
-
-V2 is intentionally isolated from V1 for safe incremental rollout.
-Current behavior mirrors V1 and can evolve independently.
-"""
+"""Orchestrated V2 workflow with tool-calling retrieval autonomy."""
+from datetime import datetime
 from langgraph.graph import StateGraph, END
 from langchain_core.language_models.chat_models import BaseChatModel
 
 from graphs.state import AgentState
 from graphs.agents.classifier_agent import classifier_node
-from graphs.nodes.retrieval import retrieve_catalogue, retrieve_projects
-from graphs.agents.chat_agent import chat_node
+from graphs.agents.chat_tools_agent import chat_with_tools_node
 from graphs.agents.summarizer_agent import summarizer_llm_node, summarizer_export_node
-from tools.pdf import markdown_to_pdf
-from tools.storage import upload_pdf_to_supabase
+from graphs.prompts_v2 import load_v2_prompt
+from typing import Callable
 
 
-def create_orchestrated_graph_v2(llm: BaseChatModel, checkpointer=None):
+def _build_v2_workflow(
+    classify_runner: Callable[[AgentState], AgentState],
+    tools_agent_runner: Callable[[AgentState], AgentState],
+    summarizer_llm_runner: Callable[[AgentState], AgentState],
+    summarizer_export_runner: Callable[[AgentState], AgentState],
+):
     workflow = StateGraph(AgentState)
 
-    workflow.add_node("classify", classifier_node(llm))
-    workflow.add_node("retrieve", retrieve_catalogue)
-
-    def _router_passthrough(state: AgentState) -> AgentState:
-        q = state.get("query") or ""
-        return {"query": q}
-
-    workflow.add_node("retrieve_router", _router_passthrough)
-    workflow.add_node("retrieve_project", retrieve_projects)
-    workflow.add_node("agent", chat_node(llm))
-    workflow.add_node("summarizer_llm", summarizer_llm_node(llm))
-    workflow.add_node(
-        "summarizer_export",
-        summarizer_export_node(
-            markdown_to_pdf=markdown_to_pdf,
-            upload_pdf=upload_pdf_to_supabase,
-        ),
-    )
+    workflow.add_node("classify", classify_runner)
+    workflow.add_node("tools_agent", tools_agent_runner)
+    workflow.add_node("summarizer_llm", summarizer_llm_runner)
+    workflow.add_node("summarizer_export", summarizer_export_runner)
 
     workflow.set_entry_point("classify")
 
@@ -43,27 +30,47 @@ def create_orchestrated_graph_v2(llm: BaseChatModel, checkpointer=None):
         "classify",
         lambda s: getattr(s.get("classification"), "classification", "CLASSIC"),
         {
-            "CLASSIC": "retrieve_router",
+            "CLASSIC": "tools_agent",
             "SUMMARIZE": "summarizer_llm",
-            "UNKNOWN": "retrieve_router",
+            "UNKNOWN": "tools_agent",
         },
     )
 
-    workflow.add_conditional_edges(
-        "retrieve_router",
-        lambda s: "PROJECT" if s.get("project_id") else "CLASSIC",
-        {
-            "PROJECT": "retrieve_project",
-            "CLASSIC": "retrieve",
-        },
-    )
-
-    workflow.add_edge("retrieve_project", "retrieve")
-    workflow.add_edge("retrieve", "agent")
-    workflow.add_edge("agent", END)
+    workflow.add_edge("tools_agent", END)
 
     workflow.add_edge("summarizer_llm", "summarizer_export")
     workflow.add_edge("summarizer_export", END)
+    return workflow
+
+
+def create_orchestrated_graph_v2(llm: BaseChatModel, checkpointer=None):
+    # Lazy imports keep module importable in notebook contexts that do not
+    # need runtime PDF generation dependencies.
+    from tools.pdf import markdown_to_pdf
+    from tools.storage import upload_pdf_to_supabase
+
+    chat_prompt_v2_template = load_v2_prompt("chat_system.md")
+    today_date = datetime.now().strftime("%d/%m/%Y")
+    chat_prompt_v2 = chat_prompt_v2_template.replace("{{TODAY_DATE}}", today_date)
+    tools_policy_v2 = load_v2_prompt("tools_policy.md")
+    classifier_prompt_v2 = load_v2_prompt("classifier_system.md")
+    summarizer_prompt_v2 = load_v2_prompt("summarizer_system.md")
 
+    workflow = _build_v2_workflow(
+        classify_runner=classifier_node(llm, system_prompt=classifier_prompt_v2),
+        tools_agent_runner=chat_with_tools_node(
+            llm,
+            base_system_prompt=chat_prompt_v2,
+            tools_policy_prompt=tools_policy_v2,
+        ),
+        summarizer_llm_runner=summarizer_llm_node(
+            llm,
+            system_prompt=summarizer_prompt_v2,
+        ),
+        summarizer_export_runner=summarizer_export_node(
+            markdown_to_pdf=markdown_to_pdf,
+            upload_pdf=upload_pdf_to_supabase,
+        ),
+    )
     return workflow.compile(checkpointer=checkpointer)
 

services/agent_service.py

@@ -216,6 +216,13 @@ class AgentService:
                     summarizer_export = node.get("summarizer_export")
                     if summarizer_export and isinstance(summarizer_export, dict):
                         messages = summarizer_export.get("messages", [])
+                    tools_agent = node.get("tools_agent")
+                    if tools_agent and isinstance(tools_agent, dict):
+                        tool_documents = tools_agent.get("documents", [])
+                        if isinstance(tool_documents, list):
+                            for doc in tool_documents:
+                                if doc is not None and doc not in documents:
+                                    documents.append(doc)
                 
                 # Get the latest message, if available, from the messages list
                 last_message = messages[-1] if messages else None

services/vectorstore_service.py

@@ -25,7 +25,23 @@ class VectorStoreServiceError(Exception):
 
 
 class PatchedSupabaseVectorStore(SupabaseVectorStore):
-    """Fixes postgrest 2.28+ incompatibility where .params moved to .request.params."""
+    """Compatibility patch across postgrest builder API variants."""
+
+    @staticmethod
+    def _set_query_param(query_builder: Any, key: str, value: Any) -> None:
+        """Set query params on both legacy and newer builder shapes."""
+        if hasattr(query_builder, "params"):
+            query_builder.params = query_builder.params.set(key, value)
+            return
+
+        request_obj = getattr(query_builder, "request", None)
+        if request_obj is not None and hasattr(request_obj, "params"):
+            request_obj.params = request_obj.params.set(key, value)
+            return
+
+        raise AttributeError(
+            f"Unsupported RPC query builder shape: {type(query_builder).__name__}"
+        )
 
     def similarity_search_by_vector_with_relevance_scores(
         self,
@@ -56,11 +72,9 @@ class PatchedSupabaseVectorStore(SupabaseVectorStore):
         # #endregion
 
         if postgrest_filter:
-            query_builder.request.params = query_builder.request.params.set(
-                "and", f"({postgrest_filter})"
-            )
+            self._set_query_param(query_builder, "and", f"({postgrest_filter})")
 
-        query_builder.request.params = query_builder.request.params.set("limit", k)
+        self._set_query_param(query_builder, "limit", k)
 
         res = query_builder.execute()