# MCP Tool Server — Custom Model Context Protocol Server

> A production-ready MCP server exposing 5 tools that any MCP-compatible LLM client (Claude Desktop, etc.) can call as part of agentic workflows.

Built with **Python MCP SDK + httpx + SQLite**.

---

## What This Project Demonstrates

- **MCP (Model Context Protocol)** — the open standard for LLM tool integration
- **Agentic AI architecture** — LLMs calling real tools autonomously
- **Tool design patterns** — input schemas, error handling, security guardrails
- **Async Python** — all tools are async-ready for performance

---

## Tools Exposed

| Tool | What it does |
|---|---|
| `get_weather` | Live weather for any city (Open-Meteo, no API key needed) |
| `query_database` | Safe SELECT queries on a local SQLite employee database |
| `read_file` | Read any local text file |
| `summarize_webpage` | Fetch and extract text from any URL |
| `calculator` | Evaluate math expressions safely (sqrt, sin, log, etc.) |

---

## Architecture

```
Claude Desktop (or any MCP client)
         │
         │  MCP Protocol (JSON-RPC over stdio)
         ▼
┌─────────────────────────────────┐
│        MCP Tool Server          │
│                                 │
│  list_tools()  → returns schema │
│  call_tool()   → executes tool  │
│                                 │
│  ┌──────────┐  ┌─────────────┐  │
│  │ Weather  │  │  Database   │  │
│  │  (HTTP)  │  │  (SQLite)   │  │
│  └──────────┘  └─────────────┘  │
│  ┌──────────┐  ┌─────────────┐  │
│  │  Files   │  │  Webpage    │  │
│  │  (disk)  │  │   (HTTP)    │  │
│  └──────────┘  └─────────────┘  │
│        ┌──────────────┐         │
│        │  Calculator  │         │
│        │  (safe eval) │         │
│        └──────────────┘         │
└─────────────────────────────────┘
```

---

## Project Structure

```
mcp-server/
├── server.py                  # Main MCP server — all 5 tools defined here
├── test_tools.py              # Test script — verify tools without Claude
├── claude_desktop_config.json # Config snippet for Claude Desktop
├── requirements.txt
└── README.md
```

---

## Step-by-Step Setup

### Step 1 — Clone and enter project

```bash
git clone https://github.com/YOUR_USERNAME/mcp-tool-server.git
cd mcp-tool-server
```

### Step 2 — Create virtual environment

```bash
python -m venv venv
source venv/bin/activate        # Mac/Linux
venv\Scripts\activate           # Windows
```

### Step 3 — Install dependencies

```bash
pip install -r requirements.txt
```

### Step 4 — Run the tests (no Claude needed)

```bash
python test_tools.py
```

You should see:
```
✅ Calculator PASS
✅ Database Query PASS
✅ Read File PASS
✅ Weather API PASS
```

### Step 5 — Connect to Claude Desktop

1. Open Claude Desktop settings → Developer → Edit Config
2. Add the following to `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "rakesh-tool-server": {
      "command": "python",
      "args": ["/full/path/to/mcp-server/server.py"]
    }
  }
}
```

3. Replace `/full/path/to/` with your actual path
4. Restart Claude Desktop
5. You'll see a 🔧 tool icon — Claude can now call your tools!

### Step 6 — Test with Claude

Ask Claude:
- *"What's the weather in Bengaluru?"* → calls `get_weather`
- *"Show me all engineers in the database"* → calls `query_database`
- *"What is sqrt(2025) + 100?"* → calls `calculator`

---

## How MCP Works (Simple Explanation)

1. **Server starts** and waits on stdin/stdout
2. Claude Desktop **discovers tools** by calling `list_tools()` — gets names, descriptions, input schemas
3. When you ask Claude something, it **decides which tool to call** based on the schemas
4. Claude sends a `call_tool(name, args)` request to the server
5. Server **executes the tool** and returns the result as text
6. Claude **uses the result** to formulate its final answer

The key innovation: tools are described with **JSON Schema** so the LLM understands exactly what inputs to provide.

---

## Security Notes

- `query_database` only allows `SELECT` — blocks any destructive SQL
- `calculator` uses safe `eval` with an allowlisted namespace — no `import`, `os`, etc.
- `read_file` is path-restricted to readable files only

---

## Tech Stack

| Layer | Technology |
|---|---|
| Protocol | MCP (Model Context Protocol) v1.0 |
| Language | Python 3.11+ async |
| HTTP Client | httpx (async) |
| Database | SQLite (built-in) |
| Weather API | Open-Meteo (free, no key) |

---

## Resume Line

> *Built a custom MCP server exposing 5 production-ready tools (weather, database, file I/O, web fetch, calculator) — demonstrating hands-on agentic AI architecture using the Model Context Protocol for LLM tool integration.*