support_for_all_clients

app.py

@@ -3,12 +3,16 @@ import os
 import json
 from typing import List, Dict, Any, Union
 from contextlib import AsyncExitStack
+import mimetypes
+import tempfile
 
 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()
@@ -20,9 +24,99 @@ class MCPClientWrapper:
     def __init__(self):
         self.session = None
         self.exit_stack = None
-        self.anthropic = Anthropic()
         self.tools = []
         self.connected = False
+        
+        # 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}")
+        
+        try:
+            if os.getenv("OPENAI_API_KEY"):
+                self.openai_client = OpenAI()
+        except Exception as e:
+            print(f"⚠️ Failed to initialize OpenAI client: {e}")
+        
+        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}")
+        
+        try:
+            if os.getenv("LLAMAINDEX_API_KEY"):
+                # Using OpenAI-compatible endpoint for Llama
+                self.llama_client = OpenAI(
+                    api_key=os.getenv("LLAMAINDEX_API_KEY"),
+                    base_url="https://api.llamaindex.ai/v1"  # Adjust based on your provider
+                )
+        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}"
     
     def connect(self) -> str:
         return loop.run_until_complete(self._connect())
@@ -62,15 +156,136 @@ 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_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:
+            # Get file info
+            file_size = os.path.getsize(file_path)
+            file_name = os.path.basename(file_path)
+            mime_type, _ = mimetypes.guess_type(file_path)
+            
+            # 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."
+            
+            # Try to read as text
+            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()
+                    
+                    # If content is too long, truncate it
+                    max_chars = 50000  # Roughly 50k characters
+                    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
+            
+            # 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."
+            
+        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"]:
+            # Convert to OpenAI tools format
+            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":
+            # Convert to Mistral tools format
+            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:
         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=""), 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)
         
-        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 = message + file_content
+        
+        new_messages = loop.run_until_complete(self._process_query(full_message, history))
+        return history + [{"role": "user", "content": full_message}] + new_messages, gr.Textbox(value=""), gr.File(value=None)
     
     async def _process_query(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]]):
         claude_messages = []
@@ -85,15 +300,27 @@ 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:
+            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)}"}]
 
         result_messages = []
         
+        # 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 result_messages
+    
+    async def _process_claude_response(self, response, claude_messages):
+        """Process Claude API response."""
+        result_messages = []
+        
         for content in response.content:
             if content.type == 'text':
                 result_messages.append({
@@ -116,154 +343,207 @@ 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)
+                
+                # Format the response
+                formatted_response = self._format_weather_response(result_content, tool_name)
+                result_messages.append(formatted_response)
+                
+                # Let the LLM analyze and respond
+                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": "```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 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
+    
+    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)
                 
-                # Parse and format the weather data response
-                try:
-                    result_json = json.loads(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", {})
                     
-                    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 = 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"
                                 
-                                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}"
-                            }
-                        })
+                                if len(reports) > 3:
+                                    formatted_response += f"... and {len(reports) - 3} more reports\n\n"
                         
-                except json.JSONDecodeError:
-                    result_messages.append({
+                        formatted_response += "**Raw Data:**\n```json\n" + json.dumps(weather_data, indent=2) + "\n```"
+                    
+                    return {
                         "role": "assistant",
-                        "content": "```\n" + result_content + "\n```",
+                        "content": formatted_response,
                         "metadata": {
-                            "title": "Raw Tool Response",
+                            "title": f"Weather Data Retrieved",
                             "status": "done",
-                            "id": f"raw_result_{tool_name}"
+                            "id": f"success_result_{tool_name}"
                         }
-                    })
-                
-                # 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({
+                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 {
                         "role": "assistant",
-                        "content": next_response.content[0].text
-                    })
-
-        return result_messages
+                        "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}"
+            }
+        }
 
 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! I support multiple AI providers "
+            "and can process uploaded files for additional context. Choose your preferred AI model below."
         )
         
-        # Connection status (auto-updates on load)
+        # 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
         status = gr.Textbox(
             label="🔌 Connection Status", 
             interactive=False, 
@@ -280,14 +560,26 @@ def gradio_interface():
             bubble_full_width=False
         )
         
+        # 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"
+            ],
+            height=100
+        )
+        
         # 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?'",
+                placeholder="e.g., 'Get weather data for station NYC001' or upload a file with additional context",
                 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")
         
@@ -298,35 +590,89 @@ def gradio_interface():
                     "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"
+                    "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):
+            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 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)
-        msg.submit(client.process_message, [msg, chatbot], [chatbot, msg])
-        clear_btn.click(lambda: [], None, chatbot)
+        
+        # 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
         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": 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))
     
-    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 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")
     
     interface = gradio_interface()
     interface.launch(debug=True, share=True)