Upload 7 files

Mise en place du MCP

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+.venv
+.env
+__pycache__/
+*.pyc
+instance
+.pytest_cache/

README.md

@@ -1,12 +1,12 @@
----
-title: Hackathon Os Farm
-emoji: 🔥
-colorFrom: yellow
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.46.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Chatbot Hackathon
+emoji: 📈
+colorFrom: pink
+colorTo: yellow
+sdk: gradio
+sdk_version: 5.46.0
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,39 +1,371 @@
-import requests
-import gradio as gr
-
-def get_random_quote(lang='en', format='json'):
-    """
-    Fetches a random quote from the Forismatic API.
-
-    Args:
-        lang (str): Language code for the quote. Default is 'en'.
-        format (str): Response format. Default is 'json'.
-
-    Returns:
-        str: Formatted quote string with author.
-    """
-    url = "https://lexicon.osfarm.org/viticulture/vine-varieties.json"
-    params = {
-        'format': format
-    }
-
-    response = requests.get(url, params=params)
-    response.raise_for_status()
-    data = response.json()
-    
-    quote = data.get('quoteText', 'No quote available').strip()
-    author = data.get('quoteAuthor', 'Unknown').strip()
-    
-    return f'"{data}"'
-
-# Create Gradio interface
-app = gr.Interface(
-    fn=get_random_quote,
-    inputs=[],  # no input needed
-    outputs=gr.Textbox(label="Random Quote"),
-    title="Random Quote Generator",
-    description="Click the button to get an inspiring random quote."
-)
-
-if __name__ == "__main__":
-    app.launch(mcp_server=True, share=True)
+import asyncio
+import os
+from typing import List, Dict, Any, Optional
+from contextlib import AsyncExitStack
+
+import gradio as gr
+
+
+import asyncio, os
+from typing import List, Dict, Any, Optional
+import gradio as gr
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from anthropic import Anthropic
+from dotenv import load_dotenv
+from tool_utils import filter_tools_for_context, summarize_latest_results, count_tokens, trim_conversation
+
+load_dotenv()
+
+import os
+import re
+import asyncio
+import logging
+from typing import List, Dict, Any, Optional, Tuple
+from contextlib import AsyncExitStack
+from anthropic import Anthropic
+from mcp.client.session import ClientSession
+from mcp.client.stdio import stdio_client
+from mcp.client.stdio import StdioServerParameters
+
+# Logger configuré
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("MCPClient")
+
+MAX_HISTORY_MESSAGES = 5
+
+
+def retry_async(max_attempts: int = 3, delay: float = 1.0):
+    """Décorateur de retry pour fonctions async."""
+    def decorator(func):
+        async def wrapper(*args, **kwargs):
+            for attempt in range(1, max_attempts + 1):
+                try:
+                    return await func(*args, **kwargs)
+                except Exception as e:
+                    if attempt == max_attempts:
+                        raise
+                    logger.warning(f"Échec tentative {attempt}/{max_attempts} : {e}. Retry dans {delay}s...")
+                    await asyncio.sleep(delay)
+            # Ne devrait jamais arriver
+            raise RuntimeError("Retry loop exited unexpectedly")
+        return wrapper
+    return decorator
+
+
+class MCPClient:
+    """Client MCP robuste avec gestion de connexion et retries."""
+
+    def __init__(self):
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+        self.session: Optional[ClientSession] = None
+        self.tools: List[Dict[str, Any]] = []
+        self.connected: bool = False
+        self.max_iterations: int = 3
+        self.client: Optional[Anthropic] = None
+        self.exit_stack: Optional[AsyncExitStack] = None
+        self._init_client()
+
+    def _init_client(self):
+        key = os.getenv("ANTHROPIC_API_KEY")
+        if not key:
+            raise EnvironmentError("❌ ANTHROPIC_API_KEY manquant dans l'environnement")
+        self.client = Anthropic()
+
+    def connect(self) -> str:
+        """Connexion synchrone MCP (wrap async)."""
+        return self.loop.run_until_complete(self._connect())
+
+    @retry_async(max_attempts=3, delay=2)
+    async def _connect(self) -> str:
+        """Connexion asynchrone avec MCP via stdio."""
+        if self.exit_stack:
+            await self.exit_stack.aclose()
+
+        self.exit_stack = AsyncExitStack()
+
+        params = StdioServerParameters(
+            command="python",
+            args=["gradio_mcp_server.py"],
+            env={"PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"},
+        )
+
+        try:
+            stdio_transport = await self.exit_stack.enter_async_context(stdio_client(params))
+            self.stdio, self.write = stdio_transport
+            self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
+            await self.session.initialize()
+
+            resp = await self.session.list_tools()
+            self.tools = [
+                {"name": t.name, "description": t.description, "input_schema": t.inputSchema}
+                for t in resp.tools
+            ]
+
+            self.connected = True
+            return f"✅ MCP connecté ({len(self.tools)} outils disponibles)"
+        except Exception as e:
+            self.connected = False
+            return f"❌ Connexion MCP échouée : {e}"
+
+    def _read_file(self, path: str) -> str:
+        """Lecture robuste de fichiers selon leur extension."""
+        import PyPDF2
+
+        ext = os.path.splitext(path)[1].lower()
+        try:
+            if ext in [".txt", ".md", ".py", ".json", ".csv"]:
+                with open(path, "r", encoding="utf-8") as f:
+                    return f.read()
+            elif ext == ".pdf":
+                with open(path, "rb") as f:
+                    return "\n".join(page.extract_text() for page in PyPDF2.PdfReader(f).pages)
+            else:
+                with open(path, "r", encoding="utf-8") as f:
+                    return f.read()
+        except Exception as e:
+            return f"[Erreur lecture fichier {os.path.basename(path)}: {e}]"
+
+    def process_message(
+        self, message: str, files: Optional[List] = None, history: Optional[List[List[str]]] = None
+    ) -> Tuple[List[List[str]], str, None]:
+        """Pipeline haut-niveau (message + fichiers → réponse)."""
+        if not self.session or not self.connected:
+            return history + [[message, "❌ Serveur MCP non connecté."]], "", None
+
+        file_content = ""
+        if files:
+            for file in files:
+                path = getattr(file, "name", file)
+                file_content += f"\nFichier: {os.path.basename(path)}\n{self._read_file(path)}\n"
+
+        full_message = (file_content + message).strip()
+        new_msgs = self.loop.run_until_complete(self._process_query(full_message, history or []))
+        assistant_reply = "\n\n".join(m.get("content", "") for m in new_msgs if m.get("role") == "assistant")
+
+        return (history or []) + [[message, assistant_reply]], "", None
+
+    async def _process_query(self, message: str, history: List[Any]):
+        """Exécution de la requête utilisateur avec gestion outils."""
+        if not self.client:
+            return [{"role": "assistant", "content": "❌ Client Claude indisponible."}]
+
+        # Prompt système (LEXICON)
+        sys_prompt = (
+            "You are LEXICON, an intelligent agricultural and weather data assistant with access to "
+            "specialized tools. Your mission: produce complete, accurate answers using planning + multiple tool calls."
+        )
+
+        conv = [{"role": r, "content": c} for h in history for r, c in zip(["user", "assistant"], h)]
+        conv.append({"role": "user", "content": message})
+
+        try:
+            return await self._tool_loop(conv, sys_prompt)
+        except Exception as e:
+            return [{"role": "assistant", "content": f"❌ Erreur Claude : {e}"}]
+
+    @retry_async(max_attempts=3, delay=2)
+    async def _tool_loop(self, messages: List[Dict[str, str]], sys_prompt: str):
+        """Boucle principale de planification/exécution avec outils MCP."""
+        result_msgs: List[Dict[str, str]] = []
+        conv = messages.copy()
+        seen_tool_calls = set()
+        iteration = 0
+        last_summary = None
+        max_context_tokens = 2000
+        tool_timeout = 10.0
+
+        while iteration < self.max_iterations:
+            iteration += 1
+            tools_this_round = filter_tools_for_context(self.tools, conv, [])
+
+            try:
+                resp = self.client.messages.create(
+                    model=os.getenv("CLAUDE_MODEL", "claude-3-5-sonnet-20241022"),
+                    max_tokens=int(os.getenv("CLAUDE_MAX_TOKENS", "8192")),
+                    system=sys_prompt,
+                    messages=conv,
+                    tools=tools_this_round,
+                )
+            except Exception as e:
+                result_msgs.append({"role": "assistant", "content": f"❌ Erreur appel modèle : {e}"})
+                break
+
+            has_tool_calls = False
+            iteration_changes = False
+
+            for c in resp.content:
+                if c.type == "tool_use":
+                    has_tool_calls = True
+                    tool_name, tool_args, tool_call_id = c.name, c.input, c.id
+                    key = (tool_name, tuple(sorted(tool_args.items())))
+                    if key in seen_tool_calls:
+                        result_msgs.append({"role": "assistant", "content": f"ℹ️ Tool déjà appelé {tool_name}({tool_args})"})
+                        continue
+                    seen_tool_calls.add(key)
+
+                    try:
+                        tool_result = await asyncio.wait_for(
+                            self.session.call_tool(tool_name, tool_args), timeout=tool_timeout
+                        )
+                        raw_str = "\n".join(str(item) for item in tool_result.content)
+                        conv.extend([
+                            {"role": "assistant", "content": [{"type": "tool_use", "id": tool_call_id, "name": tool_name, "input": tool_args}]},
+                            {"role": "user", "content": [{"type": "tool_result", "tool_use_id": tool_call_id, "content": raw_str}]}
+                        ])
+                        result_msgs.append({"role": "assistant", "content": f"🔧 {tool_name}({tool_args})\n```json\n{raw_str}\n```"})
+                        iteration_changes = True
+                    except asyncio.TimeoutError:
+                        msg = f"❌ Timeout outil {tool_name}({tool_args})"
+                        result_msgs.append({"role": "assistant", "content": msg})
+                    except Exception as e:
+                        msg = f"❌ Erreur outil {tool_name}({tool_args}) : {e}"
+                        result_msgs.append({"role": "assistant", "content": msg})
+
+                elif c.type == "text":
+                    text = c.text.strip()
+                    if text:
+                        result_msgs.append({"role": "assistant", "content": text})
+                        conv.append({"role": "assistant", "content": text})
+                        iteration_changes = True
+
+            # Conditions d'arrêt
+            if not has_tool_calls or not iteration_changes:
+                break
+
+            summary = summarize_latest_results(conv)
+            if last_summary is not None and summary == last_summary:
+                result_msgs.append({"role": "assistant", "content": "ℹ️ Pas de nouvelles infos, arrêt."})
+                break
+            last_summary = summary
+
+            if max_context_tokens and count_tokens(conv) > max_context_tokens:
+                conv = trim_conversation(conv, keep_last_n=MAX_HISTORY_MESSAGES)
+
+        # Synthèse finale
+        result_msgs.append({"role": "assistant", "content": "## 📋 Synthèse finale :"})
+        try:
+            final_prompt = "Basé sur les données collectées, rédige une réponse claire et utile à la question initiale."
+            conv.append({"role": "user", "content": final_prompt})
+            final_resp = self.client.messages.create(
+                model=os.getenv("CLAUDE_MODEL", "claude-3-5-sonnet-20241022"),
+                max_tokens=int(os.getenv("CLAUDE_MAX_TOKENS", "8192")),
+                system="You are the assistant producing the final analysis.",
+                messages=conv,
+                tools=[],
+            )
+            for c in final_resp.content:
+                if c.type == "text":
+                    result_msgs.append({"role": "assistant", "content": c.text.strip()})
+        except Exception as e:
+            result_msgs.append({"role": "assistant", "content": f"❌ Erreur synthèse finale : {e}"})
+
+        return result_msgs
+
+client = MCPClient()
+
+def gradio_interface():
+    # Keep the custom orange and red theme
+    theme = gr.themes.Default(
+        primary_hue=gr.themes.colors.orange,
+        secondary_hue=gr.themes.colors.red,
+        neutral_hue=gr.themes.colors.slate,
+    )
+
+    with gr.Blocks(title="MCP LEXICON", theme=theme, css=".gradio-container {max-width: 95% !important;}") as demo:
+        
+        # 1. Top row with title and the new dynamic status button
+        with gr.Row():
+            with gr.Column(scale=8):
+                gr.Markdown("## 🌾 LEXICON CHATBOT")
+            with gr.Column(scale=10, min_width=220):
+                status_button = gr.Button(
+                    "Connecting...", 
+                    variant="stop", 
+                    interactive=False
+                )
+
+        # 2. Main chat interface with a clear button
+        with gr.Row():
+            chatbot = gr.Chatbot(
+                label="Conversation",
+                value=[], 
+                height=650,
+                show_copy_button=True,
+                avatar_images=("👤", "🌾"),
+                bubble_full_width=False,
+            )
+            clear_btn = gr.Button("🗑️ Clear", scale=0)
+        
+        # 3. Concise input bar at the bottom (standard chatbot layout)
+        with gr.Row():
+            with gr.Column(scale=10):
+                msg = gr.Textbox(
+                    label="User Prompt",
+                    placeholder="Ask a question about agriculture, weather, or geography...",
+                    show_label=False,
+                    container=False # Removes border for a cleaner look
+                )
+            
+            file_btn = gr.UploadButton("📎", file_count="multiple", scale=1)
+            
+            submit_btn = gr.Button(
+                "Ask", 
+                variant="primary", 
+                scale=1
+            )
+        
+        # Examples accordion remains at the bottom
+        with gr.Accordion("💡 Example Queries", open=False):
+            gr.Examples(
+                examples=[
+                    "What's the complete agricultural profile of Bignan including weather stations, cadastral parcels, and production data?",
+                    "Find all weather stations near Paris, get their latest data, and analyze weather patterns",
+                    "I need comprehensive information about vine varieties and which phytosanitary products are recommended for vineyard management",
+                ],
+                inputs=msg
+            )
+        
+        # Event handlers
+        def auto_connect():
+            return client.connect()
+        
+        def process_and_clear(message, files, history):
+            if not message.strip() and not files:
+                return history, "", None
+            # Simply return the result from the client method
+            return client.process_message(message, files, history)
+        
+        # Setup events
+        demo.load(auto_connect, outputs=status_button)
+        status_button.click(auto_connect, outputs=status_button)
+        
+        submit_btn.click(
+            process_and_clear,
+            inputs=[msg, file_btn, chatbot],
+            outputs=[chatbot, msg, file_btn]
+        )
+        
+        msg.submit(
+            process_and_clear,
+            inputs=[msg, file_btn, chatbot],
+            outputs=[chatbot, msg, file_btn]
+        )
+        
+        clear_btn.click(lambda: ([], "", None), outputs=[chatbot, msg, file_btn], queue=False)
+        
+    return demo
+
+if __name__ == "__main__":
+    if not os.getenv("ANTHROPIC_API_KEY"):
+        print("Warning: ANTHROPIC_API_KEY not found in environment.")
+        print("Please set it in your .env file: ANTHROPIC_API_KEY=your_key_here")
+    else:
+        print("Found Anthropic API key")
+    
+    print("Starting Enhanced MCP Client with Multi-Step Planning...")
+    print("API endpoint: https://lexicon.osfarm.org")
+    
+    interface = gradio_interface()
+    interface.launch(debug=True, share=True)

gradio_mcp_server.py

@@ -0,0 +1,433 @@
+from mcp.server.fastmcp import FastMCP
+import json
+import sys
+import io
+import requests
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
+
+mcp = FastMCP("lexicon_api_server")
+
+BASE_URL = "https://lexicon.osfarm.org"
+
+def make_api_request(endpoint: str, params: dict = None) -> str:
+    """Helper function to make API requests with consistent error handling"""
+    url = f"{BASE_URL}{endpoint}"
+    
+    try:
+        response = requests.get(url, params=params, timeout=30)
+        response.raise_for_status()
+        
+        # Check if response is GeoJSON or regular JSON
+        content_type = response.headers.get('content-type', '')
+        if 'application/geo+json' in content_type or endpoint.endswith('.geojson'):
+            data_type = "geojson"
+        else:
+            data_type = "json"
+        
+        data = response.json()
+        
+        return json.dumps({
+            "type": "success",
+            "data_type": data_type,
+            "endpoint": endpoint,
+            "data": data,
+            "message": f"Successfully retrieved data from {endpoint}"
+        }, indent=2)
+        
+    except requests.exceptions.ConnectionError:
+        return json.dumps({
+            "type": "error",
+            "endpoint": endpoint,
+            "message": f"Could not connect to API. Please ensure the service is running."
+        })
+    except requests.exceptions.Timeout:
+        return json.dumps({
+            "type": "error",
+            "endpoint": endpoint,
+            "message": f"Request timed out for {endpoint}"
+        })
+    except requests.exceptions.HTTPError as e:
+        status_code = e.response.status_code if e.response else "unknown"
+        return json.dumps({
+            "type": "error",
+            "endpoint": endpoint,
+            "status_code": status_code,
+            "message": f"HTTP error {status_code} for {endpoint}. Resource may not exist or API may be unavailable."
+        })
+    except json.JSONDecodeError:
+        return json.dumps({
+            "type": "error",
+            "endpoint": endpoint,
+            "message": f"Invalid JSON response from {url}"
+        })
+    except Exception as e:
+        return json.dumps({
+            "type": "error",
+            "endpoint": endpoint,
+            "message": f"Unexpected error: {str(e)}"
+        })
+
+@mcp.tool()
+async def get_parcel_identifier_json(latitude: float, longitude: float) -> str:
+    """
+    Retrieve parcel identifier information in JSON format for a given geographic location. -- ST PORCHAIRE
+
+    Args:
+        latitude (float): Latitude of the point of interest.
+        longitude (float): Longitude of the point of interest.
+
+    Returns:
+        str: JSON string containing parcel identifier data for the specified coordinates.
+
+    This tool allows you to obtain parcel identification data by providing precise geographic coordinates.
+    Useful for reverse-geocoding a location to its cadastral reference.
+    """
+    params = {"latitude": latitude, "longitude": longitude}
+    return make_api_request("/tools/parcel-identifier.json", params)[:20000]
+
+@mcp.tool()
+async def get_cadastral_parcels(
+    page: int = 1,
+    code: str = None,
+    prefix: str = None,
+    section: str = None,
+    number: str = None
+) -> str:
+    """
+    Retrieve a paginated list of cadastral parcels, with optional filters.
+
+    Args:
+        page (int, optional): Page number for pagination (default: 1).
+        code (str, optional): Commune code to filter parcels.
+        prefix (str, optional): Parcel prefix for more precise filtering.
+        section (str, optional): Parcel section identifier.
+        number (str, optional): Parcel number.
+
+    Returns:
+        str: JSON string containing a list of cadastral parcels matching the filters.
+
+    This tool enables searching for cadastral parcels using various administrative and parcel-specific filters.
+    Useful for exploring land registry data at different levels of granularity.
+    Using a single postal_code, gives every cadastral parcels codes in that city, for example.
+    """
+    params = {"page": page}
+    if code: params["code"] = code
+    if prefix: params["prefix"] = prefix
+    if section: params["section"] = section
+    if number: params["number"] = number
+    return make_api_request("/geographical-references/cadastral-parcels.json", params)
+
+@mcp.tool()
+async def get_cadastral_parcel(parcel_id: str) -> str:
+    """
+    Retrieve detailed information about a specific cadastral parcel.
+
+    Args:
+        parcel_id (str): Unique identifier of the cadastral parcel.
+
+    Returns:
+        str: JSON string with detailed information about the parcel.
+
+    Use this tool to get all available data for a single cadastral parcel, including administrative and spatial attributes.
+    """
+    return make_api_request(f"/geographical-references/cadastral-parcels/{parcel_id}.json")
+
+
+@mcp.tool()
+async def get_cadastral_parcel_prices(postal_code: str = None, city: str = None, department: str = None) -> str:
+    """
+    Retrieve cadastral parcel price information, filtered by postal code, city, or department,
+
+    Args:
+        postal_code (str, optional): Postal code to filter results.
+        city (str, optional): City name for filtering.
+        department (str, optional): Department code or name.
+
+    Returns:
+        str: JSON string with price information for cadastral parcels.
+
+    This tool provides access to price data for cadastral parcels, supporting multiple administrative filters.
+    It is possible, with a postal code and a city name, to get the prices of every cadastral parcel sold in that city and when, 
+    for example. So it is possible to know which one is the most expensive or the cheapest.
+    """
+    params = {}
+    if postal_code: params["postal_code"] = postal_code
+    if city: params["city"] = city
+    if department: params["department"] = department
+    ## FOR DEMO PURPOSES:
+    params["page"] = 2
+    return make_api_request("/geographical-references/cadastral-parcel-prices.json", params)
+    
+# geographical-references/cadastral-parcel-prices?postal_code=&city=Saint-Porchaire&department=&page=2
+
+@mcp.tool()
+async def get_cap_parcels(page: int = 1, city: str = None) -> str:
+    """
+    Retrieve a paginated list of CAP (Common Agricultural Policy) parcels, 
+    allowing to access the crops available in the filtered city.
+
+    Args:
+        page (int, optional): Page number for pagination (default: 1).
+        city (str, optional): City name to filter CAP parcels.
+
+    Returns:
+        str: JSON string containing CAP parcels matching the filters.
+
+    This tool allows you to explore CAP parcels, which are relevant for agricultural policy and subsidy management.
+    """
+    return make_api_request(f"/geographical-references/cap-parcels.json?city={city}")
+
+@mcp.tool()
+async def get_municipalities(page: int = 1, country: str = None, city: str = None) -> str:
+    """
+    Retrieve a paginated list of municipalities, with optional filters for country and city.
+
+    Args:
+        page (int, optional): Page number for pagination (default: 1).
+        country (str, optional): Country name to filter municipalities.
+        city (str, optional): City name for more precise filtering.
+
+    Returns:
+        str: JSON string containing municipalities matching the filters.
+
+    This tool is useful for exploring administrative boundaries and locating municipalities by name or country.
+    """
+    params = {"page": page}
+    if country: params["country"] = country
+    if city: params["city"] = city
+    return make_api_request("/geographical-references/municipalities.json", params)
+
+@mcp.tool()
+async def get_municipality(municipality_id: str) -> str:
+    """
+    Retrieve detailed information about a specific municipality.
+
+    Args:
+        municipality_id (str): Unique identifier of the municipality.
+
+    Returns:
+        str: JSON string with detailed information about the municipality.
+
+    Use this tool to access all available data for a single municipality, including administrative and spatial attributes.
+    """
+    return make_api_request(f"/geographical-references/municipalities/{municipality_id}.json")
+
+@mcp.tool()
+async def get_productions(page: int = 1, family: str = None, usage: str = None) -> str:
+    """
+    Retrieve a paginated list of production data, with optional filters for family and usage.
+
+    Args:
+        page (int, optional): Page number for pagination (default: 1).
+        family (str, optional): Production family (e.g., crop type).
+        usage (str, optional): Usage type (e.g., food, feed).
+
+    Returns:
+        str: JSON string containing production data matching the filters.
+
+    This tool is useful for analyzing agricultural production by type and intended use.
+    """
+    params = {"page": page}
+    if family: params["family"] = family
+    if usage: params["usage"] = usage
+    return make_api_request("/production/productions.json", params)
+
+@mcp.tool()
+async def get_cropsets(page: int = 1) -> str:
+    """
+    Retrieve a paginated list of phytosanitary cropsets.
+
+    Args:
+        page (int, optional): Page number for pagination (default: 1).
+
+    Returns:
+        str: JSON string containing cropset data.
+
+    This tool provides access to phytosanitary cropsets, which are important for plant protection and regulatory compliance.
+    """
+    params = {"page": page}
+    return make_api_request("/phytosanitary/cropsets.json", params)
+
+@mcp.tool()
+async def get_phytosanitary_products(page: int = 1) -> str:
+    """
+    Retrieve a paginated list of phytosanitary products, and returns:
+     Name
+     firm
+     Type
+     Active compounds
+     Usage state
+
+    Args:
+        page (int, optional): Page number for pagination (default: 1).
+        type (str, optional): Product type (e.g., herbicide, fungicide).
+        state (str, optional): Product state (e.g., approved, withdrawn).
+
+    Returns:
+        str: JSON string containing phytosanitary products matching the filters.
+
+    This tool is useful for exploring available plant protection products and their regulatory status.
+    """
+    return make_api_request("/phytosanitary/products.json")
+
+@mcp.tool()
+async def get_phytosanitary_symbols(page: int = 1) -> str:
+    """
+    Retrieve a paginated list of phytosanitary symbols.
+
+    Args:
+        page (int, optional): Page number for pagination (default: 1).
+
+    Returns:
+        str: JSON string containing phytosanitary symbols.
+
+    This tool provides access to symbols used in plant protection and regulatory documentation.
+    """
+    params = {"page": page}
+    return make_api_request("/phytosanitary/symbols.json", params)
+
+@mcp.tool()
+async def get_seed_varieties(page: int = 1, species: str = None) -> str:
+    """
+    Retrieve a paginated list of seed varieties, optionally filtered by species.
+
+    Args:
+        page (int, optional): Page number for pagination (default: 1).
+        species (str, optional): Species name to filter seed varieties, ALWAYS IN CAPITAL LETTERS, e.g for "avoine", use "AVOINE",
+        to find the right species, for example "AVOINE". Then varieties will be filtered.
+
+    Returns:
+        str: JSON string containing seed varieties matching the filters.
+
+    This tool is useful for exploring available seed varieties for different crops.
+    """
+    params = {"page": page}
+    if species: params["species"] = species
+    return make_api_request("/seeds/varieties.json", params)
+
+
+@mcp.tool()
+async def get_vine_varieties(page: int = 1, category: str = None, color: str = None) -> str:
+    """
+    Retrieve a paginated list of vine varieties, with optional filters for category and color.
+
+    Args:
+        page (int, optional): Page number for pagination (default: 1).
+        category (str, optional): Vine category (e.g., table, wine).
+        color (str, optional): Grape color (e.g., red, white).
+
+    Returns:
+        str: JSON string containing vine varieties matching the filters.
+
+    This tool is useful for exploring grapevine diversity and selecting varieties for viticulture.
+    """
+    params = {"page": page}
+    if category: params["category"] = category
+    if color: params["color"] = color
+    return make_api_request("/viticulture/vine-varieties.json", params)
+
+@mcp.tool()
+async def get_weather_stations(page: int = 1, country: str = None, name: str = None) -> str:
+    """
+    Retrieve a paginated list of weather stations, with optional filters for country and station name.
+
+    Args:
+        page (int, optional): Page number for pagination (default: 1).
+        country (str, optional): Country name to filter stations.
+        name (str, optional): Station name for more precise filtering.
+
+    Returns:
+        str: JSON string containing weather stations matching the filters.
+
+    This tool is useful for discovering available weather stations and narrowing down by location or name.
+    """
+    params = {"page": page}
+    if country: params["country"] = country
+    if name: params["name"] = name
+    return make_api_request("/weather/stations.json", params)
+
+@mcp.tool()
+async def get_weather_station(station_code: str) -> str:
+    """
+    Retrieve detailed information about a specific weather station.
+
+    Args:
+        station_code (str): Unique code identifying the weather station.
+
+    Returns:
+        str: JSON string with detailed information about the weather station.
+
+    Use this tool to access metadata and attributes for a single weather station.
+    """
+    return make_api_request(f"/weather/stations/{station_code}.json")
+
+@mcp.tool()
+async def get_weather_data(station_code: str, start: str = None, end: str = None) -> str:
+    """
+    Retrieve hourly weather reports for a specific station, optionally filtered by date range.
+
+    Args:
+        station_code (str): Unique code identifying the weather station.
+        start (str, optional): Start date/time in ISO format (e.g., '2024-01-01T00:00:00Z').
+        end (str, optional): End date/time in ISO format (e.g., '2024-01-31T23:59:59Z').
+
+    Returns:
+        str: JSON string containing hourly weather reports for the specified station and date range.
+
+    This tool is useful for analyzing weather data over time for a given location.
+    """
+    params = {}
+    if start: params["start"] = start
+    if end: params["end"] = end
+    return make_api_request(f"/weather/stations/{station_code}/hourly-reports.json", params)
+
+
+@mcp.tool()
+async def get_cadastral_parcel_geolocation(parcel_id: str) -> str:
+    """
+    Retrieve geolocation data for a specific cadastral parcel in GeoJSON format.
+
+    Args:
+        parcel_id (str): Unique identifier of the cadastral parcel.
+
+    Returns:
+        str: GeoJSON string with spatial data for the parcel.
+
+    Use this tool to obtain the geometry of a cadastral parcel for mapping or spatial analysis.
+    """
+    return make_api_request(f"/geographical-references/cadastral-parcels/{parcel_id}/geolocation.geojson")
+
+@mcp.tool()
+async def get_cap_parcel_geolocation(cap_id: str) -> str:
+    """
+    Retrieve geolocation data for a specific CAP parcel in GeoJSON format.
+
+    Args:
+        cap_id (str): Unique identifier of the CAP parcel.
+
+    Returns:
+        str: GeoJSON string with spatial data for the CAP parcel.
+
+    Use this tool to obtain the geometry of a CAP parcel for mapping or spatial analysis.
+    """
+    return make_api_request(f"/geographical-references/cap-parcels/{cap_id}/geolocation.geojson")
+
+@mcp.tool()
+async def get_municipality_cadastre(municipality_id: str) -> str:
+    """
+    Retrieve cadastre data for a municipality in GeoJSON format.
+
+    Args:
+        municipality_id (str): Unique identifier of the municipality.
+
+    Returns:
+        str: GeoJSON string with cadastre data for the municipality.
+
+    Use this tool to obtain the spatial extent of a municipality's cadastre for mapping or GIS analysis.
+    """
+    return make_api_request(f"/geographical-references/municipalities/{municipality_id}/cadastre.geojson")
+
+if __name__ == "__main__":
+    mcp.run(transport='stdio')

requirements.txt

@@ -1 +1,6 @@
-gradio[mcp]
+gradio[mcp]
+anthropic 
+mcp
+openai
+mistralai==0.4.2
+PyPDF2

tool_utils.py

@@ -0,0 +1,56 @@
+# Fonctions utilitaires
+from typing import Any, Dict, List
+
+
+def filter_tools_for_context(tools: List[Any], conversation_messages: List[Dict[str, Any]], keywords: List[str]) -> List[Any]:
+    """Filtrage simple des outils selon contexte récent et mots-clés."""
+    recent_text = " ".join(
+        msg["content"] if isinstance(msg.get("content"), str) else " ".join(
+            item.get("text", "") for item in msg.get("content", []) if isinstance(item, dict)
+        )
+        for msg in conversation_messages[-5:]
+    ).lower()
+
+    selected = []
+    for tool in tools:
+        name = (tool.get("name") if isinstance(tool, dict) else getattr(tool, "name", "")).lower()
+        desc = (tool.get("description") if isinstance(tool, dict) else getattr(tool, "description", "")).lower()
+        if not keywords or any(kw.lower() in (name + desc + recent_text) for kw in keywords):
+            selected.append(tool)
+    return selected
+
+
+def summarize_latest_results(conversation_messages: List[Dict[str, Any]]) -> str:
+    """Résumé des derniers résultats outils."""
+    summaries = []
+    for msg in conversation_messages:
+        if msg.get("role") == "user" and isinstance(msg.get("content"), list):
+            for item in msg["content"]:
+                if isinstance(item, dict) and item.get("type") == "tool_result":
+                    summaries.append(item.get("content", ""))
+    return "\n".join(summaries[-5:]).strip()
+
+
+def count_tokens(conversation_messages: List[Dict[str, Any]]) -> int:
+    """Comptage naïf de tokens (optimisation mémoire)."""
+    total = 0
+    for msg in conversation_messages:
+        content = msg.get("content")
+        if isinstance(content, str):
+            total += len(content.split())
+        elif isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict) and "text" in item:
+                    total += len(item["text"].split())
+                elif isinstance(item, str):
+                    total += len(item.split())
+    return total
+
+
+def trim_conversation(conversation_messages: List[Dict[str, Any]], keep_last_n: int = 5) -> List[Dict[str, Any]]:
+    """Réduction du contexte conversationnel."""
+    if len(conversation_messages) <= keep_last_n:
+        return conversation_messages
+    trimmed = conversation_messages[-keep_last_n:]
+    trimmed.insert(0, {"role": "system", "content": "Résumé des messages précédents supprimés pour raison de contexte."})
+    return trimmed