# TaskFlow MCP v2 — Shared Tasks with LLM-Generated Progress Context

A hands-on **AI Bridge** lab for building, testing, and deploying a real MCP server with tools, resources, prompts, SQLite persistence, and a shared progress log.

TaskFlow starts as a task CRUD service, then adds a context layer: after a person completes meaningful work, the connected LLM can summarize that work in 1–2 sentences and append it to the task. Another teammate can later retrieve the same task and see the accumulated progress history.

## What you will learn

- MCP tools, resources, and prompts
- How type hints and docstrings become tool schemas and model instructions
- Local `stdio` transport and hosted Streamable HTTP transport
- In-memory MCP testing with FastMCP
- SQLite schema evolution without deleting existing data
- LLM-assisted progress summaries shared across clients
- Deployment to Render

## Prerequisites

- Python 3.10+
- Git
- `uv`
- Node.js/npm for MCP Inspector
- Optional: Ollama plus a tool-capable model such as `qwen3:8b`

## 1. Clone and install

```powershell
 git clone https://github.com/AdarshVijay101/taskflow-mcp.git
 cd taskflow-mcp
 uv sync --extra dev
 uv run pytest -v
```

Expected after this upgrade: **10 tests passed**.

## 2. Run locally over stdio

```powershell
uv run taskflow
```

A stdio MCP server waits for a client to launch or communicate with it. Press `Ctrl+C` when finished.

## 3. Inspect the local server

```powershell
npx @modelcontextprotocol/inspector uv run taskflow
```

Verify these MCP components:

### Tools

1. `create_task`
2. `list_tasks`
3. `get_task`
4. `update_task_status`
5. `update_task_progress`
6. `delete_task`

### Resources

- `tasks://all`
- `tasks://stats`
- `tasks://{status}/list`

### Prompts

- `daily_standup`
- `prioritize_my_day`
- `work_on_task`

## 4. Run locally over Streamable HTTP

### PowerShell

```powershell
$env:TASKFLOW_TRANSPORT = "http"
uv run taskflow
```

Endpoint:

```text
http://localhost:8000/mcp
```

Remove the temporary environment variable later with:

```powershell
Remove-Item Env:TASKFLOW_TRANSPORT
```

## 5. Connect a local Ollama model to the hosted MCP server

Make sure Ollama is already running, then install the client:

```powershell
python -m pip install --upgrade ollmcp
```

Register the hosted TaskFlow server:

```powershell
ollmcp mcp add --transport http taskflow-live `
  "https://taskflow-mcp-mp8f.onrender.com/mcp"
```

Launch the local model:

```powershell
ollmcp --provider ollama --model qwen3:8b
```

Demo prompt:

```text
Create a high-priority task called "Create 2 webinar topics for Kumar".
In the description put:
Topic 1 = ChatGPT desktop app new features;
Topic 2 = how QA professionals can use AI.
```

Then, in a fresh chat as Bhargav:

```text
Pull task 1. I finished Topic 1 and drafted the outline. Log a concise
progress summary on the task and record Bhargav as the author.
```

Finally, as Kumar:

```text
Pull task 1 and tell me what has been completed so far.
```

## 6. Connect Claude Desktop to the local stdio server

Find the full path to `uv.exe`:

```powershell
(Get-Command uv).Source
```

Open:

```text
%APPDATA%\Claude\claude_desktop_config.json
```

Use the full paths on your machine and escape Windows backslashes:

```json
{
  "mcpServers": {
    "taskflow": {
      "command": "C:\\full\\path\\to\\uv.exe",
      "args": [
        "--directory",
        "D:\\DATA ENGINEER\\PROJECTS\\MCP LAB\\taskflow-mcp",
        "run",
        "taskflow"
      ]
    }
  }
}
```

Restart Claude Desktop after saving the file.

## 7. Deploy on Render

The included `render.yaml` installs the package and starts HTTP transport automatically.

Hosted endpoint used by this lab:

```text
https://taskflow-mcp-mp8f.onrender.com/mcp
```

### Storage warning

The free Render filesystem is ephemeral. SQLite data can disappear after a restart, spin-down, or redeployment. This lab is suitable for demonstrations, not important production records.

### Security warning

The hosted lab endpoint has no authentication. Anyone who knows the URL can call its tools and change its task data. Do not store sensitive information.

## The context-layer distinction

A plain CRUD API stores values supplied by its caller. In this demo, the connected LLM reads the work conversation, decides what matters, generates a concise progress summary, and submits it through the MCP tool. A REST API could also receive an LLM-generated note when placed behind an agent, so the accurate distinction is:

> The plain CRUD API does not generate or orchestrate the summary by itself. MCP gives compatible clients a standardized way to discover the tool, understand its schema and instructions, call it, and carry the generated context between teammates.

## Project map

```text
src/taskflow/
├── config.py      # Environment-driven settings
├── db.py          # SQLite storage and v1 → v2 migration
├── tools.py       # Six model-callable tools
├── resources.py   # Three read-only resource patterns
├── prompts.py     # Three reusable prompts
└── server.py      # FastMCP app and transport switch
```

The detailed two-person webinar walkthrough is in `LAB_ADDENDUM_v2.md`.