# Weather Info App with MCP Server

A simple weather information application built with FastAPI and integrated with an MCP (Model Context Protocol) server for use with Gemini CLI.

## 📋 Requirements Checklist

- ✅ FastAPI weather application
- ✅ MCP Server implementation
- ✅ Gemini CLI integration
- ✅ MCP tools demonstration
- ✅ Screen recording (see `SCREEN_RECORDING_GUIDE.md`)

## 🎥 Screen Recording

**IMPORTANT:** This repository includes a screen recording demonstrating:
1. MCP server running
2. `gemini mcp list` command showing available tools
3. Usage of all MCP tools (`get_weather`, `get_weather_batch`, `check_api_health`)

See `SCREEN_RECORDING_GUIDE.md` for detailed recording instructions.

## Project Structure

```
.
├── weather_api.py      # FastAPI weather application
├── mcp_server.py       # MCP server exposing weather tools
├── requirements.txt    # Python dependencies
├── mcp_config.json    # Gemini CLI MCP configuration
├── demo.py            # Demo script for testing
└── README.md          # This file
```

## Features

- **FastAPI Weather API**: RESTful API providing weather information
- **MCP Server**: Exposes weather functionality as MCP tools
- **Gemini CLI Integration**: Ready to use with Google's Gemini CLI
- **Multiple Tools**: Get weather for single/multiple cities, health check

## Installation

1. Clone this repository:
```bash
git clone <your-repo-url>
cd "MCp derver using FAST MCP"
```

2. Install dependencies:
```bash
pip install -r requirements.txt
```

## Running the Application

### Step 1: Start the FastAPI Weather Server

In one terminal:
```bash
python weather_api.py
```

The API will be available at `http://localhost:8000`

You can test it:
```bash
# Using curl
curl http://localhost:8000/weather?city=London

# Or using the browser
http://localhost:8000/weather?city=Paris
```

### Step 2: Configure Gemini CLI for MCP

The MCP server uses stdio transport. Create or update your Gemini CLI configuration file:

**On Windows:**
`%APPDATA%\Google\Gemini CLI\mcp_config.json`

**On macOS/Linux:**
`~/.config/google-gemini-cli/mcp_config.json`

Example configuration:
```json
{
  "mcpServers": {
    "weather-info": {
      "command": "python",
      "args": ["<absolute-path-to-mcp_server.py>"],
      "env": {}
    }
  }
}
```

For Windows, use full path like:
```json
{
  "mcpServers": {
    "weather-info": {
      "command": "python",
      "args": ["B:\\MCp derver using FAST MCP\\mcp_server.py"],
      "env": {}
    }
  }
}
```

### Step 3: Use with Gemini CLI

1. Start Gemini CLI
2. List available MCP tools:
```bash
gemini mcp list
```

3. Use the tools:
```bash
# Get weather for a city
gemini mcp call weather-info get_weather --city "Tokyo"

# Get weather for multiple cities
gemini mcp call weather-info get_weather_batch --cities "London,Paris,New York"

# Check API health
gemini mcp call weather-info check_api_health
```

## Available MCP Tools

### 1. `get_weather`
Get current weather information for a single city.

**Parameters:**
- `city` (required): Name of the city
- `country` (optional): Country name

**Example:**
```bash
gemini mcp call weather-info get_weather --city "London" --country "UK"
```

### 2. `get_weather_batch`
Get weather information for multiple cities at once.

**Parameters:**
- `cities` (required): Comma-separated list of cities

**Example:**
```bash
gemini mcp call weather-info get_weather_batch --cities "Tokyo,Seoul,Beijing"
```

### 3. `check_api_health`
Check if the weather API is running and healthy.

**Example:**
```bash
gemini mcp call weather-info check_api_health
```

## Testing

Run the demo script to test the setup:
```bash
python demo.py
```

## API Endpoints

The FastAPI server provides:

- `GET /` - API information
- `GET /health` - Health check
- `GET /weather?city=<name>&country=<name>` - Get weather (GET)
- `POST /weather` - Get weather (POST with JSON body)

## Screen Recording Instructions

To create a screen recording demonstrating the MCP server:

1. Start the FastAPI server: `python weather_api.py`
2. Open Gemini CLI
3. Show `gemini mcp list` command to see available tools
4. Demonstrate each tool:
   - `get_weather` for a single city
   - `get_weather_batch` for multiple cities
   - `check_api_health`
5. Show the responses and how they work together

## Project Files

- `weather_api.py` - FastAPI weather application
- `mcp_server.py` - MCP server exposing weather tools
- `demo.py` - Testing and demonstration script
- `get_path.py` - Helper to get correct paths for configuration
- `test_mcp_structure.py` - Verify MCP imports and structure
- `requirements.txt` - Python dependencies
- `mcp_config.json` - Example Gemini CLI configuration

## Documentation

- `README.md` - This file (main documentation)
- `QUICK_START.md` - Quick setup guide
- `setup_instructions.md` - Detailed setup instructions
- `SCREEN_RECORDING_GUIDE.md` - Guide for creating demo video
- `PROJECT_SUMMARY.md` - Complete project overview

## Notes

- The weather data is mock/simulated for demonstration purposes
- Make sure the FastAPI server is running before using MCP tools
- The MCP server communicates with the FastAPI server via HTTP
- All paths in the configuration must be absolute paths

## Troubleshooting

**MCP server not connecting:**
- Ensure FastAPI server is running on port 8000
- Check that the path to `mcp_server.py` in the config is correct and absolute
- Verify Python is in your PATH

**Tools not appearing:**
- Restart Gemini CLI after updating the configuration
- Check the MCP server logs for errors
- Verify the configuration JSON syntax is correct