Add application file

README.md

@@ -1,8 +1,8 @@
 ---
 title: Chatbot Hackathon
-emoji: 🌍
+emoji: 📈
 colorFrom: pink
-colorTo: blue
+colorTo: yellow
 sdk: gradio
 sdk_version: 5.46.0
 app_file: app.py

app.py

@@ -0,0 +1,332 @@
+import asyncio
+import os
+import json
+from typing import List, Dict, Any, Union
+from contextlib import AsyncExitStack
+
+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 dotenv import load_dotenv
+
+load_dotenv()
+
+loop = asyncio.new_event_loop()
+asyncio.set_event_loop(loop)
+
+class MCPClientWrapper:
+    def __init__(self):
+        self.session = None
+        self.exit_stack = None
+        self.anthropic = Anthropic()
+        self.tools = []
+        self.connected = False
+    
+    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()
+        
+        self.exit_stack = AsyncExitStack()
+        
+        server_path = "gradio_mcp_server.py"
+        
+        server_params = StdioServerParameters(
+            command="python",
+            args=[server_path],
+            env={"PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"}
+        )
+        
+        try:
+            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()
+            self.tools = [{ 
+                "name": tool.name,
+                "description": tool.description,
+                "input_schema": tool.inputSchema
+            } for tool in response.tools]
+            
+            self.connected = True
+            tool_names = [tool["name"] for tool in self.tools]
+            return f"✅ Connected to MCP Weather Server. Available tools: {', '.join(tool_names)}"
+        except Exception as e:
+            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:
+        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="")
+        
+        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]]):
+        claude_messages = []
+        for msg in history:
+            if isinstance(msg, ChatMessage):
+                role, content = msg.role, msg.content
+            else:
+                role, content = msg.get("role"), msg.get("content")
+            
+            if role in ["user", "assistant", "system"]:
+                claude_messages.append({"role": role, "content": content})
+        
+        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
+        )
+
+        result_messages = []
+        
+        for content in response.content:
+            if content.type == 'text':
+                result_messages.append({
+                    "role": "assistant", 
+                    "content": content.text
+                })
+                
+            elif content.type == 'tool_use':
+                tool_name = content.name
+                tool_args = content.input
+                
+                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"
+                    }
+                })
+                
+                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}"
+                        }
+                    })
+                
+                # 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": next_response.content[0].text
+                    })
+
+        return result_messages
+
+client = MCPClientWrapper()
+
+def gradio_interface():
+    with gr.Blocks(title="MCP Weather Client", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🌤️ Weather Station 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?'*"
+        )
+        
+        # Connection status (auto-updates on load)
+        status = gr.Textbox(
+            label="🔌 Connection Status", 
+            interactive=False, 
+            value="🔄 Connecting to weather server..."
+        )
+        
+        # Main chat interface
+        chatbot = gr.Chatbot(
+            value=[], 
+            height=600,
+            type="messages",
+            show_copy_button=True,
+            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 '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")
+        
+        # Example queries
+        with gr.Row():
+            gr.Examples(
+                examples=[
+                    "What weather stations are available?",
+                    "Get weather data for station ABC123",
+                    "Show me the latest hourly reports for station NYC001",
+                    "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"
+            )
+        
+        # Auto-connect when the interface loads
+        def auto_connect():
+            return client.connect()
+        
+        # Event handlers
+        demo.load(auto_connect, outputs=status)
+        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__":
+    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 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

@@ -0,0 +1,114 @@
+from mcp.server.fastmcp import FastMCP
+import json
+import sys
+import io
+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.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 = "http://localhost:8888/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"
+    }
+    
+    try:
+        response = requests.get(url, params=params, timeout=30)
+        response.raise_for_status()
+        
+        weather_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}"
+        }, 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."
+        })
+    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}"
+        })
+    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,
+            "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."
+        })
+    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}"
+        })
+    except Exception as e:
+        return json.dumps({
+            "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

@@ -0,0 +1 @@
+gradio[mcp]