add mistra openai fix async

app.py

@@ -1,7 +1,8 @@
 import asyncio
 import os
 import json
-from typing import List, Dict, Any, Union
+import base64
+from typing import List, Dict, Any, Union, Optional
 from contextlib import AsyncExitStack
 
 import gradio as gr
@@ -9,6 +10,8 @@ from gradio.components.chatbot import ChatMessage
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 from anthropic import Anthropic
+from openai import OpenAI
+from mistralai.client import MistralClient
 from dotenv import load_dotenv
 
 load_dotenv()
@@ -20,9 +23,40 @@ class MCPClientWrapper:
     def __init__(self):
         self.session = None
         self.exit_stack = None
-        self.anthropic = Anthropic()
+        self.clients = {}
         self.tools = []
         self.connected = False
+        self.current_provider = "claude"
+        self._init_clients()
+    
+    def _init_clients(self):
+        """Initialize all available LLM clients based on API keys"""
+        if os.getenv("ANTHROPIC_API_KEY"):
+            self.clients["claude"] = Anthropic()
+        
+        if os.getenv("OPENAI_API_KEY"):
+            self.clients["openai"] = OpenAI()
+        
+        if os.getenv("MISTRAL_API_KEY"):
+            self.clients["mistral"] = MistralClient(api_key=os.getenv("MISTRAL_API_KEY"))
+        
+        if os.getenv("LLAMAINDEX_API_KEY"):
+            # Assuming this is for a generic API that accepts OpenAI-compatible format
+            self.clients["llama"] = OpenAI(
+                api_key=os.getenv("LLAMAINDEX_API_KEY"),
+                base_url="https://api.llamaindex.ai/v1"  # Adjust URL as needed
+            )
+    
+    def set_provider(self, provider: str):
+        """Set the current LLM provider"""
+        if provider in self.clients:
+            self.current_provider = provider
+            return f"✅ Switched to {provider.upper()}"
+        return f"❌ {provider.upper()} API key not found"
+    
+    def get_available_providers(self) -> List[str]:
+        """Get list of available providers"""
+        return list(self.clients.keys())
     
     def connect(self) -> str:
         return loop.run_until_complete(self._connect())
@@ -62,18 +96,77 @@ class MCPClientWrapper:
             self.connected = False
             return f"❌ Failed to connect to MCP server: {str(e)}"
     
-    def process_message(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]]) -> tuple:
+    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 to read as text, fallback to binary info
+                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)}"
+    
+    def process_message(self, message: str, files: Optional[List], history: List[Union[Dict[str, Any], ChatMessage]]) -> tuple:
         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."}
-            ], gr.Textbox(value="")
+            ], gr.Textbox(value=""), None
+        
+        # Process uploaded files
+        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"\n📄 File: {os.path.basename(file_path)}\n{content}\n"
+            file_content += "--- END FILES ---\n\n"
         
-        new_messages = loop.run_until_complete(self._process_query(message, history))
-        return history + [{"role": "user", "content": message}] + new_messages, gr.Textbox(value="")
+        # Combine message with file content
+        full_message = file_content + message if file_content else message
+        
+        new_messages = loop.run_until_complete(self._process_query(full_message, history))
+        return history + [{"role": "user", "content": message}] + new_messages, gr.Textbox(value=""), None
     
     async def _process_query(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]]):
+        if self.current_provider not in self.clients:
+            return [{"role": "assistant", "content": f"❌ {self.current_provider.upper()} client not available"}]
+        
+        client = self.clients[self.current_provider]
         claude_messages = []
+        
         for msg in history:
             if isinstance(msg, ChatMessage):
                 role, content = msg.role, msg.content
@@ -85,21 +178,64 @@ class MCPClientWrapper:
         
         claude_messages.append({"role": "user", "content": message})
         
-        response = self.anthropic.messages.create(
-            model="claude-3-5-sonnet-20241022",
-            max_tokens=1500,
-            messages=claude_messages,
-            tools=self.tools
-        )
-
+        try:
+            if self.current_provider == "claude":
+                response = client.messages.create(
+                    model="claude-3-5-sonnet-20241022",
+                    max_tokens=1500,
+                    messages=claude_messages,
+                    tools=self.tools
+                )
+                return await self._process_claude_response(response, claude_messages)
+            
+            elif self.current_provider == "openai":
+                # Convert tools format for OpenAI
+                openai_tools = []
+                for tool in self.tools:
+                    openai_tools.append({
+                        "type": "function",
+                        "function": {
+                            "name": tool["name"],
+                            "description": tool["description"],
+                            "parameters": tool["input_schema"]
+                        }
+                    })
+                
+                response = client.chat.completions.create(
+                    model="gpt-4-turbo-preview",
+                    max_tokens=1500,
+                    messages=claude_messages,
+                    tools=openai_tools if openai_tools else None
+                )
+                return await self._process_openai_response(response, claude_messages)
+            
+            elif self.current_provider == "mistral":
+                response = client.chat(
+                    model="mistral-large-latest",
+                    max_tokens=1500,
+                    messages=claude_messages,
+                    tools=self.tools if self.tools else None
+                )
+                return await self._process_mistral_response(response, claude_messages)
+            
+            elif self.current_provider == "llama":
+                response = client.chat.completions.create(
+                    model="llama-2-70b-chat",  # Adjust model name as needed
+                    max_tokens=1500,
+                    messages=claude_messages,
+                    tools=self.tools if self.tools else None
+                )
+                return await self._process_openai_response(response, claude_messages)  # Same format as OpenAI
+                
+        except Exception as e:
+            return [{"role": "assistant", "content": f"❌ Error with {self.current_provider}: {str(e)}"}]
+    
+    async def _process_claude_response(self, response, claude_messages):
         result_messages = []
         
         for content in response.content:
             if content.type == 'text':
-                result_messages.append({
-                    "role": "assistant", 
-                    "content": content.text
-                })
+                result_messages.append({"role": "assistant", "content": content.text})
                 
             elif content.type == 'tool_use':
                 tool_name = content.name
@@ -107,138 +243,24 @@ class MCPClientWrapper:
                 
                 result_messages.append({
                     "role": "assistant",
-                    "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)}",
-                        "status": "pending",
-                        "id": f"tool_call_{tool_name}"
-                    }
-                })
-                
-                result_messages.append({
-                    "role": "assistant",
-                    "content": "```json\n" + json.dumps(tool_args, indent=2, ensure_ascii=True) + "\n```",
-                    "metadata": {
-                        "parent_id": f"tool_call_{tool_name}",
-                        "id": f"params_{tool_name}",
-                        "title": "Tool Parameters"
-                    }
+                    "content": f"🔧 I'll use the **{tool_name}** tool to fetch the data you requested.",
+                    "metadata": {"title": f"Using tool: {tool_name}", "status": "pending"}
                 })
                 
                 result = await self.session.call_tool(tool_name, tool_args)
-                
-                if result_messages and "metadata" in result_messages[-2]:
-                    result_messages[-2]["metadata"]["status"] = "done"
-                
                 result_content = result.content
                 if isinstance(result_content, list):
                     result_content = "\n".join(str(item) for item in result_content)
                 
-                # Parse and format the weather data response
-                try:
-                    result_json = json.loads(result_content)
-                    
-                    if isinstance(result_json, dict):
-                        if result_json.get("type") == "success":
-                            # Format successful weather data response
-                            station_code = result_json.get("station_code", "Unknown")
-                            weather_data = result_json.get("data", {})
-                            
-                            # Create a nicely formatted response
-                            formatted_response = f"## 🌤️ Weather Data for Station: {station_code}\n\n"
-                            
-                            if isinstance(weather_data, dict):
-                                # Show key weather information if available
-                                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"
-                                        # Show first few reports as example
-                                        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```"
-                            else:
-                                formatted_response += "**Raw Data:**\n```json\n" + json.dumps(weather_data, indent=2) + "\n```"
-                            
-                            result_messages.append({
-                                "role": "assistant",
-                                "content": formatted_response,
-                                "metadata": {
-                                    "title": f"Weather Data Retrieved",
-                                    "status": "done",
-                                    "id": f"success_result_{tool_name}"
-                                }
-                            })
-                            
-                        elif result_json.get("type") == "error":
-                            # Format error response
-                            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:** {error_msg}\n\n"
-                            error_response += "**Suggestions:**\n"
-                            error_response += "- Check if the station code is correct\n"
-                            error_response += "- Ensure the weather API service is running on localhost:8888\n"
-                            error_response += "- Try a different station code\n"
-                            
-                            result_messages.append({
-                                "role": "assistant",
-                                "content": error_response,
-                                "metadata": {
-                                    "title": "Weather API Error",
-                                    "status": "error",
-                                    "id": f"error_result_{tool_name}"
-                                }
-                            })
-                        else:
-                            # Unknown response format
-                            result_messages.append({
-                                "role": "assistant",
-                                "content": "```json\n" + result_content + "\n```",
-                                "metadata": {
-                                    "title": "Raw Tool Response",
-                                    "status": "done",
-                                    "id": f"raw_result_{tool_name}"
-                                }
-                            })
-                    else:
-                        result_messages.append({
-                            "role": "assistant",
-                            "content": "```\n" + result_content + "\n```",
-                            "metadata": {
-                                "title": "Raw Tool Response",
-                                "status": "done",
-                                "id": f"raw_result_{tool_name}"
-                            }
-                        })
-                        
-                except json.JSONDecodeError:
-                    result_messages.append({
-                        "role": "assistant",
-                        "content": "```\n" + result_content + "\n```",
-                        "metadata": {
-                            "title": "Raw Tool Response",
-                            "status": "done",
-                            "id": f"raw_result_{tool_name}"
-                        }
-                    })
+                result_messages.append({
+                    "role": "assistant",
+                    "content": self._format_tool_result(result_content),
+                    "metadata": {"title": "Tool Result", "status": "done"}
+                })
                 
-                # Let Claude analyze and respond to the weather data
+                # Get Claude's analysis of the result
                 claude_messages.append({"role": "user", "content": f"Tool result for {tool_name}: {result_content}"})
-                next_response = self.anthropic.messages.create(
+                next_response = self.clients["claude"].messages.create(
                     model="claude-3-5-sonnet-20241022",
                     max_tokens=1500,
                     messages=claude_messages,
@@ -249,26 +271,123 @@ class MCPClientWrapper:
                         "role": "assistant",
                         "content": next_response.content[0].text
                     })
-
+        
+        return result_messages
+    
+    async def _process_openai_response(self, response, claude_messages):
+        result_messages = []
+        message = response.choices[0].message
+        
+        if message.content:
+            result_messages.append({"role": "assistant", "content": message.content})
+        
+        if message.tool_calls:
+            for tool_call in message.tool_calls:
+                tool_name = tool_call.function.name
+                tool_args = json.loads(tool_call.function.arguments)
+                
+                result_messages.append({
+                    "role": "assistant",
+                    "content": f"🔧 Using **{tool_name}** tool...",
+                    "metadata": {"title": f"Tool: {tool_name}", "status": "pending"}
+                })
+                
+                result = await self.session.call_tool(tool_name, tool_args)
+                result_content = result.content
+                if isinstance(result_content, list):
+                    result_content = "\n".join(str(item) for item in result_content)
+                
+                result_messages.append({
+                    "role": "assistant",
+                    "content": self._format_tool_result(result_content),
+                    "metadata": {"title": "Tool Result", "status": "done"}
+                })
+        
+        return result_messages
+    
+    async def _process_mistral_response(self, response, claude_messages):
+        result_messages = []
+        message = response.choices[0].message
+        
+        if message.content:
+            result_messages.append({"role": "assistant", "content": message.content})
+        
         return result_messages
+    
+    def _format_tool_result(self, result_content: str) -> str:
+        """Format tool result for display"""
+        try:
+            result_json = json.loads(result_content)
+            if isinstance(result_json, dict) and result_json.get("type") == "success":
+                station_code = result_json.get("station_code", "Unknown")
+                weather_data = result_json.get("data", {})
+                
+                formatted_response = f"## 🌤️ Weather Data for Station: {station_code}\n\n"
+                
+                if isinstance(weather_data, dict) and "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"
+                
+                return formatted_response
+            
+            elif isinstance(result_json, dict) and result_json.get("type") == "error":
+                error_msg = result_json.get("message", "Unknown error")
+                return f"## ❌ Error\n\n{error_msg}"
+            
+            return f"```json\n{json.dumps(result_json, indent=2)}\n```"
+            
+        except json.JSONDecodeError:
+            return f"```\n{result_content}\n```"
 
 client = MCPClientWrapper()
 
 def gradio_interface():
     with gr.Blocks(title="MCP LEXICON", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🌤️ LEXICON CHATBOT - ask me anything")
+        gr.Markdown("# 🌤️ LEXICON CHATBOT - Multi-LLM Weather Assistant")
         gr.Markdown(
-            "Ask me about weather data from any weather station! I can fetch hourly reports, "
-            "help you explore weather patterns, and answer questions about specific stations. "
-            "Just ask naturally - for example: *'Get weather data for station ABC123'* or *'What stations are available?'*"
+            "Ask me about weather data from any weather station! Upload files for additional context. "
+            "I can fetch hourly reports, help you explore weather patterns, and answer questions about specific stations."
         )
         
-        # Connection status (auto-updates on load)
-        status = gr.Textbox(
-            label="🔌 Connection Status", 
-            interactive=False, 
-            value="🔄 Connecting to weather server..."
-        )
+        # Settings row
+        with gr.Row():
+            # LLM Provider selection
+            available_providers = client.get_available_providers()
+            if available_providers:
+                provider_choice = gr.Dropdown(
+                    choices=available_providers,
+                    value=client.current_provider if client.current_provider in available_providers else available_providers[0],
+                    label="🤖 LLM Provider",
+                    scale=1
+                )
+            else:
+                provider_choice = gr.Dropdown(
+                    choices=["No API keys found"],
+                    value="No API keys found",
+                    label="🤖 LLM Provider",
+                    scale=1,
+                    interactive=False
+                )
+            
+            # Connection status
+            status = gr.Textbox(
+                label="🔌 MCP Connection", 
+                interactive=False, 
+                value="🔄 Connecting...",
+                scale=2
+            )
         
         # Main chat interface
         chatbot = gr.Chatbot(
@@ -280,53 +399,106 @@ def gradio_interface():
             bubble_full_width=False
         )
         
-        # 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 'Show me available weather stations' or 'What's the latest data from station LAX123?'",
-                scale=4
-            )
-            with gr.Column(scale=1):
-                clear_btn = gr.Button("🗑️ Clear Chat", size="lg")
-                reconnect_btn = gr.Button("🔄 Reconnect", size="lg")
+        # Input row with file upload
+        with gr.Row():
+            with gr.Column(scale=4):
+                msg = gr.Textbox(
+                    label="💬 Message",
+                    placeholder="Ask about weather data or upload files for context...",
+                    lines=2
+                )
+            with gr.Column(scale=2):
+                file_upload = gr.File(
+                    label="📎 Upload Files",
+                    file_count="multiple",
+                    file_types=[".txt", ".pdf", ".csv", ".json", ".md", ".py", ".js", ".html", ".xml", ".yaml"]
+                )
         
-        # Example queries
+        # Control buttons
         with gr.Row():
+            submit_btn = gr.Button("Send", variant="primary", scale=2)
+            clear_btn = gr.Button("🗑️ Clear", scale=1)
+            reconnect_btn = gr.Button("🔄 Reconnect MCP", scale=1)
+        
+        # Example queries
+        with gr.Accordion("💡 Example Queries", open=False):
             gr.Examples(
                 examples=[
                     "What weather stations are available?",
                     "Get weather data for station ABC123",
-                    "Show me the latest hourly reports for station NYC001",
-                    "Get weather data for station LAX789 from page 2",
-                    "Fetch weather data for station CHI456 between 2024-01-01 and 2024-01-31"
+                    "Show me the latest reports for NYC001",
+                    "Compare weather patterns between two stations",
+                    "Analyze the uploaded CSV data with weather information"
                 ],
-                inputs=msg,
-                label="💡 Example Queries"
+                inputs=msg
             )
         
-        # Auto-connect when the interface loads
+        # Event handlers
         def auto_connect():
             return client.connect()
         
-        # Event handlers
+        def change_provider(provider):
+            if provider != "No API keys found":
+                result = client.set_provider(provider)
+                return result
+            return "❌ No valid provider selected"
+        
+        def process_and_clear(message, files, history):
+            if not message.strip() and not files:
+                return history, "", None
+            return client.process_message(message, files, history)
+        
+        # Setup events
         demo.load(auto_connect, outputs=status)
-        msg.submit(client.process_message, [msg, chatbot], [chatbot, msg])
-        clear_btn.click(lambda: [], None, chatbot)
+        
+        provider_choice.change(
+            change_provider, 
+            inputs=provider_choice, 
+            outputs=gr.Textbox(visible=False)  # Hidden output for status
+        )
+        
+        submit_btn.click(
+            process_and_clear,
+            inputs=[msg, file_upload, chatbot],
+            outputs=[chatbot, msg, file_upload]
+        )
+        
+        msg.submit(
+            process_and_clear,
+            inputs=[msg, file_upload, chatbot],
+            outputs=[chatbot, msg, file_upload]
+        )
+        
+        clear_btn.click(lambda: ([], "", None), outputs=[chatbot, msg, file_upload])
         reconnect_btn.click(auto_connect, outputs=status)
         
     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 or environment variables.")
-        print("Example .env file content:")
-        print("ANTHROPIC_API_KEY=your_api_key_here")
+    # Check for API keys
+    api_keys = {
+        "ANTHROPIC_API_KEY": "Claude",
+        "OPENAI_API_KEY": "OpenAI", 
+        "MISTRAL_API_KEY": "Mistral",
+        "LLAMAINDEX_API_KEY": "Llama"
+    }
+    
+    found_keys = []
+    for key, name in api_keys.items():
+        if os.getenv(key):
+            found_keys.append(name)
+    
+    if found_keys:
+        print(f"🔑 Found API keys for: {', '.join(found_keys)}")
+    else:
+        print("⚠️  Warning: No API keys found in environment.")
+        print("Please set them in your .env file:")
+        for key in api_keys.keys():
+            print(f"{key}=your_key_here")
     
-    print("🚀 Starting MCP Weather Client...")
-    print("📡 Will auto-connect to gradio_mcp_server.py")
-    print("🌐 Weather API endpoint: http://localhost:8888/weather/stations")
+    print("🚀 Starting MCP Multi-LLM Weather Client...")
+    print("🔡 Will auto-connect to gradio_mcp_server.py")
+    print("🌐 Weather API endpoint: https://lexicon.osfarm.org/weather/stations")
     
     interface = gradio_interface()
     interface.launch(debug=True, share=True)

gradio_mcp_server.py

@@ -7,108 +7,226 @@ 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("weather_api_server")
+mcp = FastMCP("lexicon_api_server")
 
-@mcp.tool()
-async def get_weather_data(station_code: str, page: int = 1, start: str = None, end: str = None) -> str:
-    """Get hourly weather reports from a weather station.
-    
-    Args:
-        station_code: The weather station code/ID to fetch data from
-        page: Page number for pagination (default: 1)
-        start: Start date/time filter in ISO format (optional, e.g., '2024-01-01T00:00:00Z')
-        end: End date/time filter in ISO format (optional, e.g., '2024-01-31T23:59:59Z')
-    
-    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"
-    
-    params = {
-        "page": page,
-        "start": start if start else "null",
-        "end": end if end else "null"
-    }
+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()
         
-        weather_data = response.json()
+        # 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",
-            "station_code": station_code,
-            "data": weather_data,
-            "request_params": params,
-            "message": f"Successfully retrieved weather data for station {station_code}"
+            "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",
-            "station_code": station_code,
-            "message": f"Could not connect to weather API at localhost:8888. Please ensure the weather service is running."
+            "endpoint": endpoint,
+            "message": f"Could not connect to API. Please ensure the service is running."
         })
     except requests.exceptions.Timeout:
         return json.dumps({
             "type": "error",
-            "station_code": station_code,
-            "message": f"Request timed out while fetching data for station {station_code}"
+            "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",
-            "station_code": station_code,
+            "endpoint": endpoint,
             "status_code": status_code,
-            "message": f"HTTP error {status_code} when fetching data for station {station_code}. Station may not exist or API may be unavailable."
+            "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",
-            "station_code": station_code,
-            "message": f"Invalid JSON response received from weather API for station {station_code}"
+            "endpoint": endpoint,
+            "message": f"Invalid JSON response from {endpoint}"
         })
     except Exception as e:
         return json.dumps({
             "type": "error",
-            "station_code": station_code,
-            "message": f"Unexpected error fetching weather data: {str(e)}"
+            "endpoint": endpoint,
+            "message": f"Unexpected error: {str(e)}"
         })
 
+# WEATHER TOOLS
+@mcp.tool()
+async def get_weather_stations() -> str:
+    """Get a list of all available weather stations"""
+    return make_api_request("/weather/stations.json")
+
 @mcp.tool()
-async def list_available_stations() -> str:
-    """Get a list of available weather stations from the API.
+async def get_weather_station(station_code: str) -> str:
+    """Get details of a specific weather station
     
-    Returns:
-        JSON string containing available stations or error information
+    Args:
+        station_code: The weather station code/ID
     """
-    base_url = "http://localhost:8888/weather/stations"
+    return make_api_request(f"/weather/stations/{station_code}.json")
+
+@mcp.tool()
+async def get_weather_data(station_code: str, page: int = 1, start: str = None, end: str = None) -> str:
+    """Get hourly weather reports from a weather station.
     
-    try:
-        response = requests.get(base_url, timeout=30)
-        response.raise_for_status()
-        
-        stations_data = response.json()
-        
-        return json.dumps({
-            "type": "success",
-            "data": stations_data,
-            "message": "Successfully retrieved list of available weather stations"
-        }, indent=2)
-        
-    except requests.exceptions.ConnectionError:
-        return json.dumps({
-            "type": "error",
-            "message": "Could not connect to weather API at localhost:8888. Please ensure the weather service is running."
-        })
-    except Exception as e:
-        return json.dumps({
-            "type": "error",
-            "message": f"Error fetching station list: {str(e)}"
-        })
+    Args:
+        station_code: The weather station code/ID to fetch data from
+        page: Page number for pagination (default: 1)
+        start: Start date/time filter in ISO format (optional, e.g., '2024-01-01T00:00:00Z')
+        end: End date/time filter in ISO format (optional, e.g., '2024-01-31T23:59:59Z')
+    """
+    params = {"page": page}
+    if start:
+        params["start"] = start
+    if end:
+        params["end"] = end
+    
+    return make_api_request(f"/weather/stations/{station_code}/hourly-reports.json", params)
+
+# TOOLS
+@mcp.tool()
+async def get_parcel_identifier_json() -> str:
+    """Get parcel identifier tool data in JSON format"""
+    return make_api_request("/tools/parcel-identifier.json")
+
+@mcp.tool()
+async def get_parcel_identifier_geojson() -> str:
+    """Get parcel identifier tool data in GeoJSON format"""
+    return make_api_request("/tools/parcel-identifier.geojson")
+
+# GEOGRAPHICAL REFERENCES - CADASTRAL PARCELS
+@mcp.tool()
+async def get_cadastral_parcels() -> str:
+    """Get list of all cadastral parcels"""
+    return make_api_request("/geographical-references/cadastral-parcels.json")
+
+@mcp.tool()
+async def get_cadastral_parcel(parcel_id: str) -> str:
+    """Get details of a specific cadastral parcel
+    
+    Args:
+        parcel_id: The cadastral parcel ID
+    """
+    return make_api_request(f"/geographical-references/cadastral-parcels/{parcel_id}.json")
+
+@mcp.tool()
+async def get_cadastral_parcel_geolocation(parcel_id: str) -> str:
+    """Get geolocation data for a cadastral parcel in GeoJSON format
+    
+    Args:
+        parcel_id: The cadastral parcel ID
+    """
+    return make_api_request(f"/geographical-references/cadastral-parcels/{parcel_id}/geolocation.geojson")
+
+# GEOGRAPHICAL REFERENCES - CAP PARCELS
+@mcp.tool()
+async def get_cap_parcels() -> str:
+    """Get list of all CAP (Common Agricultural Policy) parcels"""
+    return make_api_request("/geographical-references/cap-parcels.json")
+
+@mcp.tool()
+async def get_cap_parcel(cap_id: str) -> str:
+    """Get details of a specific CAP parcel
+    
+    Args:
+        cap_id: The CAP parcel ID
+    """
+    return make_api_request(f"/geographical-references/cap-parcels/{cap_id}.json")
+
+@mcp.tool()
+async def get_cap_parcel_geolocation(cap_id: str) -> str:
+    """Get geolocation data for a CAP parcel in GeoJSON format
+    
+    Args:
+        cap_id: The CAP parcel ID
+    """
+    return make_api_request(f"/geographical-references/cap-parcels/{cap_id}/geolocation.geojson")
+
+# GEOGRAPHICAL REFERENCES - MUNICIPALITIES
+@mcp.tool()
+async def get_municipalities() -> str:
+    """Get list of all municipalities"""
+    return make_api_request("/geographical-references/municipalities.json")
+
+@mcp.tool()
+async def get_municipality(municipality_id: str) -> str:
+    """Get details of a specific municipality
+    
+    Args:
+        municipality_id: The municipality ID
+    """
+    return make_api_request(f"/geographical-references/municipalities/{municipality_id}.json")
+
+@mcp.tool()
+async def get_municipality_cadastre(municipality_id: str) -> str:
+    """Get cadastre data for a municipality in GeoJSON format
+    
+    Args:
+        municipality_id: The municipality ID
+    """
+    return make_api_request(f"/geographical-references/municipalities/{municipality_id}/cadastre.geojson")
+
+@mcp.tool()
+async def get_municipality_cap_parcels(municipality_id: str) -> str:
+    """Get CAP parcels geolocation data for a municipality in GeoJSON format
+    
+    Args:
+        municipality_id: The municipality ID
+    """
+    return make_api_request(f"/geographical-references/municipalities/{municipality_id}/cap-parcels.geojson")
+
+# PRODUCTION
+@mcp.tool()
+async def get_productions() -> str:
+    """Get list of all production data"""
+    return make_api_request("/production/productions.json")
+
+# PHYTOSANITARY
+@mcp.tool()
+async def get_cropsets() -> str:
+    """Get list of all phytosanitary cropsets"""
+    return make_api_request("/phytosanitary/cropsets.json")
+
+@mcp.tool()
+async def get_phytosanitary_products() -> str:
+    """Get list of all phytosanitary products"""
+    return make_api_request("/phytosanitary/products.json")
+
+@mcp.tool()
+async def get_phytosanitary_symbols() -> str:
+    """Get list of all phytosanitary symbols"""
+    return make_api_request("/phytosanitary/symbols.json")
+
+# SEEDS
+@mcp.tool()
+async def get_seed_varieties() -> str:
+    """Get list of all seed varieties"""
+    return make_api_request("/seeds/varieties.json")
+
+# VITICULTURE
+@mcp.tool()
+async def get_vine_varieties() -> str:
+    """Get list of all vine varieties"""
+    return make_api_request("/viticulture/vine-varieties.json")
 
 if __name__ == "__main__":
     mcp.run(transport='stdio')

requirements.txt

@@ -2,4 +2,5 @@ gradio[mcp]
 anthropic 
 mcp
 openai
-mistralai
+mistralai==0.4.2
+PyPDF2