support all clients et upload files

app.py

@@ -150,8 +150,8 @@ class MCPClientWrapper:
             } for tool in response.tools]
             
             self.connected = True
-            tool_names = [tool["name"] for tool in self.tools]
-            return f"✅ Connected to MCP Weather Server. Available tools: {', '.join(tool_names)}"
+            tool_count = len(self.tools)
+            return f"✅ Connected to LEXICON Agricultural API Server. Available tools: {tool_count} tools covering weather, cadastral data, CAP parcels, municipalities, production, phytosanitary, seeds, and viticulture."
         except Exception as e:
             self.connected = False
             return f"❌ Failed to connect to MCP server: {str(e)}"
@@ -169,7 +169,7 @@ class MCPClientWrapper:
             
             # Check file size (limit to 10MB)
             if file_size > 10 * 1024 * 1024:
-                return f"\n\n🔍 **File Upload Error**: {file_name} is too large (>10MB). Please upload a smaller file."
+                return f"\n\n📎 **File Upload Error**: {file_name} is too large (>10MB). Please upload a smaller file."
             
             # Try to read as text
             encodings_to_try = ['utf-8', 'utf-16', 'latin-1', 'cp1252']
@@ -184,7 +184,7 @@ class MCPClientWrapper:
                     if len(content) > max_chars:
                         content = content[:max_chars] + f"\n\n[Content truncated - showing first {max_chars} characters of {len(content)} total]"
                     
-                    file_info = f"\n\n🔍 **Uploaded File**: {file_name}"
+                    file_info = f"\n\n📎 **Uploaded File**: {file_name}"
                     if mime_type:
                         file_info += f" ({mime_type})"
                     file_info += f" - {file_size:,} bytes\n\n```\n{content}\n```"
@@ -195,10 +195,10 @@ class MCPClientWrapper:
                     continue
             
             # If all text encodings fail, it's likely a binary file
-            return f"\n\n🔍 **File Upload**: {file_name} appears to be a binary file and cannot be displayed as text."
+            return f"\n\n📎 **File Upload**: {file_name} appears to be a binary file and cannot be displayed as text."
             
         except Exception as e:
-            return f"\n\n🔍 **File Upload Error**: Could not read {file_name}: {str(e)}"
+            return f"\n\n📎 **File Upload Error**: Could not read {file_name}: {str(e)}"
     
     def _convert_tools_for_provider(self, provider: str):
         """Convert MCP tools format to provider-specific format."""
@@ -273,7 +273,7 @@ class MCPClientWrapper:
         if not self.session or not self.connected:
             return history + [
                 {"role": "user", "content": message}, 
-                {"role": "assistant", "content": "❌ MCP weather server is not connected. Please check the connection status above."}
+                {"role": "assistant", "content": "❌ LEXICON Agricultural API server is not connected. Please check the connection status above."}
             ], gr.Textbox(value=""), gr.File(value=None)
         
         # Process uploaded file if present
@@ -334,7 +334,7 @@ class MCPClientWrapper:
                 
                 result_messages.append({
                     "role": "assistant",
-                    "content": f"🔧 I'll use the **{tool_name}** tool to fetch the weather data you requested.",
+                    "content": f"🔧 I'll use the **{tool_name}** tool to fetch the requested data.",
                     "metadata": {
                         "title": f"Using tool: {tool_name}",
                         "log": f"Parameters: {json.dumps(tool_args, ensure_ascii=True)}",
@@ -349,7 +349,7 @@ class MCPClientWrapper:
                     result_content = "\n".join(str(item) for item in result_content)
                 
                 # Format the response
-                formatted_response = self._format_weather_response(result_content, tool_name)
+                formatted_response = self._format_api_response(result_content, tool_name)
                 result_messages.append(formatted_response)
                 
                 # Let the LLM analyze and respond
@@ -383,7 +383,7 @@ class MCPClientWrapper:
                 
                 result_messages.append({
                     "role": "assistant",
-                    "content": f"🔧 I'll use the **{tool_name}** tool to fetch the weather data you requested."
+                    "content": f"🔧 I'll use the **{tool_name}** tool to fetch the requested data."
                 })
                 
                 result = await self.session.call_tool(tool_name, tool_args)
@@ -391,7 +391,7 @@ class MCPClientWrapper:
                 if isinstance(result_content, list):
                     result_content = "\n".join(str(item) for item in result_content)
                 
-                formatted_response = self._format_weather_response(result_content, tool_name)
+                formatted_response = self._format_api_response(result_content, tool_name)
                 result_messages.append(formatted_response)
         
         return result_messages
@@ -415,7 +415,7 @@ class MCPClientWrapper:
                 
                 result_messages.append({
                     "role": "assistant",
-                    "content": f"🔧 I'll use the **{tool_name}** tool to fetch the weather data you requested."
+                    "content": f"🔧 I'll use the **{tool_name}** tool to fetch the requested data."
                 })
                 
                 result = await self.session.call_tool(tool_name, tool_args)
@@ -423,47 +423,45 @@ class MCPClientWrapper:
                 if isinstance(result_content, list):
                     result_content = "\n".join(str(item) for item in result_content)
                 
-                formatted_response = self._format_weather_response(result_content, tool_name)
+                formatted_response = self._format_api_response(result_content, tool_name)
                 result_messages.append(formatted_response)
         
         return result_messages
     
-    def _format_weather_response(self, result_content: str, tool_name: str):
-        """Format weather data response."""
+    def _format_api_response(self, result_content: str, tool_name: str):
+        """Format API response data."""
         try:
             result_json = json.loads(result_content)
             
             if isinstance(result_json, dict):
                 if result_json.get("type") == "success":
-                    station_code = result_json.get("station_code", "Unknown")
-                    weather_data = result_json.get("data", {})
+                    data = result_json.get("data", {})
                     
-                    formatted_response = f"## 🌤️ Weather Data for Station: {station_code}\n\n"
-                    
-                    if isinstance(weather_data, dict):
-                        if "reports" in weather_data:
-                            reports = weather_data["reports"]
-                            if isinstance(reports, list) and len(reports) > 0:
-                                formatted_response += f"**Found {len(reports)} weather reports**\n\n"
-                                for i, report in enumerate(reports[:3]):
-                                    if isinstance(report, dict):
-                                        timestamp = report.get("timestamp", "Unknown time")
-                                        temperature = report.get("temperature", "N/A")
-                                        humidity = report.get("humidity", "N/A")
-                                        formatted_response += f"**Report {i+1}** ({timestamp}):\n"
-                                        formatted_response += f"- Temperature: {temperature}\n"
-                                        formatted_response += f"- Humidity: {humidity}\n\n"
-                                
-                                if len(reports) > 3:
-                                    formatted_response += f"... and {len(reports) - 3} more reports\n\n"
-                        
-                        formatted_response += "**Raw Data:**\n```json\n" + json.dumps(weather_data, indent=2) + "\n```"
+                    # Create formatted response based on tool type
+                    if "weather" in tool_name.lower():
+                        formatted_response = self._format_weather_data(data, tool_name)
+                    elif "cadastral" in tool_name.lower():
+                        formatted_response = self._format_cadastral_data(data, tool_name)
+                    elif "municipality" in tool_name.lower() or "municipalities" in tool_name.lower():
+                        formatted_response = self._format_municipality_data(data, tool_name)
+                    elif "cap" in tool_name.lower():
+                        formatted_response = self._format_cap_data(data, tool_name)
+                    elif "production" in tool_name.lower():
+                        formatted_response = self._format_production_data(data, tool_name)
+                    elif "phytosanitary" in tool_name.lower():
+                        formatted_response = self._format_phytosanitary_data(data, tool_name)
+                    elif "seed" in tool_name.lower() or "varieties" in tool_name.lower():
+                        formatted_response = self._format_seed_data(data, tool_name)
+                    elif "vine" in tool_name.lower():
+                        formatted_response = self._format_viticulture_data(data, tool_name)
+                    else:
+                        formatted_response = self._format_generic_data(data, tool_name)
                     
                     return {
                         "role": "assistant",
                         "content": formatted_response,
                         "metadata": {
-                            "title": f"Weather Data Retrieved",
+                            "title": f"Data Retrieved: {tool_name}",
                             "status": "done",
                             "id": f"success_result_{tool_name}"
                         }
@@ -471,17 +469,16 @@ class MCPClientWrapper:
                 
                 elif result_json.get("type") == "error":
                     error_msg = result_json.get("message", "Unknown error occurred")
-                    station_code = result_json.get("station_code", "Unknown")
                     
-                    error_response = f"## ❌ Error Fetching Weather Data\n\n"
-                    error_response += f"**Station:** {station_code}\n"
+                    error_response = f"## ❌ Error Fetching Data\n\n"
+                    error_response += f"**Tool:** {tool_name}\n"
                     error_response += f"**Error:** {error_msg}\n\n"
                     
                     return {
                         "role": "assistant",
                         "content": error_response,
                         "metadata": {
-                            "title": "Weather API Error",
+                            "title": "API Error",
                             "status": "error",
                             "id": f"error_result_{tool_name}"
                         }
@@ -492,22 +489,139 @@ class MCPClientWrapper:
         
         return {
             "role": "assistant",
-            "content": "```\n" + result_content + "\n```",
+            "content": "```json\n" + result_content + "\n```",
             "metadata": {
-                "title": "Raw Tool Response",
+                "title": "Raw API Response",
                 "status": "done",
                 "id": f"raw_result_{tool_name}"
             }
         }
+    
+    def _format_weather_data(self, data, tool_name):
+        """Format weather-specific data."""
+        if "reports" in data:
+            reports = data["reports"]
+            if isinstance(reports, list) and len(reports) > 0:
+                formatted_response = f"## 🌤️ Weather Data\n\n"
+                formatted_response += f"**Found {len(reports)} weather reports**\n\n"
+                for i, report in enumerate(reports[:3]):
+                    if isinstance(report, dict):
+                        timestamp = report.get("timestamp", "Unknown time")
+                        temperature = report.get("temperature", "N/A")
+                        humidity = report.get("humidity", "N/A")
+                        formatted_response += f"**Report {i+1}** ({timestamp}):\n"
+                        formatted_response += f"- Temperature: {temperature}\n"
+                        formatted_response += f"- Humidity: {humidity}\n\n"
+                
+                if len(reports) > 3:
+                    formatted_response += f"... and {len(reports) - 3} more reports\n\n"
+                return formatted_response
+        
+        return self._format_generic_data(data, tool_name)
+    
+    def _format_cadastral_data(self, data, tool_name):
+        """Format cadastral parcel data."""
+        formatted_response = f"## 🗺️ Cadastral Data\n\n"
+        
+        if isinstance(data, list):
+            formatted_response += f"**Found {len(data)} cadastral parcels**\n\n"
+            for i, parcel in enumerate(data[:5]):
+                if isinstance(parcel, dict):
+                    parcel_id = parcel.get("id", f"Parcel {i+1}")
+                    formatted_response += f"**{parcel_id}**\n"
+                    if "area" in parcel:
+                        formatted_response += f"- Area: {parcel['area']}\n"
+                    if "owner" in parcel:
+                        formatted_response += f"- Owner: {parcel['owner']}\n"
+                    formatted_response += "\n"
+            if len(data) > 5:
+                formatted_response += f"... and {len(data) - 5} more parcels\n\n"
+        
+        return formatted_response
+    
+    def _format_municipality_data(self, data, tool_name):
+        """Format municipality data."""
+        formatted_response = f"## 🏛️ Municipality Data\n\n"
+        
+        if isinstance(data, list):
+            formatted_response += f"**Found {len(data)} municipalities**\n\n"
+            for i, municipality in enumerate(data[:5]):
+                if isinstance(municipality, dict):
+                    name = municipality.get("name", f"Municipality {i+1}")
+                    formatted_response += f"**{name}**\n"
+                    if "code" in municipality:
+                        formatted_response += f"- Code: {municipality['code']}\n"
+                    if "population" in municipality:
+                        formatted_response += f"- Population: {municipality['population']}\n"
+                    formatted_response += "\n"
+        
+        return formatted_response
+    
+    def _format_cap_data(self, data, tool_name):
+        """Format CAP parcel data."""
+        formatted_response = f"## 🌾 CAP Parcel Data\n\n"
+        
+        if isinstance(data, list):
+            formatted_response += f"**Found {len(data)} CAP parcels**\n\n"
+            for i, parcel in enumerate(data[:5]):
+                if isinstance(parcel, dict):
+                    parcel_id = parcel.get("cap_id", f"CAP Parcel {i+1}")
+                    formatted_response += f"**{parcel_id}**\n"
+                    if "area" in parcel:
+                        formatted_response += f"- Area: {parcel['area']}\n"
+                    if "crop_type" in parcel:
+                        formatted_response += f"- Crop Type: {parcel['crop_type']}\n"
+                    formatted_response += "\n"
+        
+        return formatted_response
+    
+    def _format_production_data(self, data, tool_name):
+        """Format production data."""
+        formatted_response = f"## 🌾 Production Data\n\n"
+        return self._format_generic_data(data, tool_name, formatted_response)
+    
+    def _format_phytosanitary_data(self, data, tool_name):
+        """Format phytosanitary data."""
+        formatted_response = f"## 🛡️ Phytosanitary Data\n\n"
+        return self._format_generic_data(data, tool_name, formatted_response)
+    
+    def _format_seed_data(self, data, tool_name):
+        """Format seed varieties data."""
+        formatted_response = f"## 🌱 Seed Varieties Data\n\n"
+        return self._format_generic_data(data, tool_name, formatted_response)
+    
+    def _format_viticulture_data(self, data, tool_name):
+        """Format viticulture data."""
+        formatted_response = f"## 🍇 Viticulture Data\n\n"
+        return self._format_generic_data(data, tool_name, formatted_response)
+    
+    def _format_generic_data(self, data, tool_name, header="## 📊 Data Retrieved\n\n"):
+        """Format generic data response."""
+        formatted_response = header
+        
+        if isinstance(data, list) and len(data) > 0:
+            formatted_response += f"**Found {len(data)} items**\n\n"
+            # Show first few items
+            for i, item in enumerate(data[:3]):
+                formatted_response += f"**Item {i+1}:**\n```json\n{json.dumps(item, indent=2)}\n```\n\n"
+            if len(data) > 3:
+                formatted_response += f"... and {len(data) - 3} more items\n\n"
+        elif isinstance(data, dict):
+            formatted_response += "**Data:**\n```json\n" + json.dumps(data, indent=2) + "\n```\n\n"
+        else:
+            formatted_response += f"**Data:** {data}\n\n"
+        
+        return formatted_response
 
 client = MCPClientWrapper()
 
 def gradio_interface():
     with gr.Blocks(title="MCP LEXICON", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🌤️ LEXICON CHATBOT - Multi-LLM Weather Assistant")
+        gr.Markdown("# 🌾 LEXICON AGRICULTURAL API ASSISTANT")
         gr.Markdown(
-            "Ask me about weather data from any weather station! I support multiple AI providers "
-            "and can process uploaded files for additional context. Choose your preferred AI model below."
+            "Your comprehensive AI assistant for agricultural and geographical data! I can access weather stations, "
+            "cadastral parcels, CAP parcels, municipalities, production data, phytosanitary information, seed varieties, "
+            "and viticulture data. Choose your preferred AI model below and upload files for additional context."
         )
         
         # LLM Provider Selection
@@ -538,7 +652,7 @@ def gradio_interface():
             
             with gr.Column(scale=1):
                 current_model_display = gr.Textbox(
-                    label="🔄 Current Selection",
+                    label="📋 Current Selection",
                     value=f"{client.current_provider}: {client.current_model}",
                     interactive=False
                 )
@@ -547,7 +661,7 @@ def gradio_interface():
         status = gr.Textbox(
             label="🔌 Connection Status", 
             interactive=False, 
-            value="🔄 Connecting to weather server..."
+            value="🔄 Connecting to LEXICON Agricultural API server..."
         )
         
         # Main chat interface
@@ -556,17 +670,17 @@ def gradio_interface():
             height=600,
             type="messages",
             show_copy_button=True,
-            avatar_images=("👤", "🤖"),
+            avatar_images=("👤", "🌾"),
             bubble_full_width=False
         )
         
-        # File upload component (already exists in your code!)
+        # File upload component
         file_upload = gr.File(
             label="📎 Upload File (optional)",
             file_count="single",
             file_types=[
                 ".txt", ".md", ".py", ".js", ".html", ".css", ".json", ".csv", 
-                ".xml", ".yml", ".yaml", ".ini", ".cfg", ".log", ".sql"
+                ".xml", ".yml", ".yaml", ".ini", ".cfg", ".log", ".sql", ".geojson"
             ],
             height=100
         )
@@ -574,8 +688,8 @@ def gradio_interface():
         # Input row
         with gr.Row(equal_height=True):
             msg = gr.Textbox(
-                label="💬 Ask about weather data",
-                placeholder="e.g., 'Get weather data for station NYC001' or upload a file with additional context",
+                label="💬 Ask about agricultural or geographical data",
+                placeholder="e.g., 'List all weather stations', 'Find cadastral parcels in municipality X', 'What seed varieties are available?'",
                 scale=4
             )
             with gr.Column(scale=1):
@@ -583,19 +697,56 @@ def gradio_interface():
                 clear_btn = gr.Button("🗑️ Clear Chat", size="lg")
                 reconnect_btn = gr.Button("🔄 Reconnect", size="lg")
         
-        # Example queries
-        with gr.Row():
-            gr.Examples(
-                examples=[
-                    "What weather stations are available?",
-                    "Get weather data for station ABC123",
-                    "Show me the latest hourly reports for station NYC001",
-                    "Analyze the uploaded data and compare it with weather patterns",
-                    "Explain the weather trends from the uploaded CSV file"
-                ],
-                inputs=msg,
-                label="💡 Example Queries"
-            )
+        # Example queries organized by category
+        with gr.Accordion("💡 Example Queries by Category", open=False):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("**🌤️ Weather**")
+                    gr.Examples(
+                        examples=[
+                            "List all weather stations",
+                            "Get weather data for station ABC123",
+                            "Show station information for NYC001"
+                        ],
+                        inputs=msg,
+                        label=None
+                    )
+                    
+                    gr.Markdown("**🗺️ Cadastral & Geographical**")
+                    gr.Examples(
+                        examples=[
+                            "List all municipalities",
+                            "Get cadastral parcels",
+                            "Show municipality with ID 12345",
+                            "Get geolocation for cadastral parcel XYZ"
+                        ],
+                        inputs=msg,
+                        label=None
+                    )
+                
+                with gr.Column():
+                    gr.Markdown("**🌾 Agricultural**")
+                    gr.Examples(
+                        examples=[
+                            "List CAP parcels",
+                            "Show available productions",
+                            "Get seed varieties",
+                            "List vine varieties for viticulture"
+                        ],
+                        inputs=msg,
+                        label=None
+                    )
+                    
+                    gr.Markdown("**🛡️ Phytosanitary**")
+                    gr.Examples(
+                        examples=[
+                            "List phytosanitary products",
+                            "Show phytosanitary symbols",
+                            "Get cropsets information"
+                        ],
+                        inputs=msg,
+                        label=None
+                    )
         
         # Provider/Model update functions
         def update_models(provider):
@@ -668,11 +819,17 @@ if __name__ == "__main__":
     else:
         print("🔑 Available API keys:", ", ".join(available_keys))
     
-    print("🚀 Starting Multi-LLM MCP Weather Client...")
-    print("🔡 Will auto-connect to gradio_mcp_server.py")
-    print("🌐 Weather API endpoint: https://lexicon.osfarm.org/weather/stations")
-    print("📎 File upload enabled - supports text, code, and data files")
+    print("🚀 Starting Multi-LLM LEXICON Agricultural API Client...")
+    print("🔗 Will auto-connect to gradio_mcp_server.py")
+    print("🌐 API endpoint: https://lexicon.osfarm.org")
+    print("📂 File upload enabled - supports text, code, data files, and GeoJSON")
     print("🤖 Multi-LLM support: Claude, OpenAI, Mistral, Llama")
+    print("🌾 Comprehensive agricultural data access:")
+    print("   • Weather stations and reports")
+    print("   • Cadastral and CAP parcels") 
+    print("   • Municipalities and geographical references")
+    print("   • Production and phytosanitary data")
+    print("   • Seed varieties and viticulture information")
     
     interface = gradio_interface()
     interface.launch(debug=True, share=True)

gradio_mcp_server.py

@@ -3,11 +3,297 @@ import json
 import sys
 import io
 import requests
+from typing import Optional
 
 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("weather_api_server")
+mcp = FastMCP("lexicon_api_server")
+
+# Base URL for all API endpoints
+BASE_URL = "https://lexicon.osfarm.org"
+
+def make_api_request(url: str, params: dict = None, endpoint_name: str = "API") -> str:
+    """Generic function to make API requests with consistent error handling."""
+    try:
+        response = requests.get(url, params=params, timeout=30)
+        response.raise_for_status()
+        
+        data = response.json()
+        
+        return json.dumps({
+            "type": "success",
+            "data": data,
+            "url": url,
+            "params": params or {},
+            "message": f"Successfully retrieved data from {endpoint_name}"
+        }, indent=2)
+        
+    except requests.exceptions.ConnectionError:
+        return json.dumps({
+            "type": "error",
+            "url": url,
+            "message": f"Could not connect to {endpoint_name}. Please ensure the service is running."
+        })
+    except requests.exceptions.Timeout:
+        return json.dumps({
+            "type": "error",
+            "url": url,
+            "message": f"Request timed out while fetching data from {endpoint_name}"
+        })
+    except requests.exceptions.HTTPError as e:
+        status_code = e.response.status_code if e.response else "unknown"
+        return json.dumps({
+            "type": "error",
+            "url": url,
+            "status_code": status_code,
+            "message": f"HTTP error {status_code} when fetching data from {endpoint_name}. Resource may not exist or API may be unavailable."
+        })
+    except json.JSONDecodeError:
+        return json.dumps({
+            "type": "error",
+            "url": url,
+            "message": f"Invalid JSON response received from {endpoint_name}"
+        })
+    except Exception as e:
+        return json.dumps({
+            "type": "error",
+            "url": url,
+            "message": f"Unexpected error fetching data from {endpoint_name}: {str(e)}"
+        })
+
+# TOOLS - PARCEL IDENTIFIER
+@mcp.tool()
+async def get_parcel_identifier() -> str:
+    """Get parcel identifier tools/information in JSON format.
+    
+    Returns:
+        JSON string containing parcel identifier data or error information
+    """
+    url = f"{BASE_URL}/tools/parcel-identifier.json"
+    return make_api_request(url, endpoint_name="Parcel Identifier")
+
+@mcp.tool()
+async def get_parcel_identifier_geojson() -> str:
+    """Get parcel identifier tools/information in GeoJSON format.
+    
+    Returns:
+        JSON string containing parcel identifier GeoJSON data or error information
+    """
+    url = f"{BASE_URL}/tools/parcel-identifier.geojson"
+    return make_api_request(url, endpoint_name="Parcel Identifier GeoJSON")
+
+# GEOGRAPHICAL REFERENCES - CADASTRAL PARCELS
+@mcp.tool()
+async def get_cadastral_parcels() -> str:
+    """Get list of all cadastral parcels.
+    
+    Returns:
+        JSON string containing cadastral parcels data or error information
+    """
+    url = f"{BASE_URL}/geographical-references/cadastral-parcels.json"
+    return make_api_request(url, endpoint_name="Cadastral Parcels")
+
+@mcp.tool()
+async def get_cadastral_parcel_by_id(parcel_id: str) -> str:
+    """Get specific cadastral parcel information by ID.
+    
+    Args:
+        parcel_id: The cadastral parcel ID to fetch information for
+    
+    Returns:
+        JSON string containing cadastral parcel data or error information
+    """
+    url = f"{BASE_URL}/geographical-references/cadastral-parcels/{parcel_id}.json"
+    return make_api_request(url, endpoint_name=f"Cadastral Parcel {parcel_id}")
+
+@mcp.tool()
+async def get_cadastral_parcel_geolocation(parcel_id: str) -> str:
+    """Get geolocation data for a specific cadastral parcel in GeoJSON format.
+    
+    Args:
+        parcel_id: The cadastral parcel ID to fetch geolocation data for
+    
+    Returns:
+        JSON string containing cadastral parcel geolocation data or error information
+    """
+    url = f"{BASE_URL}/geographical-references/cadastral-parcels/{parcel_id}/geolocation.geojson"
+    return make_api_request(url, endpoint_name=f"Cadastral Parcel {parcel_id} Geolocation")
+
+# GEOGRAPHICAL REFERENCES - CAP PARCELS
+@mcp.tool()
+async def get_cap_parcels() -> str:
+    """Get list of all CAP (Common Agricultural Policy) parcels.
+    
+    Returns:
+        JSON string containing CAP parcels data or error information
+    """
+    url = f"{BASE_URL}/geographical-references/cap-parcels.json"
+    return make_api_request(url, endpoint_name="CAP Parcels")
+
+@mcp.tool()
+async def get_cap_parcel_by_id(cap_id: str) -> str:
+    """Get specific CAP parcel information by ID.
+    
+    Args:
+        cap_id: The CAP parcel ID to fetch information for
+    
+    Returns:
+        JSON string containing CAP parcel data or error information
+    """
+    url = f"{BASE_URL}/geographical-references/cap-parcels/{cap_id}.json"
+    return make_api_request(url, endpoint_name=f"CAP Parcel {cap_id}")
+
+@mcp.tool()
+async def get_cap_parcel_geolocation(cap_id: str) -> str:
+    """Get geolocation data for a specific CAP parcel in GeoJSON format.
+    
+    Args:
+        cap_id: The CAP parcel ID to fetch geolocation data for
+    
+    Returns:
+        JSON string containing CAP parcel geolocation data or error information
+    """
+    url = f"{BASE_URL}/geographical-references/cap-parcels/{cap_id}/geolocation.geojson"
+    return make_api_request(url, endpoint_name=f"CAP Parcel {cap_id} Geolocation")
+
+# GEOGRAPHICAL REFERENCES - MUNICIPALITIES
+@mcp.tool()
+async def get_municipalities() -> str:
+    """Get list of all municipalities.
+    
+    Returns:
+        JSON string containing municipalities data or error information
+    """
+    url = f"{BASE_URL}/geographical-references/municipalities.json"
+    return make_api_request(url, endpoint_name="Municipalities")
+
+@mcp.tool()
+async def get_municipality_by_id(municipality_id: str) -> str:
+    """Get specific municipality information by ID.
+    
+    Args:
+        municipality_id: The municipality ID to fetch information for
+    
+    Returns:
+        JSON string containing municipality data or error information
+    """
+    url = f"{BASE_URL}/geographical-references/municipalities/{municipality_id}.json"
+    return make_api_request(url, endpoint_name=f"Municipality {municipality_id}")
+
+@mcp.tool()
+async def get_municipality_cadastre(municipality_id: str) -> str:
+    """Get cadastre data for a specific municipality in GeoJSON format.
+    
+    Args:
+        municipality_id: The municipality ID to fetch cadastre data for
+    
+    Returns:
+        JSON string containing municipality cadastre data or error information
+    """
+    url = f"{BASE_URL}/geographical-references/municipalities/{municipality_id}/cadastre.geojson"
+    return make_api_request(url, endpoint_name=f"Municipality {municipality_id} Cadastre")
+
+@mcp.tool()
+async def get_municipality_cap_parcels(municipality_id: str) -> str:
+    """Get CAP parcels data for a specific municipality in GeoJSON format.
+    
+    Args:
+        municipality_id: The municipality ID to fetch CAP parcels data for
+    
+    Returns:
+        JSON string containing municipality CAP parcels data or error information
+    """
+    url = f"{BASE_URL}/geographical-references/municipalities/{municipality_id}/cap-parcels.geojson"
+    return make_api_request(url, endpoint_name=f"Municipality {municipality_id} CAP Parcels")
+
+# PRODUCTION
+@mcp.tool()
+async def get_productions() -> str:
+    """Get list of all agricultural productions.
+    
+    Returns:
+        JSON string containing productions data or error information
+    """
+    url = f"{BASE_URL}/production/productions.json"
+    return make_api_request(url, endpoint_name="Productions")
+
+# PHYTOSANITARY
+@mcp.tool()
+async def get_phytosanitary_cropsets() -> str:
+    """Get list of phytosanitary cropsets.
+    
+    Returns:
+        JSON string containing cropsets data or error information
+    """
+    url = f"{BASE_URL}/phytosanitary/cropsets.json"
+    return make_api_request(url, endpoint_name="Phytosanitary Cropsets")
+
+@mcp.tool()
+async def get_phytosanitary_products() -> str:
+    """Get list of phytosanitary products.
+    
+    Returns:
+        JSON string containing phytosanitary products data or error information
+    """
+    url = f"{BASE_URL}/phytosanitary/products.json"
+    return make_api_request(url, endpoint_name="Phytosanitary Products")
+
+@mcp.tool()
+async def get_phytosanitary_symbols() -> str:
+    """Get list of phytosanitary symbols.
+    
+    Returns:
+        JSON string containing phytosanitary symbols data or error information
+    """
+    url = f"{BASE_URL}/phytosanitary/symbols.json"
+    return make_api_request(url, endpoint_name="Phytosanitary Symbols")
+
+# SEEDS
+@mcp.tool()
+async def get_seed_varieties() -> str:
+    """Get list of seed varieties.
+    
+    Returns:
+        JSON string containing seed varieties data or error information
+    """
+    url = f"{BASE_URL}/seeds/varieties.json"
+    return make_api_request(url, endpoint_name="Seed Varieties")
+
+# VITICULTURE
+@mcp.tool()
+async def get_vine_varieties() -> str:
+    """Get list of vine varieties.
+    
+    Returns:
+        JSON string containing vine varieties data or error information
+    """
+    url = f"{BASE_URL}/viticulture/vine-varieties.json"
+    return make_api_request(url, endpoint_name="Vine Varieties")
+
+# WEATHER - Enhanced existing tools
+@mcp.tool()
+async def list_weather_stations() -> str:
+    """Get a list of available weather stations.
+    
+    Returns:
+        JSON string containing available stations or error information
+    """
+    url = f"{BASE_URL}/weather/stations.json"
+    return make_api_request(url, endpoint_name="Weather Stations")
+
+@mcp.tool()
+async def get_weather_station_info(station_code: str) -> str:
+    """Get information about a specific weather station.
+    
+    Args:
+        station_code: The weather station code/ID to fetch information for
+    
+    Returns:
+        JSON string containing weather station information or error information
+    """
+    url = f"{BASE_URL}/weather/stations/{station_code}.json"
+    return make_api_request(url, endpoint_name=f"Weather Station {station_code}")
 
 @mcp.tool()
 async def get_weather_data(station_code: str, page: int = 1, start: str = None, end: str = None) -> str:
@@ -22,14 +308,15 @@ async def get_weather_data(station_code: str, page: int = 1, start: str = None,
     Returns:
         JSON string containing weather data or error information
     """
-    base_url = "https://lexicon.osfarm.org/weather/stations"
-    url = f"{base_url}/{station_code}/hourly-reports.json"
+    url = f"{BASE_URL}/weather/stations/{station_code}/hourly-reports.json"
     
-    params = {
-        "page": page,
-        "start": start if start else "null",
-        "end": end if end else "null"
-    }
+    params = {}
+    if page != 1:
+        params["page"] = page
+    if start:
+        params["start"] = start
+    if end:
+        params["end"] = end
     
     try:
         response = requests.get(url, params=params, timeout=30)
@@ -49,7 +336,7 @@ async def get_weather_data(station_code: str, page: int = 1, start: str = None,
         return json.dumps({
             "type": "error",
             "station_code": station_code,
-            "message": f"Could not connect to weather API at localhost:8888. Please ensure the weather service is running."
+            "message": f"Could not connect to weather API. Please ensure the weather service is running."
         })
     except requests.exceptions.Timeout:
         return json.dumps({