# Taskade Mcp

> 🤖 Taskade MCP · Official MCP server and OpenAPI to MCP codegen. Build AI agent tools from any OpenAPI API and connect to Claude, Cursor, and more.

- **Type:** MCP server
- **Install:** `agentstack add mcp-taskade-mcp`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [taskade](https://agentstack.voostack.com/s/taskade)
- **Installs:** 0
- **Category:** [Integrations](https://agentstack.voostack.com/c/integrations)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [taskade](https://github.com/taskade)
- **Source:** https://github.com/taskade/mcp
- **Website:** https://taskade.com/blog/mcp

## Install

```sh
agentstack add mcp-taskade-mcp
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Taskade MCP Server

> The **Workspace MCP** (`@taskade/mcp-server`) — run your Taskade workspace from any AI client.

**Connect [Taskade](https://www.taskade.com) to any AI assistant — Claude, Cursor, Windsurf, VS Code, and more — via the [Model Context Protocol](https://modelcontextprotocol.io/).**

[](https://www.npmjs.com/package/@taskade/mcp-server)
[](https://github.com/taskade/mcp)
[](https://github.com/taskade/mcp/blob/main/LICENSE)

[](cursor://anysphere.cursor-deeplink/mcp/install?name=taskade&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkB0YXNrYWRlL21jcC1zZXJ2ZXIiXSwiZW52Ijp7IlRBU0tBREVfQVBJX0tFWSI6InlvdXItYXBpLWtleS1oZXJlIn19)
[](vscode:mcp/install?%7B%22name%22%3A%22taskade%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40taskade%2Fmcp-server%22%5D%2C%22env%22%3A%7B%22TASKADE_API_KEY%22%3A%22%24%7Binput%3Ataskade_api_key%7D%22%7D%7D)

**62 tools** for workspaces, projects, tasks, AI agents, agent chat, webhooks, knowledge bases, templates, media, and sharing — all from your AI client.

- [MCP Server](https://github.com/taskade/mcp/tree/main/packages/server) — Connect Taskade to Claude Desktop, Cursor, Windsurf, or any MCP client.
- [OpenAPI Codegen](https://github.com/taskade/mcp/tree/main/packages/openapi-codegen) — Generate MCP tools from any OpenAPI spec — not just Taskade.

---

## Contents

- [Demo](#demo)
- [Quick Start](#quick-start)
- [Tools (62)](#tools-62)
- [Why Taskade MCP?](#why-taskade-mcp)
- [Agent Recipes](#agent-recipes)
- [Use Cases](#use-cases)
- [OpenAPI Codegen](#openapi-codegen)
- [What is Taskade?](#what-is-taskade)
- [Roadmap](#roadmap)
- [Contributing](#contributing)
- [License](#license)

---

## Demo

MCP-powered Taskade agent running inside Claude Desktop by Anthropic:

| Build Agents via MCP | Automate Workflows | Manage Projects |
|:---:|:---:|:---:|
|  |  |  |
| Create, train, deploy AI agents from Claude/Cursor | Build multi-step automations across 100+ services | Full workspace management from your AI assistant *(paid plans; some endpoints gated on free)* |

---

## Quick Start

> ⚡ **Prefer a hosted option?** `https://www.taskade.com/mcp` is the OAuth-protected **[Genesis App MCP](https://github.com/taskade/docs/blob/main/apis-living-system-development/genesis-app-mcp.md)** — a *separate hosted surface* from this Workspace MCP server. See its guide to learn what it does and whether it fits your use case. To read and write your workspace **content** (projects, tasks, agents) as described below, use the Workspace MCP server (this package).

## Which Taskade MCP do I want?

Taskade speaks MCP through three surfaces — this repo is the first one:

| I want to… | Use | Where / auth |
|---|---|---|
| Have my AI client **read & write my projects, tasks, agents** | **Workspace MCP** — this repo (`@taskade/mcp-server`) | Local stdio · personal token · most plans |
| **Edit my published app's code** from my IDE | **[Genesis App MCP](https://github.com/taskade/docs/blob/main/apis-living-system-development/genesis-app-mcp.md)** | Hosted · OAuth 2.0 (`https://www.taskade.com/mcp`) · Business+ |
| Let my agents **reach Slack / Shopify / Gmail** | **[MCP Connectors](https://github.com/taskade/docs/blob/main/genesis-living-system-builder/genesis/mcp-connectors.md)** | Hosted, in-product |

### 1. Get Your API Key

Go to [Taskade Settings > API](https://www.taskade.com/settings/api) and create a Personal Access Token.

### 2. Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "@taskade/mcp-server"],
      "env": {
        "TASKADE_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

### 3. Cursor

Add to your Cursor MCP settings:

```json
{
  "mcpServers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "@taskade/mcp-server"],
      "env": {
        "TASKADE_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

### 4. Windsurf

Add to `~/.codeium/windsurf/mcp_config.json` (or **Settings → Cascade → MCP → Add Server**):

```json
{
  "mcpServers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "@taskade/mcp-server"],
      "env": {
        "TASKADE_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

### 5. Cline

In VS Code, open the Cline **MCP Servers** panel → **Configure MCP Servers** and add:

```json
{
  "mcpServers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "@taskade/mcp-server"],
      "env": {
        "TASKADE_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

### 6. VS Code

Add a `.vscode/mcp.json` to your workspace (VS Code uses the `servers` key; `${input:…}` prompts for your key on first run):

```json
{
  "servers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "@taskade/mcp-server"],
      "env": {
        "TASKADE_API_KEY": "${input:taskade_api_key}"
      }
    }
  }
}
```

### 7. HTTP / SSE Mode (remote & custom clients)

```bash
TASKADE_API_KEY=your-api-key npx @taskade/mcp-server --http
```

The server starts at `http://localhost:3000` (configure with `PORT` env var). Connect via SSE at `http://localhost:3000/sse?access_token=your-api-key`.

---

## Tools (62)

### Workspaces

| Tool | Description |
|------|-------------|
| `workspacesGet` | List all workspaces |
| `workspaceFoldersGet` | List folders in a workspace |
| `workspaceCreateProject` | Create a project in a workspace |

### Projects

| Tool | Description |
|------|-------------|
| `projectGet` | Get project details |
| `projectCreate` | Create a new project |
| `projectCopy` | Copy a project to a folder |
| `projectComplete` | Mark project as completed |
| `projectRestore` | Restore a completed project |
| `projectMembersGet` | List project members |
| `projectFieldsGet` | Get custom fields for a project |
| `projectShareLinkGet` | Get the share link |
| `projectShareLinkEnable` | Enable the share link |
| `projectBlocksGet` | Get all blocks in a project |
| `projectTasksGet` | Get all tasks in a project |
| `folderProjectsGet` | List projects in a folder |

### Tasks

| Tool | Description |
|------|-------------|
| `taskGet` | Get task details |
| `taskCreate` | Create one or more tasks |
| `taskPut` | Update a task |
| `taskDelete` | Delete a task |
| `taskComplete` | Mark task as complete |
| `taskUncomplete` | Mark task as incomplete |
| `taskMove` | Move a task within a project |
| `taskAssigneesGet` | Get task assignees |
| `taskPutAssignees` | Assign users to a task |
| `taskDeleteAssignees` | Remove assignees |
| `taskGetDate` | Get task due date |
| `taskPutDate` | Set task due date |
| `taskDeleteDate` | Remove task due date |
| `taskNoteGet` | Get task note |
| `taskNotePut` | Update task note |
| `taskNoteDelete` | Delete task note |
| `taskFieldsValueGet` | Get all field values |
| `taskFieldValueGet` | Get a specific field value |
| `taskFieldValuePut` | Set a field value |
| `taskFieldValueDelete` | Delete a field value |

### AI Agents

Create, manage, and publish autonomous AI agents with custom knowledge and tools.

| Tool | Description |
|------|-------------|
| `folderAgentGenerate` | Generate an AI agent from a text prompt |
| `folderCreateAgent` | Create an agent with custom configuration |
| `folderAgentGet` | List agents in a folder |
| `agentGet` | Get agent details |
| `agentUpdate` | Update agent configuration |
| `deleteAgent` | Delete an agent |
| `agentPublicAccessEnable` | Publish agent publicly |
| `agentPublicGet` | Get public agent details |
| `agentPublicUpdate` | Update public agent settings |
| `agentKnowledgeProjectCreate` | Add a project as agent knowledge |
| `agentKnowledgeMediaCreate` | Add media as agent knowledge |
| `agentKnowledgeProjectRemove` | Remove project from knowledge |
| `agentKnowledgeMediaRemove` | Remove media from knowledge |
| `agentConvosGet` | List agent conversations |
| `agentConvoGet` | Get conversation details |
| `publicAgentGet` | Get agent by public ID |

### Templates

| Tool | Description |
|------|-------------|
| `folderProjectTemplatesGet` | List available project templates |
| `projectFromTemplate` | Create a project from a template |

### Media

| Tool | Description |
|------|-------------|
| `mediasGet` | List media files in a folder |
| `mediaGet` | Get media details |
| `mediaDelete` | Delete a media file |

### Personal

| Tool | Description |
|------|-------------|
| `meProjectsGet` | List all your projects |

### Agent Chat & Webhooks (API v2, beta)

Capabilities the v1 API doesn't have: hold a live conversation with an AI agent, and receive real-time events.

| Tool | Description |
|------|-------------|
| `promptAgent` | Send a message to an AI agent and get its reply |
| `listConversations` | List an agent's conversations |
| `getConversation` | Get a conversation's messages |
| `subscribeWebhook` | Subscribe to real-time Taskade event webhooks |
| `unsubscribeWebhook` | Remove a webhook subscription |

---

## Why Taskade MCP?

Taskade MCP gives your AI assistant **access to your workspace** — projects, tasks, agents, knowledge bases, templates, and automations (on paid plans; some endpoints such as workspace listing are gated for free accounts). Instead of writing API code, describe what you need in natural language.

```
┌──────────────────────────────────────────────────────────┐
│                HOW TASKADE MCP WORKS                     │
└──────────────────────────────────────────────────────────┘

  You (in Claude/Cursor/Windsurf):
  "Create a support agent trained on our docs project"
                         ↓
  ┌──────────────────────────────────┐
  │     Taskade MCP Server           │
  │     (62 tools, 8 categories)     │
  └──────────────────────────────────┘
       ↓              ↓            ↓
  folderCreateAgent  agentKnowledge  agentPublicAccess
  (creates agent)    (attaches docs)  (publishes it)
                         ↓
  Result: Live AI chatbot trained on your data
```

| What You Say | What Happens |
|-------------|-------------|
| "Show me all overdue tasks" | Reads projects → filters tasks → formats report |
| "Create a support agent trained on our docs" | Creates agent → attaches knowledge → publishes |
| "Set up next week's sprint from our template" | Copies template → populates tasks → assigns team |
| "Summarize yesterday's completed work" | Reads task history → generates standup summary |

### Why MCP Instead of REST API?

| | REST API | MCP Server |
|-|----------|-----------|
| **Setup** | Write HTTP client, handle auth, parse JSON | `npx @taskade/mcp-server` — one command |
| **Interface** | Code against endpoints | Natural language — describe what you need |
| **Chaining** | Manual orchestration | AI chains tools intelligently |
| **Error handling** | Write error handling code | AI interprets errors and retries |

### Why Taskade MCP Over Other MCP Servers?

Taskade is the only MCP server that includes **AI agent management** (create, train, deploy agents), **knowledge base training** (attach docs, projects, media), and **OpenAPI codegen** (generate MCP tools from any API spec). 62 tools across 8 categories.

---

## Agent Recipes

Recipe 1: Daily Standup Summarizer

**Problem:** Team standup notes scattered across Slack, email, and docs.

```
You: "Check my Taskade workspace for yesterday's completed tasks,
      summarize them as a standup update, then create today's
      priority tasks based on what's still open."

Claude uses:
  1. meProjectsGet → find your active projects
  2. projectTasksGet → pull tasks from each project
  3. taskCreate → create today's priority tasks

Result: A formatted standup summary + fresh task list in Taskade.
```

Recipe 2: Knowledge Base Agent Builder

**Problem:** You have docs scattered across files and need an AI agent trained on them.

```
You: "Create an AI support agent called 'Help Bot' in my
      Customer Success folder, train it on our Documentation
      project, and publish it publicly."

Claude uses:
  1. workspaceFoldersGet → find "Customer Success" folder
  2. folderCreateAgent → create "Help Bot" with support instructions
  3. agentKnowledgeProjectCreate → attach Documentation project
  4. agentPublicAccessEnable → publish with shareable link

Result: Live AI chatbot trained on your docs, ready to embed.
```

Recipe 3: Sprint Planning Automation

**Problem:** Creating sprint projects manually every two weeks.

```
You: "Create a new sprint project from our 'Sprint Template',
      name it 'Sprint 2026-W15', move the top 10 backlog
      items into it, and assign them to the engineering team."

Claude uses:
  1. folderProjectTemplatesGet → find "Sprint Template"
  2. projectFromTemplate → create "Sprint 2026-W15"
  3. projectTasksGet → get backlog items
  4. taskMove → move top 10 tasks to new sprint
  5. taskPutAssignees → assign engineering team members

Result: Sprint ready to go, fully populated and assigned.
```

Recipe 4: Competitive Intelligence Agent

**Problem:** You need an agent that monitors competitors and reports findings.

```
You: "Generate an AI agent that researches our top 5 competitors.
      Train it on our Competitive Analysis project.
      Name it 'Market Intel Agent'."

Claude uses:
  1. folderAgentGenerate → generate agent from research prompt
  2. agentKnowledgeProjectCreate → connect Competitive Analysis project
  3. agentUpdate → refine instructions for research cadence

Result: AI research agent with domain knowledge, ready for briefings.
```

Recipe 5: Client Onboarding Pipeline

**Problem:** Each new client needs the same project structure, tasks, and materials.

```
You: "For our new client Acme Corp: create a project from
      the 'Client Onboarding' template, add tasks for
      kickoff meeting and SOW review, set due dates for
      the next 2 weeks, then share the project link."

Claude uses:
  1. projectFromTemplate → create "Acme Corp Onboarding"
  2. taskCreate → add kickoff, requirements, SOW tasks
  3. taskPutDate → set dates across next 2 weeks
  4. projectShareLinkEnable → generate share link

Result: Client onboarding project live and shareable in 30 seconds.
```

---

## Use Cases

### Project Management with AI

Ask your AI assistant to manage your Taskade workspace:

- "Show me all my projects and their status"
- "Create a new project called Q1 Planning with tasks for each team"
- "Move all overdue tasks to the Backlog project"
- "Set due dates for all tasks in the Sprint project"

### AI Agent Creation

Build and deploy AI agents directly from your editor:

- "Create an AI agent called Customer Support Bot with knowledge from our docs project"
- "Generate an agent for code review using this prompt: ..."
- "Publish my agent publicly and give me the share link"
- "Add our API documentation project as knowledge to the agent"

### Template Workflows

Automate project creation from templates:

- "List all templates in my workspace"
- "Create 5 new client onboarding projects from the Client Template"
- "Copy the Sprint Retrospective project for this week"

---

## OpenAPI Codegen

Use our generator to build MCP tools from any OpenAPI spec — not just Taskade.

```bash
npm install --save-dev @taskade/mcp-openapi-codegen @readme/openapi-parser
```

```ts
import { dereference } from '@readme/openapi-parser';
import { codegen } from '@taskade/mcp-openapi-codegen';

const document = await dereference('your-api-spec.yaml');

await codegen({
  path: 'src/tools.generated.ts',
  document,
});
```

Works with any OpenAPI 3.0+ spec. Generate MCP tools for your own APIs in minutes.

---

## What is Taskade?

[Taskade](https://www.taskade.com) ([Y Combinator S19](https://www.ycombinator.com/companies/taskade)) is the AI-native workspace for building apps, deploying agents, and automating workflows — from a single prompt. **150,000+ apps generated. Trusted by 3M, Nike, Tesla, Netflix, Airbnb, Disney, Adobe.** Rated 4.8/5 across 9,300+ reviews.

- **Genesis Apps** — Build complete apps from pr

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [taskade](https://github.com/taskade)
- **Source:** [taskade/mcp](https://github.com/taskade/mcp)
- **License:** MIT
- **Homepage:** https://taskade.com/blog/mcp

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-taskade-mcp
- Seller: https://agentstack.voostack.com/s/taskade
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.