# Weather Forecast MCP Server & Agent

A complete implementation of a weather forecast MCP (Model Context Protocol) server with a Databricks Agent Bricks agent integration.

## Overview

This project demonstrates how to build and deploy:
1. **Weather MCP Server** - FastMCP server exposing weather forecast tools
2. **Agent Bricks Integration** - An intelligent agent that uses the MCP server to answer weather questions

The weather data comes from [Open-Meteo](https://open-meteo.com/), a free weather API requiring no signup or API key.

## Architecture

```
┌─────────────────┐      ┌──────────────────┐      ┌─────────────────┐
│  User Question  │─────▶│  Agent Bricks    │─────▶│  Weather MCP    │
│   "Will it      │      │     Agent        │      │     Server      │
│  rain in SF?"   │      │                  │      │                 │
└─────────────────┘      └──────────────────┘      └─────────────────┘
                                  │                          │
                                  │                          ▼
                                  │                  ┌─────────────────┐
                                  │                  │  weather_broker │
                                  │                  │                 │
                                  ▼                  └─────────────────┘
                         ┌─────────────────┐                │
                         │  Natural Lan-   │                ▼
                         │  guage Response │        ┌─────────────────┐
                         └─────────────────┘        │   Open-Meteo    │
                                                    │      API        │
                                                    └─────────────────┘
```

## Files

### Weather MCP Server
- `weather_broker.py` - Weather API adapter (HTTP calls to Open-Meteo)
- `weather_mcp_server.py` - FastMCP server with 3 tools
- `app.yaml` - Databricks App deployment config
- `requirements.txt` - Python dependencies

### Agent Configuration
- `weather_agent.py` - Agent Bricks agent configuration

## MCP Tools

The server exposes 3 tools:

### 1. `get_current_weather(location: str)`
Get current weather conditions for any location.

**Example:**
```python
get_current_weather("Chicago")
# Returns: temperature, feels_like, humidity, wind, conditions, etc.
```

### 2. `get_forecast(location: str, days: int = 7)`
Get multi-day weather forecast (1-16 days).

**Example:**
```python
get_forecast("Austin", days=5)
# Returns: daily forecasts with high/low temps, precipitation, conditions
```

### 3. `predict_umbrella_needed(location: str, date: Optional[str] = None)`
Make a recommendation about needing an umbrella.

**Example:**
```python
predict_umbrella_needed("Seattle", "2026-08-15")
# Returns: YES/NO/MAYBE recommendation with reasoning
```

## Deployment

### Step 1: Deploy the MCP Server

```bash
# From the workspace CLI or notebook
databricks apps create weather_mcp \
  --source-path /Workspace/Users/your-email@example.com/weather_mcp
```

### Step 2: Get the App URL

```bash
databricks apps get weather_mcp
# Note the URL, e.g., https://dbc-xxxxx.cloud.databricks.com/apps/weather_mcp
```

### Step 3: Configure the Agent

Edit `weather_agent.py` and set `WEATHER_MCP_URL` to your deployed app URL:

```python
MCP_SERVER_URL = "https://dbc-xxxxx.cloud.databricks.com/apps/weather_mcp"
```

### Step 4: Deploy the Agent

The agent can be deployed as another Databricks App or used directly in notebooks.

## Testing

### Test the MCP Server Locally

```python
# In a notebook
import weather_broker

# Test current weather
weather_broker.get_current_weather("San Francisco")

# Test forecast
weather_broker.get_forecast("New York", days=3)
```

### Test the Agent

```python
from weather_agent import create_weather_agent

agent = create_weather_agent()

# Ask weather questions
response = agent.chat("What's the weather like in Chicago right now?")
print(response)

response = agent.chat("Will it rain in Austin this weekend?")
print(response)

response = agent.chat("Should I bring a jacket to Seattle tomorrow?")
print(response)
```

## Example Queries

The agent can handle natural language questions like:

* "What's the temperature in Los Angeles?"
* "Will it rain in Seattle tomorrow?"
* "Should I bring an umbrella to Chicago this weekend?"
* "Give me a 5-day forecast for New York"
* "What's the weather like in Austin compared to Dallas?"
* "Is it going to be hot in Phoenix next week?"

## Weather Data Source

This implementation uses [Open-Meteo](https://open-meteo.com/en/docs):
* ✓ Free, no API key required
* ✓ ~10,000 calls/day for non-commercial use
* ✓ Current conditions + 16-day forecasts
* ✓ Global coverage
* ✓ Temperature, precipitation, wind, humidity, sunrise/sunset

## Extending

### Add More Tools

To add new weather-related tools:

1. Add a function to `weather_broker.py` to fetch the data
2. Decorate a new tool function in `weather_mcp_server.py` with `@mcp.tool`
3. Update the agent instructions to describe when to use the new tool

### Switch to a Different Weather API

To use a different weather API:

1. Replace the API calls in `weather_broker.py`
2. If the API requires authentication, add secret management
3. Update `app.yaml` with any needed environment variables
4. Keep the same function signatures so the MCP tools don't change

## License

This is a learning project for educational purposes.