fix async error2

app.py

@@ -1,159 +1,51 @@
 import asyncio
 import os
 import json
-from typing import List, Dict, Any, Union, Optional
+from typing import List, Dict, Any, Union
 from contextlib import AsyncExitStack
-import mimetypes
-import tempfile
-import threading
-from concurrent.futures import ThreadPoolExecutor
 
 import gradio as gr
 from gradio.components.chatbot import ChatMessage
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 from anthropic import Anthropic
-from openai import OpenAI
-from mistralai.client import MistralClient
 from dotenv import load_dotenv
 
 load_dotenv()
 
+loop = asyncio.new_event_loop()
+asyncio.set_event_loop(loop)
+
 class MCPClientWrapper:
     def __init__(self):
-        self.session: Optional[ClientSession] = None
-        self.exit_stack: Optional[AsyncExitStack] = None
+        self.session = None
+        self.exit_stack = None
+        self.anthropic = Anthropic()
         self.tools = []
         self.connected = False
-        self._connection_lock = threading.Lock()
-        
-        # Initialize all LLM clients
-        self.anthropic_client = None
-        self.openai_client = None
-        self.mistral_client = None
-        self.llama_client = None
-        
-        # Current selected provider and model
-        self.current_provider = "claude"
-        self.current_model = "claude-3-5-sonnet-20241022"
-        
-        self._initialize_clients()
     
-    def _initialize_clients(self):
-        """Initialize available LLM clients based on environment variables."""
-        try:
-            if os.getenv("ANTHROPIC_API_KEY"):
-                self.anthropic_client = Anthropic()
-        except Exception as e:
-            print(f"⚠️ Failed to initialize Anthropic client: {e}")
+    def connect(self) -> str:
+        return loop.run_until_complete(self._connect())
+    
+    async def _connect(self) -> str:
+        if self.exit_stack:
+            await self.exit_stack.aclose()
         
-        try:
-            if os.getenv("OPENAI_API_KEY"):
-                self.openai_client = OpenAI()
-        except Exception as e:
-            print(f"⚠️ Failed to initialize OpenAI client: {e}")
+        self.exit_stack = AsyncExitStack()
         
-        try:
-            if os.getenv("MISTRAL_API_KEY"):
-                self.mistral_client = MistralClient(api_key=os.getenv("MISTRAL_API_KEY"))
-        except Exception as e:
-            print(f"⚠️ Failed to initialize Mistral client: {e}")
+        server_path = "gradio_mcp_server.py"
+        
+        server_params = StdioServerParameters(
+            command="python",
+            args=[server_path],
+            env={"PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"}
+        )
         
         try:
-            if os.getenv("LLAMAINDEX_API_KEY"):
-                self.llama_client = OpenAI(
-                    api_key=os.getenv("LLAMAINDEX_API_KEY"),
-                    base_url="https://api.llamaindex.ai/v1"
-                )
-        except Exception as e:
-            print(f"⚠️ Failed to initialize Llama client: {e}")
-    
-    def get_available_providers(self):
-        """Get list of available LLM providers."""
-        providers = {}
-        if self.anthropic_client:
-            providers["claude"] = {
-                "name": "Claude (Anthropic)",
-                "models": [
-                    "claude-3-5-sonnet-20241022",
-                    "claude-3-5-haiku-20241022",
-                    "claude-3-opus-20240229"
-                ]
-            }
-        if self.openai_client:
-            providers["openai"] = {
-                "name": "OpenAI",
-                "models": [
-                    "gpt-4o",
-                    "gpt-4o-mini",
-                    "gpt-4-turbo",
-                    "gpt-3.5-turbo"
-                ]
-            }
-        if self.mistral_client:
-            providers["mistral"] = {
-                "name": "Mistral AI",
-                "models": [
-                    "mistral-large-latest",
-                    "mistral-medium-latest",
-                    "mistral-small-latest",
-                    "open-mixtral-8x7b"
-                ]
-            }
-        if self.llama_client:
-            providers["llama"] = {
-                "name": "Llama",
-                "models": [
-                    "llama-3.1-70b-instruct",
-                    "llama-3.1-8b-instruct",
-                    "llama-2-70b-chat"
-                ]
-            }
-        return providers
-    
-    def update_provider(self, provider: str, model: str):
-        """Update the current provider and model."""
-        self.current_provider = provider
-        self.current_model = model
-        return f"✅ Switched to {provider}: {model}"
-    
-    async def _cleanup_connection(self):
-        """Safely cleanup existing connection."""
-        if self.exit_stack:
-            try:
-                await self.exit_stack.aclose()
-            except Exception as e:
-                print(f"Warning: Error during cleanup: {e}")
-            finally:
-                self.exit_stack = None
-                self.session = None
-                self.connected = False
-    
-    async def _establish_connection(self) -> str:
-        """Establish MCP connection in proper async context."""
-        try:
-            # Clean up any existing connection
-            await self._cleanup_connection()
-            
-            self.exit_stack = AsyncExitStack()
-            
-            server_path = "gradio_mcp_server.py"
-            server_params = StdioServerParameters(
-                command="python",
-                args=[server_path],
-                env={"PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"}
-            )
-            
-            # Enter the async context managers
-            stdio_transport = await self.exit_stack.enter_async_context(
-                stdio_client(server_params)
-            )
-            stdio, write = stdio_transport
-            
-            self.session = await self.exit_stack.enter_async_context(
-                ClientSession(stdio, write)
-            )
+            stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+            self.stdio, self.write = stdio_transport
             
+            self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
             await self.session.initialize()
             
             response = await self.session.list_tools()
@@ -166,203 +58,21 @@ class MCPClientWrapper:
             self.connected = True
             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
-            await self._cleanup_connection()
             return f"❌ Failed to connect to MCP server: {str(e)}"
     
-    def connect(self) -> str:
-        """Thread-safe connection method for Gradio."""
-        with self._connection_lock:
-            try:
-                # Create new event loop for this operation
-                try:
-                    loop = asyncio.get_event_loop()
-                except RuntimeError:
-                    loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(loop)
-                
-                if loop.is_running():
-                    # If loop is already running, we need to run in a thread
-                    import concurrent.futures
-                    with concurrent.futures.ThreadPoolExecutor() as executor:
-                        future = executor.submit(self._run_connection_in_new_loop)
-                        return future.result()
-                else:
-                    return loop.run_until_complete(self._establish_connection())
-            except Exception as e:
-                return f"❌ Connection error: {str(e)}"
-    
-    def _run_connection_in_new_loop(self) -> str:
-        """Run connection in a new event loop (for thread safety)."""
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        try:
-            return loop.run_until_complete(self._establish_connection())
-        finally:
-            loop.close()
-    
-    def read_uploaded_file(self, file_path: str) -> str:
-        """Read and process uploaded file content."""
-        if not file_path or not os.path.exists(file_path):
-            return ""
-        
-        try:
-            file_size = os.path.getsize(file_path)
-            file_name = os.path.basename(file_path)
-            mime_type, _ = mimetypes.guess_type(file_path)
-            
-            if file_size > 10 * 1024 * 1024:
-                return f"\n\n📄 **File Upload Error**: {file_name} is too large (>10MB). Please upload a smaller file."
-            
-            encodings_to_try = ['utf-8', 'utf-16', 'latin-1', 'cp1252']
-            
-            for encoding in encodings_to_try:
-                try:
-                    with open(file_path, 'r', encoding=encoding) as f:
-                        content = f.read()
-                    
-                    max_chars = 50000
-                    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}"
-                    if mime_type:
-                        file_info += f" ({mime_type})"
-                    file_info += f" - {file_size:,} bytes\n\n```\n{content}\n```"
-                    
-                    return file_info
-                    
-                except UnicodeDecodeError:
-                    continue
-            
-            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)}"
-    
-    def _convert_tools_for_provider(self, provider: str):
-        """Convert MCP tools format to provider-specific format."""
-        if provider == "claude":
-            return self.tools
-        elif provider in ["openai", "llama"]:
-            openai_tools = []
-            for tool in self.tools:
-                openai_tools.append({
-                    "type": "function",
-                    "function": {
-                        "name": tool["name"],
-                        "description": tool["description"],
-                        "parameters": tool["input_schema"]
-                    }
-                })
-            return openai_tools
-        elif provider == "mistral":
-            mistral_tools = []
-            for tool in self.tools:
-                mistral_tools.append({
-                    "type": "function",
-                    "function": {
-                        "name": tool["name"],
-                        "description": tool["description"],
-                        "parameters": tool["input_schema"]
-                    }
-                })
-            return mistral_tools
-        else:
-            return []
-    
-    async def _call_llm(self, messages: List[Dict], provider: str, model: str):
-        """Call the appropriate LLM based on provider."""
-        try:
-            if provider == "claude" and self.anthropic_client:
-                return self.anthropic_client.messages.create(
-                    model=model,
-                    max_tokens=1500,
-                    messages=messages,
-                    tools=self._convert_tools_for_provider(provider)
-                )
-            elif provider == "openai" and self.openai_client:
-                return self.openai_client.chat.completions.create(
-                    model=model,
-                    max_tokens=1500,
-                    messages=messages,
-                    tools=self._convert_tools_for_provider(provider)
-                )
-            elif provider == "llama" and self.llama_client:
-                return self.llama_client.chat.completions.create(
-                    model=model,
-                    max_tokens=1500,
-                    messages=messages,
-                    tools=self._convert_tools_for_provider(provider)
-                )
-            elif provider == "mistral" and self.mistral_client:
-                return self.mistral_client.chat(
-                    model=model,
-                    max_tokens=1500,
-                    messages=messages,
-                    tools=self._convert_tools_for_provider(provider)
-                )
-            else:
-                raise Exception(f"Provider {provider} not available or not initialized")
-        except Exception as e:
-            raise Exception(f"Error calling {provider}: {str(e)}")
-    
-    def process_message(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]], uploaded_file) -> tuple:
-        """Process message in thread-safe manner."""
+    def process_message(self, message: str, 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.File(value=None)
-        
-        # Process uploaded file if present
-        file_content = ""
-        if uploaded_file:
-            file_content = self.read_uploaded_file(uploaded_file.name if hasattr(uploaded_file, 'name') else uploaded_file)
+            ], gr.Textbox(value="")
         
-        # Combine message with file content
-        full_message = message + file_content
-        
-        try:
-            # Run async processing in new event loop
-            new_messages = self._run_async_processing(full_message, history)
-            return history + [{"role": "user", "content": full_message}] + new_messages, gr.Textbox(value=""), gr.File(value=None)
-        except Exception as e:
-            return history + [
-                {"role": "user", "content": full_message},
-                {"role": "assistant", "content": f"❌ Error processing message: {str(e)}"}
-            ], gr.Textbox(value=""), gr.File(value=None)
-    
-    def _run_async_processing(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]]):
-        """Run async message processing in new event loop."""
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-        
-        if loop.is_running():
-            # Run in thread if event loop is already running
-            import concurrent.futures
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(self._process_in_new_loop, message, history)
-                return future.result()
-        else:
-            return loop.run_until_complete(self._process_query(message, history))
-    
-    def _process_in_new_loop(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]]):
-        """Process query in a completely new event loop."""
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        try:
-            return loop.run_until_complete(self._process_query(message, history))
-        finally:
-            loop.close()
+        new_messages = loop.run_until_complete(self._process_query(message, history))
+        return history + [{"role": "user", "content": message}] + new_messages, gr.Textbox(value="")
     
     async def _process_query(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]]):
-        """Process the actual query with LLM and tools."""
         claude_messages = []
         for msg in history:
             if isinstance(msg, ChatMessage):
@@ -375,23 +85,13 @@ class MCPClientWrapper:
         
         claude_messages.append({"role": "user", "content": message})
         
-        try:
-            response = await self._call_llm(claude_messages, self.current_provider, self.current_model)
-        except Exception as e:
-            return [{"role": "assistant", "content": f"❌ Error with {self.current_provider}: {str(e)}"}]
+        response = self.anthropic.messages.create(
+            model="claude-3-5-sonnet-20241022",
+            max_tokens=1500,
+            messages=claude_messages,
+            tools=self.tools
+        )
 
-        # Handle different response formats based on provider
-        if self.current_provider == "claude":
-            return await self._process_claude_response(response, claude_messages)
-        elif self.current_provider in ["openai", "llama"]:
-            return await self._process_openai_response(response, claude_messages)
-        elif self.current_provider == "mistral":
-            return await self._process_mistral_response(response, claude_messages)
-        
-        return []
-    
-    async def _process_claude_response(self, response, claude_messages):
-        """Process Claude API response."""
         result_messages = []
         
         for content in response.content:
@@ -416,210 +116,158 @@ class MCPClientWrapper:
                     }
                 })
                 
-                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)
-                
-                formatted_response = self._format_weather_response(result_content, tool_name)
-                result_messages.append(formatted_response)
-                
-                claude_messages.append({"role": "user", "content": f"Tool result for {tool_name}: {result_content}"})
-                next_response = await self._call_llm(claude_messages, self.current_provider, self.current_model)
-                
-                if hasattr(next_response, 'content') and next_response.content and next_response.content[0].type == 'text':
-                    result_messages.append({
-                        "role": "assistant",
-                        "content": next_response.content[0].text
-                    })
-
-        return result_messages
-    
-    async def _process_openai_response(self, response, claude_messages):
-        """Process OpenAI/Llama API response."""
-        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"🔧 I'll use the **{tool_name}** tool to fetch the weather data you requested."
+                    "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"
+                    }
                 })
                 
                 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)
                 
-                formatted_response = self._format_weather_response(result_content, tool_name)
-                result_messages.append(formatted_response)
-        
-        return result_messages
-    
-    async def _process_mistral_response(self, response, claude_messages):
-        """Process Mistral API response."""
-        result_messages = []
-        
-        message = response.choices[0].message
-        
-        if message.content:
-            result_messages.append({
-                "role": "assistant", 
-                "content": message.content
-            })
-        
-        if hasattr(message, 'tool_calls') and message.tool_calls:
-            for tool_call in message.tool_calls:
-                tool_name = tool_call.function.name
-                tool_args = json.loads(tool_call.function.arguments)
+                if result_messages and "metadata" in result_messages[-2]:
+                    result_messages[-2]["metadata"]["status"] = "done"
                 
-                result_messages.append({
-                    "role": "assistant",
-                    "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)
                 result_content = result.content
                 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)
-                result_messages.append(formatted_response)
-        
-        return result_messages
-    
-    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":
-                    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"
+                # Parse and format the weather data response
+                try:
+                    result_json = json.loads(result_content)
                     
-                    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 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"
                                 
-                                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}"
+                            }
+                        })
                         
-                        formatted_response += "**Raw Data:**\n```json\n" + json.dumps(weather_data, indent=2) + "\n```"
-                    
-                    return {
+                except json.JSONDecodeError:
+                    result_messages.append({
                         "role": "assistant",
-                        "content": formatted_response,
+                        "content": "```\n" + result_content + "\n```",
                         "metadata": {
-                            "title": f"Weather Data Retrieved",
+                            "title": "Raw Tool Response",
                             "status": "done",
-                            "id": f"success_result_{tool_name}"
+                            "id": f"raw_result_{tool_name}"
                         }
-                    }
+                    })
                 
-                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:** {error_msg}\n\n"
-                    
-                    return {
+                # Let Claude analyze and respond to the weather data
+                claude_messages.append({"role": "user", "content": f"Tool result for {tool_name}: {result_content}"})
+                next_response = self.anthropic.messages.create(
+                    model="claude-3-5-sonnet-20241022",
+                    max_tokens=1500,
+                    messages=claude_messages,
+                )
+                
+                if next_response.content and next_response.content[0].type == 'text':
+                    result_messages.append({
                         "role": "assistant",
-                        "content": error_response,
-                        "metadata": {
-                            "title": "Weather API Error",
-                            "status": "error",
-                            "id": f"error_result_{tool_name}"
-                        }
-                    }
-                    
-        except json.JSONDecodeError:
-            pass
-        
-        return {
-            "role": "assistant",
-            "content": "```\n" + result_content + "\n```",
-            "metadata": {
-                "title": "Raw Tool Response",
-                "status": "done",
-                "id": f"raw_result_{tool_name}"
-            }
-        }
+                        "content": next_response.content[0].text
+                    })
+
+        return result_messages
 
-# Initialize client
 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 CHATBOT - ask me anything")
         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."
+            "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?'*"
         )
         
-        # LLM Provider Selection
-        with gr.Row():
-            with gr.Column(scale=2):
-                available_providers = client.get_available_providers()
-                if not available_providers:
-                    gr.Markdown("⚠️ **No LLM providers available**. Please check your API keys in environment variables.")
-                    provider_dropdown = gr.Dropdown(choices=[], value=None, label="🤖 AI Provider", interactive=False)
-                    model_dropdown = gr.Dropdown(choices=[], value=None, label="🎯 Model", interactive=False)
-                else:
-                    provider_choices = [(info["name"], key) for key, info in available_providers.items()]
-                    default_provider = list(available_providers.keys())[0]
-                    
-                    provider_dropdown = gr.Dropdown(
-                        choices=provider_choices,
-                        value=default_provider,
-                        label="🤖 AI Provider",
-                        interactive=True
-                    )
-                    
-                    model_dropdown = gr.Dropdown(
-                        choices=available_providers[default_provider]["models"],
-                        value=available_providers[default_provider]["models"][0],
-                        label="🎯 Model",
-                        interactive=True
-                    )
-            
-            with gr.Column(scale=1):
-                current_model_display = gr.Textbox(
-                    label="🔄 Current Selection",
-                    value=f"{client.current_provider}: {client.current_model}",
-                    interactive=False
-                )
-        
-        # Connection status
+        # Connection status (auto-updates on load)
         status = gr.Textbox(
             label="🔌 Connection Status", 
             interactive=False, 
-            value="🔄 Ready to connect..."
+            value="🔄 Connecting to weather server..."
         )
         
         # Main chat interface
@@ -628,29 +276,18 @@ def gradio_interface():
             height=600,
             type="messages",
             show_copy_button=True,
-            avatar_images=("👤", "🤖")
-        )
-        
-        # 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"
-            ],
-            height=100
+            avatar_images=("👤", "🤖"),
+            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 upload a file with additional context",
+                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):
-                send_btn = gr.Button("📤 Send", size="lg", variant="primary")
                 clear_btn = gr.Button("🗑️ Clear Chat", size="lg")
                 reconnect_btn = gr.Button("🔄 Reconnect", size="lg")
         
@@ -661,89 +298,35 @@ def gradio_interface():
                     "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"
+                    "Get weather data for station LAX789 from page 2",
+                    "Fetch weather data for station CHI456 between 2024-01-01 and 2024-01-31"
                 ],
                 inputs=msg,
                 label="💡 Example Queries"
             )
         
-        # Provider/Model update functions
-        def update_models(provider):
-            available_providers = client.get_available_providers()
-            if provider in available_providers:
-                models = available_providers[provider]["models"]
-                return gr.Dropdown(choices=models, value=models[0])
-            return gr.Dropdown(choices=[], value=None)
-        
-        def update_current_selection(provider, model):
-            if provider and model:
-                status_msg = client.update_provider(provider, model)
-                return f"{provider}: {model}", status_msg
-            return current_model_display.value, "❌ Please select both provider and model"
-        
-        # Auto-connect function
+        # Auto-connect when the interface loads
         def auto_connect():
             return client.connect()
         
-        def clear_all():
-            return [], gr.File(value=None)
-        
         # Event handlers
         demo.load(auto_connect, outputs=status)
-        
-        # Provider/Model selection
-        provider_dropdown.change(update_models, provider_dropdown, model_dropdown)
-        model_dropdown.change(
-            update_current_selection, 
-            [provider_dropdown, model_dropdown], 
-            [current_model_display, status]
-        )
-        
-        # Send message on button click or enter key
-        send_btn.click(
-            client.process_message, 
-            [msg, chatbot, file_upload], 
-            [chatbot, msg, file_upload]
-        )
-        msg.submit(
-            client.process_message, 
-            [msg, chatbot, file_upload], 
-            [chatbot, msg, file_upload]
-        )
-        
-        # Clear chat and file
-        clear_btn.click(clear_all, None, [chatbot, file_upload])
-        
-        # Reconnect
+        msg.submit(client.process_message, [msg, chatbot], [chatbot, msg])
+        clear_btn.click(lambda: [], None, chatbot)
         reconnect_btn.click(auto_connect, outputs=status)
         
     return demo
 
 if __name__ == "__main__":
-    # Check for API keys
-    api_keys = {
-        "ANTHROPIC_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
-        "OPENAI_API_KEY": os.getenv("OPENAI_API_KEY"), 
-        "MISTRAL_API_KEY": os.getenv("MISTRAL_API_KEY"),
-        "LLAMAINDEX_API_KEY": os.getenv("LLAMAINDEX_API_KEY")
-    }
-    
-    available_keys = [key for key, value in api_keys.items() if value]
-    
-    if not available_keys:
-        print("⚠️  Warning: No API keys found in environment.")
-        print("Please set at least one of the following in your .env file:")
-        for key in api_keys.keys():
-            print(f"  {key}=your_api_key_here")
-    else:
-        print("🔑 Available API keys:", ", ".join(available_keys))
+    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")
     
-    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("🚀 Starting MCP Weather Client...")
+    print("📡 Will auto-connect to gradio_mcp_server.py")
+    print("🌐 Weather API endpoint: http://localhost:8888/weather/stations")
     
     interface = gradio_interface()
     interface.launch(debug=True, share=True)

gradio_mcp_server.py

@@ -76,4 +76,39 @@ async def get_weather_data(station_code: str, page: int = 1, start: str = None,
             "type": "error",
             "station_code": station_code,
             "message": f"Unexpected error fetching weather data: {str(e)}"
-        })
+        })
+
+@mcp.tool()
+async def list_available_stations() -> str:
+    """Get a list of available weather stations from the API.
+    
+    Returns:
+        JSON string containing available stations or error information
+    """
+    base_url = "http://localhost:8888/weather/stations"
+    
+    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)}"
+        })
+
+if __name__ == "__main__":
+    mcp.run(transport='stdio')

requirements.txt

@@ -1,5 +1,3 @@
 gradio[mcp]
 anthropic 
 mcp
-openai
-mistralai