# Task Manager MCP Server

A Python MCP server that demonstrates all **3 MCP primitives** — built as a portfolio project after completing the Anthropic MCP course.

## What's inside

| Primitive | What it does | Examples |
|-----------|-------------|---------|
| **Tools** | Model-controlled actions — Claude calls these to do things | `create_task`, `complete_task`, `delete_task`, `list_tasks`, `update_task` |
| **Resources** | App-controlled read-only data — Claude reads these for context | `tasks://all`, `tasks://summary`, `tasks://{id}` |
| **Prompts** | User-controlled templates — structured starting points for conversations | `daily_planning`, `end_of_day_review`, `weekly_summary` |

---

## Setup

### 1. Clone / copy this project

```bash
git clone <your-repo-url>
cd task-manager-mcp
```

### 2. Create a virtual environment

```bash
python -m venv .venv
source .venv/bin/activate      # Windows: .venv\Scripts\activate
```

### 3. Install dependencies

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

### 4. Run the server

```bash
python server.py
```

---

## Test with the MCP Inspector

The MCP Inspector lets you test all your tools, resources, and prompts in the browser — no client needed.

```bash
mcp dev server.py
```

Then open **http://localhost:5173** in your browser.

From there you can:
- Call any tool and see the response
- Read any resource by URI
- Preview and run any prompt

---

## Connect to Claude Desktop

Add this to your Claude Desktop config file:

**Mac:** `~/Library/Application Support/Claude/claude_desktop_config.json`  
**Windows:** `%APPDATA%\Claude\claude_desktop_config.json`

```json
{
  "mcpServers": {
    "task-manager": {
      "command": "python",
      "args": ["/absolute/path/to/task-manager-mcp/server.py"]
    }
  }
}
```

Restart Claude Desktop — you'll see the task manager tools available in the chat.

---

## Example conversations with Claude

Once connected, try these:

**Using tools:**
> "Create a high-priority task: finish portfolio README, due 2025-07-01"

> "What tasks do I have pending?"

> "Mark task abc12345 as complete"

**Using resources:**
> "Read tasks://summary and tell me how I'm doing"

> "Show me the details of task abc12345 using its resource URI"

**Using prompts:**
> Run the `daily_planning` prompt to get your morning briefing

> Run `end_of_day_review` in the evening

---

## Project structure

```
task-manager-mcp/
├── server.py          # All MCP logic — tools, resources, prompts
├── requirements.txt   # Single dependency: mcp[cli]
├── README.md
└── tasks/
    └── tasks.json     # Auto-created on first task
```

---

## Key concepts demonstrated

### Tools (model-controlled)
Claude decides when to call these based on what the user asks. The decorator pattern means you write a plain Python function — no JSON schema needed:

```python
@mcp.tool()
def create_task(title: str, priority: str = "medium") -> str:
    ...
```

### Resources (app-controlled)
Exposed as URIs. Claude can read these to ground its responses in real data:

```python
@mcp.resource("tasks://summary")
def get_task_summary() -> str:
    ...
```

Templated resources use `{variable}` in the URI:

```python
@mcp.resource("tasks://{task_id}")
def get_task_by_id(task_id: str) -> str:
    ...
```

### Prompts (user-controlled)
Pre-crafted conversation starters. They read live data and return a structured message:

```python
@mcp.prompt()
def daily_planning() -> str:
    # reads current tasks, builds a structured prompt string
    ...
```

---

Built with [FastMCP](https://github.com/jlowin/fastmcp) · Anthropic MCP course graduate project