Upload 7 files (#1)

- Upload 7 files (23e855c25ddc7902183e32653d807b6f82c007f3)


Co-authored-by: Florian Guerin <[email protected]>

.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: 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
+---
+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,503 +1,371 @@
-import asyncio
-import os
-import json
-from typing import List, Dict, Any, Union, Optional
-from contextlib import AsyncExitStack
-
-import gradio as gr
-from gradio.components.chatbot import ChatMessage
-from mcp import ClientSession, StdioServerParameters
-from mcp.client.stdio import stdio_client
-from anthropic import Anthropic
-from dotenv import load_dotenv
-
-load_dotenv()
-
-loop = asyncio.new_event_loop()
-asyncio.set_event_loop(loop)
-
-class MCPClientWrapper:
-    def __init__(self):
-        self.session = None
-        self.exit_stack = None
-        self.client = None
-        self.tools = []
-        self.connected = False
-        self.max_iterations = 3  # Prevent infinite loops
-        self._init_client()
-    
-    def _init_client(self):
-        """Initialize Claude client"""
-        if os.getenv("ANTHROPIC_API_KEY"):
-            self.client = Anthropic()
-        else:
-            raise ValueError("ANTHROPIC_API_KEY not found in environment")
-    
-    def connect(self) -> str:
-        return loop.run_until_complete(self._connect())
-
-    async def _connect(self) -> str:
-        if self.exit_stack:
-            await self.exit_stack.aclose()
-        
-        self.exit_stack = AsyncExitStack()
-        server_path = "gradio_mcp_server.py"
-        
-        server_params = StdioServerParameters(
-            command="python",
-            args=[server_path],
-            env={"PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"}
-        )
-        
-        try:
-            stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_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()
-            
-            response = await self.session.list_tools()
-            self.tools = [{ 
-                "name": tool.name,
-                "description": tool.description,
-                "input_schema": tool.inputSchema
-            } for tool in response.tools]
-            
-            self.connected = True
-            return f"Connected to MCP Server. Available tools: {len(self.tools)}"
-        except Exception as e:
-            self.connected = False
-            return f"Failed to connect to MCP server: {str(e)}"
-    
-    def _read_file_content(self, file_path: str) -> str:
-        """Read and extract text content from uploaded file"""
-        try:
-            file_extension = os.path.splitext(file_path)[1].lower()
-            
-            if file_extension in ['.txt', '.md', '.py', '.js', '.html', '.css', '.json', '.xml', '.yaml', '.yml']:
-                with open(file_path, 'r', encoding='utf-8') as f:
-                    return f.read()
-            
-            elif file_extension == '.pdf':
-                try:
-                    import PyPDF2
-                    with open(file_path, 'rb') as f:
-                        reader = PyPDF2.PdfReader(f)
-                        text = ""
-                        for page in reader.pages:
-                            text += page.extract_text() + "\n"
-                        return text
-                except ImportError:
-                    return f"PDF file detected but PyPDF2 not installed. File name: {os.path.basename(file_path)}"
-            
-            elif file_extension == '.csv':
-                with open(file_path, 'r', encoding='utf-8') as f:
-                    return f.read()
-            
-            else:
-                try:
-                    with open(file_path, 'r', encoding='utf-8') as f:
-                        return f.read()
-                except UnicodeDecodeError:
-                    file_size = os.path.getsize(file_path)
-                    return f"Binary file detected: {os.path.basename(file_path)} ({file_size} bytes)"
-                    
-        except Exception as e:
-            return f"Error reading file {os.path.basename(file_path)}: {str(e)}"
-    
-    # In the MCPClientWrapper class...
-
-    def process_message(self, message: str, files: Optional[List], history: List[List[str]]) -> tuple:
-        if not self.session or not self.connected:
-            # Format the error message correctly for the chatbot
-            error_response = "MCP server is not connected. Please check the connection status above."
-            return history + [[message, error_response]], "", None
-        
-        # Process uploaded files (your existing code is fine here)
-        file_content = ""
-        if files:
-            file_content = "\n\n--- UPLOADED FILES ---\n"
-            for file in files:
-                if hasattr(file, 'name'):
-                    file_path = file.name
-                else:
-                    file_path = file
-                
-                content = self._read_file_content(file_path)
-                file_content += f"\nFile: {os.path.basename(file_path)}\n{content}\n"
-            file_content += "--- END FILES ---\n\n"
-        
-        # Combine message with file content
-        full_message = file_content + message if file_content else message
-        
-        # This returns a list of dictionaries like [{'role': 'assistant', 'content': '...'}, ...]
-        new_messages = loop.run_until_complete(self._process_query(full_message, history))
-
-        # 1. Combine all the assistant's generated messages (tool calls, analysis) into a single string.
-        assistant_response_parts = [
-            msg.get('content', '') for msg in new_messages if msg.get('role') == 'assistant'
-        ]
-        assistant_full_response = "\n\n".join(assistant_response_parts)
-
-        # 2. Update the history in the format Gradio expects: a list of [user, assistant] pairs.
-        updated_history = history + [[message, assistant_full_response]]
-
-        # 3. Return the correctly formatted history and other component updates.
-        return updated_history, "", None
-    
-    async def _process_query(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]]):
-        if not self.client:
-            return [{"role": "assistant", "content": "Claude client not available"}]
-        
-        # Enhanced system prompt that encourages planning and comprehensive analysis
-        system_prompt = """You are LEXICON, an intelligent agricultural and weather data assistant with access to comprehensive databases through specialized tools.
-
-CORE MISSION: When users ask questions, you must create and execute detailed plans to provide complete, accurate answers using ALL relevant data sources.
-
-PLANNING APPROACH:
-1. **ANALYZE** the user's question to identify all information needs
-2. **PLAN** a systematic approach using multiple tools and data sources
-3. **EXECUTE** your plan step-by-step, making multiple tool calls as needed
-4. **SYNTHESIZE** all gathered data into a comprehensive, well-structured answer
-
-AVAILABLE DATA SOURCES:
-- Weather stations and meteorological data (current and historical)
-- Municipalities and geographical references
-- Cadastral parcels and CAP (Common Agricultural Policy) parcels  
-- Agricultural production data and statistics
-- Seed varieties and vine varieties databases
-- Phytosanitary products and crop protection information
-- Geolocation data (GeoJSON) for mapping and spatial analysis
-
-EXECUTION PRINCIPLES:
-- Make MULTIPLE tool calls to gather complete information
-- Follow up on IDs, codes, or references found in initial results
-- Cross-reference data between different sources when relevant
-- Always aim for comprehensive coverage of the topic
-- If initial results suggest additional relevant data exists, pursue it
-- Provide context and explain relationships between different data points
-
-EXAMPLE WORKFLOWS:
-- Location query → Search municipalities → Get detailed info → Fetch cadastral/CAP data → Analyze geographical context
-- Weather inquiry → Find relevant stations → Get station details → Retrieve weather data → Analyze patterns
-- Agricultural question → Search relevant databases → Cross-reference production data → Provide comprehensive agricultural context
-
-Remember: Your goal is thorough investigation and complete answers, not quick single-tool responses.
-
-"""
-        
-        # Build conversation history for Claude
-        claude_messages = []
-        for msg in history:
-            if isinstance(msg, ChatMessage):
-                role, content = msg.role, msg.content
-            else:
-                role, content = msg.get("role"), msg.get("content")
-            
-            if role in ["user", "assistant"]:
-                claude_messages.append({"role": role, "content": content})
-        
-        claude_messages.append({"role": "user", "content": message})
-        
-        try:
-            # Start the iterative tool calling process
-            return await self._iterative_tool_calling(claude_messages)
-            
-        except Exception as e:
-            return [{"role": "assistant", "content": f"Error with Claude: {str(e)}"}]
-    
-    async def _iterative_tool_calling(self, messages: List[Dict[str, str]]):
-        """Enhanced method that allows Claude to reason through multiple tool calls"""
-        result_messages = []
-        conversation_messages = messages.copy()
-        iteration = 0
-        
-        while iteration < self.max_iterations:
-            iteration += 1
-            
-            try:
-                # Make API call to Claude
-                response = self.client.messages.create(
-                    model="claude-3-5-sonnet-20241022",
-                                        max_tokens=8192,
-                    system="""You are LEXICON, an intelligent agricultural and weather data assistant with access to comprehensive databases through specialized tools.
-
-CORE MISSION: When users ask questions, you must create and execute detailed plans to provide complete, accurate answers using ALL relevant data sources.
-
-PLANNING APPROACH:
-1. **ANALYZE** the user's question to identify all information needs
-2. **PLAN** a systematic approach using multiple tools and data sources
-3. **EXECUTE** your plan step-by-step, making multiple tool calls as needed
-4. **SYNTHESIZE** all gathered data into a comprehensive, well-structured answer
-
-AVAILABLE DATA SOURCES:
-- Weather stations and meteorological data (current and historical)
-- Municipalities and geographical references
-- Cadastral parcels and CAP (Common Agricultural Policy) parcels  
-- Agricultural production data and statistics
-- Seed varieties and vine varieties databases
-- Phytosanitary products and crop protection information
-- Geolocation data (GeoJSON) for mapping and spatial analysis
-
-EXECUTION PRINCIPLES:
-- Make MULTIPLE tool calls to gather complete information
-- Follow up on IDs, codes, or references found in initial results
-- Cross-reference data between different sources when relevant
-- Always aim for comprehensive coverage of the topic
-- If initial results suggest additional relevant data exists, pursue it
-- Provide context and explain relationships between different data points
-
-EXAMPLE WORKFLOWS:
-- Location query → Search municipalities → Get detailed info → Fetch cadastral/CAP data → Analyze geographical context
-- Weather inquiry → Find relevant stations → Get station details → Retrieve weather data → Analyze patterns
-- Agricultural question → Search relevant databases → Cross-reference production data → Provide comprehensive agricultural context
-
-Important: if the user mention "Saint-Porchaire", here's are the latitude and longitude to use to call the tool: 45.8289 and -0.7864,
-And never use the short "ST PORCHAIRE", only use "Saint-Porchaire" for all calls.
-When your answer involves citing several items, such as parcel IDs, mention many, as long as the output message is easily readable.
-
-Remember: Your goal is thorough investigation and complete answers, not quick single-tool responses.""",
-                    messages=conversation_messages,
-                    tools=self.tools
-                )
-                
-                # Process the response
-                has_tool_calls = False
-                response_text = ""
-                
-                for content in response.content:
-                    if content.type == 'text':
-                        response_text = content.text
-                        
-                    elif content.type == 'tool_use':
-                        has_tool_calls = True
-                        tool_name = content.name
-                        tool_args = content.input
-                        tool_call_id = content.id
-                        
-                        try:
-                            # Execute the tool call
-                            result = await self.session.call_tool(tool_name, tool_args)
-                            raw_result = result.content
-                            
-                            if isinstance(raw_result, list):
-                                raw_result = "\n".join(str(item) for item in raw_result)
-                            
-                            # Add tool result to conversation for Claude to see
-                            conversation_messages.append({
-                                "role": "assistant", 
-                                "content": [
-                                    {"type": "tool_use", "id": tool_call_id, "name": tool_name, "input": tool_args}
-                                ]
-                            })
-                            conversation_messages.append({
-                                "role": "user",
-                                "content": [
-                                    {
-                                        "type": "tool_result",
-                                        "tool_use_id": tool_call_id,
-                                        "content": str(raw_result)
-                                    }
-                                ]
-                            })
-                            
-                            # Add to result messages for display
-                            tool_display = f"🔧 **{tool_name}**({', '.join(f'{k}={v}' for k, v in tool_args.items())})\n\n```json\n{raw_result}\n```"
-                            result_messages.append({
-                                "role": "assistant",
-                                "content": tool_display
-                            })
-                            
-                        except Exception as e:
-                            error_msg = f"❌ Error calling {tool_name}: {str(e)}"
-                            result_messages.append({
-                                "role": "assistant",
-                                "content": error_msg
-                            })
-                            
-                            # Add error to conversation
-                            conversation_messages.append({
-                                "role": "user",
-                                "content": [
-                                    {
-                                        "type": "tool_result", 
-                                        "tool_use_id": tool_call_id,
-                                        "content": f"Error: {str(e)}"
-                                    }
-                                ]
-                            })
-                
-                # If there was response text, add it
-                if response_text.strip():
-                    result_messages.append({
-                        "role": "assistant",
-                        "content": response_text
-                    })
-                    
-                    # Add to conversation if this isn't just a tool call
-                    if not has_tool_calls:
-                        conversation_messages.append({
-                            "role": "assistant",
-                            "content": response_text
-                        })
-                
-                # If no tool calls were made, we're done with data gathering
-                if not has_tool_calls:
-                    break
-                    
-            except Exception as e:
-                result_messages.append({
-                    "role": "assistant",
-                    "content": f"❌ Error in iteration {iteration}: {str(e)}"
-                })
-                break
-        
-        # After all tool calls, get Claude's final synthesis
-        if iteration > 1:  # Only if we actually made tool calls
-            try:
-                final_prompt = "Based on all the data you've gathered above, please provide a comprehensive, well-structured answer to the user's original question. Synthesize the information from all sources and present it in a clear, useful format. Don't repeat the raw data - instead, analyze and explain what it means for the user."
-                
-                conversation_messages.append({
-                    "role": "user",
-                    "content": final_prompt
-                })
-                
-                final_response = self.client.messages.create(
-                    model="claude-3-5-sonnet-20241022",
-                    max_tokens=8192,
-                    system="You are LEXICON. Provide a comprehensive, synthesized answer based on all the data gathered. Focus on insights, analysis, and practical information rather than repeating raw data.",
-                    messages=conversation_messages,
-                    tools=[]  # No tools for final synthesis
-                )
-                
-                for content in final_response.content:
-                    if content.type == 'text':
-                        result_messages.append({
-                            "role": "assistant",
-                            "content": f"## 📋 **Comprehensive Analysis**\n\n{content.text}"
-                        })
-                        
-            except Exception as e:
-                result_messages.append({
-                    "role": "assistant",
-                    "content": f"❌ Error generating final analysis: {str(e)}"
-                })
-        
-        # # If we hit max iterations, add a note
-        # if iteration >= self.max_iterations:
-        #     result_messages.append({
-        #         "role": "assistant",
-        #         "content": f"ℹ️ Reached maximum analysis depth ({self.max_iterations} steps)."
-        #     })
-        
-        return result_messages
-
-client = MCPClientWrapper()
-
-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():
-            for status_update in client.connect():
-                yield status_update
-        
-        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)
-
-# provide everything you know about the municipality of ABANCOURT
+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

@@ -1,433 +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__":
+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,6 +1,6 @@
-gradio[mcp]
-anthropic 
-mcp
-openai
-mistralai==0.4.2
+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