Create tasks with title, priority (low, medium, high), and optional description (max 2000 characters).
List all tasks, optionally filtered by status (todo, in_progress, done).
Get a specific task by its numeric ID.
Update task status to todo, in_progress, or done.
Delete a task by ID.
Log LLM-generated progress summaries onto tasks for a shared work history.
Access read-only resources: tasks://all, tasks://stats, tasks://{status}/list.
Use prompts for common workflows: daily_standup, prioritize_my_day, work_on_task.
Supports stdio and HTTP transports; works with Ollama and Claude Desktop; deployable on Render.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@TaskFlow MCP Create a high priority task to review the project proposal."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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.
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
Related MCP server: mcp-task-manager
Python 3.10+
Git
uv
Node.js/npm for MCP Inspector
Optional: Ollama plus a tool-capable model such as qwen3:8b
git clone https://github.com/AdarshVijay101/taskflow-mcp.git
cd taskflow-mcp
uv sync --extra dev
uv run pytest -vExpected after this upgrade: 10 tests passed.
uv run taskflowA stdio MCP server waits for a client to launch or communicate with it. Press Ctrl+C when finished.
npx @modelcontextprotocol/inspector uv run taskflowVerify these MCP components:
create_task
list_tasks
get_task
update_task_status
update_task_progress
delete_task
tasks://all
tasks://stats
tasks://{status}/list
daily_standup
prioritize_my_day
work_on_task
$env:TASKFLOW_TRANSPORT = "http"
uv run taskflowEndpoint:
http://localhost:8000/mcpRemove the temporary environment variable later with:
Remove-Item Env:TASKFLOW_TRANSPORTMake sure Ollama is already running, then install the client:
python -m pip install --upgrade ollmcpRegister the hosted TaskFlow server:
ollmcp mcp add --transport http taskflow-live `
"https://taskflow-mcp-mp8f.onrender.com/mcp"Launch the local model:
ollmcp --provider ollama --model qwen3:8bDemo prompt:
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:
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:
Pull task 1 and tell me what has been completed so far.Find the full path to uv.exe:
(Get-Command uv).SourceOpen:
%APPDATA%\Claude\claude_desktop_config.jsonUse the full paths on your machine and escape Windows backslashes:
{
"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.
The included render.yaml installs the package and starts HTTP transport automatically.
Hosted endpoint used by this lab:
https://taskflow-mcp-mp8f.onrender.com/mcpThe 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.
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.
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.
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 switchThe detailed two-person webinar walkthrough is in LAB_ADDENDUM_v2.md.
Create a new task. Returns the created task including its id.
| Name | Required | Description | Default |
|---|---|---|---|
| title | Yes | ||
| priority | No | medium | |
| description | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It mentions the return value (the created task with its id), which is good, but lacks disclosure on side effects, idempotency, or error conditions. Adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short (two sentences) and front-loaded with the action. However, it could be slightly expanded to include parameter context without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters and an output schema, the description is incomplete. It fails to explain the role of each parameter or provide usage context, making it insufficient for an agent to fully understand the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for parameter meaning. It does not explain the title, priority, or description parameters at all, leaving their semantics entirely to the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create a new task') and the resource ('task'), and distinguishes from sibling tools like list_tasks and get_task. No ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like update_task_status. The description lacks context on prerequisites or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Permanently delete a task by id.
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavior. It mentions permanence but omits side effects (e.g., cascading deletes), authorization requirements, or state changes. Bare minimum.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise and front-loaded. However, it sacrifices necessary detail for brevity, earning a middle score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple tool (1 param, no nested objects), the description could be more complete. It does not mention return value or any output, despite a provided output schema. Minimal but not entirely insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must explain parameters. It only says 'by id' without specifying that task_id is an integer or its required constraints. The output schema is present but not referenced.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (delete) and the resource (task), specifying it is permanent. It effectively distinguishes from sibling tools like create_task or get_task.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives such as update_task_status or get_task. The description does not mention prerequisites, consequences, or context for deletion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch a single task by its numeric id.
| Name | Required | Description | Default |
|---|---|---|---|
| task_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It does not mention that the operation is read-only, what happens if the task is not found, or any authentication requirements. The description is too brief.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, front-loading the essential information. However, it could be structured with more detail without significant bloat.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity (1 parameter, output schema exists), the description is minimally adequate. But it lacks examples, error scenarios, or any usage hints that an agent might need for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, meaning the description must add meaning to the parameter. It only says 'numeric id' but does not describe the parameter name 'task_id' or any constraints beyond type integer. Minimal added value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Fetch', the resource 'task', and the key detail 'by its numeric id'. This distinguishes it from siblings like list_tasks (fetching multiple) or create_task (creating).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as when to use get_task vs list_tasks. It lacks context for typical use cases or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all tasks, optionally filtered by status (todo, in_progress, or done).
| Name | Required | Description | Default |
|---|---|---|---|
| status | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey behavior. It states it lists tasks, implying a read-only operation, but does not mention pagination, sorting, or limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that front-loads the core purpose and immediately covers the optional parameter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low parameter count and output schema existence, the description is adequate but could mention that it returns a list of task objects or default sorting.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning to the 'status' parameter by listing the possible enum values and indicating filtering is optional, supplementing the schema which already defines the enum.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and resource 'tasks', and the optional filtering differentiates it from siblings like 'create_task' and 'delete_task'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions optional filtering by status but does not provide explicit guidance on when to use this tool versus alternatives, e.g., 'get_task' for a single task.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Move a task to a new status: todo, in_progress, or done.
| Name | Required | Description | Default |
|---|---|---|---|
| status | Yes | ||
| task_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states the basic mutation effect but does not mention permissions, idempotency, reversibility, or side effects. This is insufficient for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that directly conveys the tool's purpose and valid inputs. No superfluous words; it is front-loaded with the key action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 params, output schema exists) the description provides the core action and valid statuses. However, it omits prerequisites (task must exist), error scenarios, and parameter intent. It is adequate but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, requiring the description to explain parameters. It lists the status enum values (already in schema) but provides no explanation for task_id. The description adds minimal meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Move') and resource ('task'), and specifies the exact new status values. It naturally distinguishes from sibling tools like create_task (adds), list_tasks (lists), get_task (retrieves), and delete_task (removes).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when a task's status needs to be updated to one of the stated values. However, it lacks explicit exclusions or alternative tools; given the complementary nature of siblings, it remains clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0create_taskdelete_taskget_tasklist_tasksupdate_task_statusEach tool targets a distinct operation: create, list (with optional filter), get by id, update status, delete. No overlap or ambiguity.
All tools follow a consistent verb_noun pattern using snake_case (create_task, list_tasks, get_task, update_task_status, delete_task).
5 tools is well-scoped for a simple task manager, covering essential operations without unnecessary complexity.
While basic CRUD and status transition are covered, there is no general update tool to modify task fields like title or description, which is a notable gap.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Task management your AI agents can actually run. One line becomes a context-ready task over MCP.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Official Todoist MCP server for AI assistants to manage tasks, projects, and workflows.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/AdarshVijay101/taskflow-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
