support all clients et upload files5

app.py

@@ -150,8 +150,8 @@ class MCPClientWrapper:
             } for tool in response.tools]
             
             self.connected = True
-            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."
+            tool_names = [tool["name"] for tool in self.tools]
+            return f"✅ Connected to MCP Weather Server. Available tools: {', '.join(tool_names)}"
         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": "❌ LEXICON Agricultural API server is not connected. Please check the connection status above."}
+                {"role": "assistant", "content": "❌ MCP weather 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 requested data.",
+                    "content": f"🔧 I'll use the **{tool_name}** tool to fetch the weather data you requested.",
                     "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_api_response(result_content, tool_name)
+                formatted_response = self._format_weather_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 requested data."
+                    "content": f"🔧 I'll use the **{tool_name}** tool to fetch the weather data you requested."
                 })
                 
                 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_api_response(result_content, tool_name)
+                formatted_response = self._format_weather_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 requested data."
+                    "content": f"🔧 I'll use the **{tool_name}** tool to fetch the weather data you requested."
                 })
                 
                 result = await self.session.call_tool(tool_name, tool_args)
@@ -423,45 +423,47 @@ class MCPClientWrapper:
                 if isinstance(result_content, list):
                     result_content = "\n".join(str(item) for item in result_content)
                 
-                formatted_response = self._format_api_response(result_content, tool_name)
+                formatted_response = self._format_weather_response(result_content, tool_name)
                 result_messages.append(formatted_response)
         
         return result_messages
     
-    def _format_api_response(self, result_content: str, tool_name: str):
-        """Format API response data."""
+    def _format_weather_response(self, result_content: str, tool_name: str):
+        """Format weather data response."""
         try:
             result_json = json.loads(result_content)
             
             if isinstance(result_json, dict):
                 if result_json.get("type") == "success":
-                    data = result_json.get("data", {})
+                    station_code = result_json.get("station_code", "Unknown")
+                    weather_data = result_json.get("data", {})
                     
-                    # 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)
+                    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```"
                     
                     return {
                         "role": "assistant",
                         "content": formatted_response,
                         "metadata": {
-                            "title": f"Data Retrieved: {tool_name}",
+                            "title": f"Weather Data Retrieved",
                             "status": "done",
                             "id": f"success_result_{tool_name}"
                         }
@@ -469,16 +471,17 @@ 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 Data\n\n"
-                    error_response += f"**Tool:** {tool_name}\n"
+                    error_response = f"## ❌ Error Fetching Weather Data\n\n"
+                    error_response += f"**Station:** {station_code}\n"
                     error_response += f"**Error:** {error_msg}\n\n"
                     
                     return {
                         "role": "assistant",
                         "content": error_response,
                         "metadata": {
-                            "title": "API Error",
+                            "title": "Weather API Error",
                             "status": "error",
                             "id": f"error_result_{tool_name}"
                         }
@@ -489,139 +492,22 @@ class MCPClientWrapper:
         
         return {
             "role": "assistant",
-            "content": "```json\n" + result_content + "\n```",
+            "content": "```\n" + result_content + "\n```",
             "metadata": {
-                "title": "Raw API Response",
+                "title": "Raw Tool 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 AGRICULTURAL API ASSISTANT")
+        gr.Markdown("# 🌤️ LEXICON CHATBOT - Multi-LLM Weather Assistant")
         gr.Markdown(
-            "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."
+            "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."
         )
         
         # LLM Provider Selection
@@ -652,7 +538,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
                 )
@@ -661,7 +547,7 @@ def gradio_interface():
         status = gr.Textbox(
             label="🔌 Connection Status", 
             interactive=False, 
-            value="🔄 Connecting to LEXICON Agricultural API server..."
+            value="🔄 Connecting to weather server..."
         )
         
         # Main chat interface
@@ -670,17 +556,17 @@ def gradio_interface():
             height=600,
             type="messages",
             show_copy_button=True,
-            avatar_images=("👤", "🌾"),
+            avatar_images=("👤", "🤖"),
             bubble_full_width=False
         )
         
-        # File upload component
+        # File upload component (already exists in your code!)
         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", ".geojson"
+                ".xml", ".yml", ".yaml", ".ini", ".cfg", ".log", ".sql"
             ],
             height=100
         )
@@ -688,8 +574,8 @@ def gradio_interface():
         # Input row
         with gr.Row(equal_height=True):
             msg = gr.Textbox(
-                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?'",
+                label="💬 Ask about weather data",
+                placeholder="e.g., 'Get weather data for station NYC001' or upload a file with additional context",
                 scale=4
             )
             with gr.Column(scale=1):
@@ -697,56 +583,19 @@ def gradio_interface():
                 clear_btn = gr.Button("🗑️ Clear Chat", size="lg")
                 reconnect_btn = gr.Button("🔄 Reconnect", size="lg")
         
-        # 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
-                    )
+        # 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"
+            )
         
         # Provider/Model update functions
         def update_models(provider):
@@ -819,17 +668,11 @@ if __name__ == "__main__":
     else:
         print("🔑 Available API keys:", ", ".join(available_keys))
     
-    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("🚀 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("🤖 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,297 +3,11 @@ 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("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 = FastMCP("weather_api_server")
 
 @mcp.tool()
 async def get_weather_data(station_code: str, page: int = 1, start: str = None, end: str = None) -> str:
@@ -308,15 +22,14 @@ async def get_weather_data(station_code: str, page: int = 1, start: str = None,
     Returns:
         JSON string containing weather data or error information
     """
-    url = f"{BASE_URL}/weather/stations/{station_code}/hourly-reports.json"
+    base_url = "https://lexicon.osfarm.org/weather/stations"
+    url = f"{base_url}/{station_code}/hourly-reports.json"
     
-    params = {}
-    if page != 1:
-        params["page"] = page
-    if start:
-        params["start"] = start
-    if end:
-        params["end"] = end
+    params = {
+        "page": page,
+        "start": start if start else "null",
+        "end": end if end else "null"
+    }
     
     try:
         response = requests.get(url, params=params, timeout=30)
@@ -336,7 +49,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. Please ensure the weather service is running."
+            "message": f"Could not connect to weather API at localhost:8888. Please ensure the weather service is running."
         })
     except requests.exceptions.Timeout:
         return json.dumps({