The Model Context Protocol (MCP) is an open standard that lets AI agents and automations talk to external tools and data sources. Taskade's hosted MCP v2 connectors are zero-setup and fully managed — your agents pick up new tools the moment a connector is added, no glue code, no API keys to rotate.
TL;DR: MCP is "USB-C for AI." Taskade Genesis ships hosted MCP v2, agents and automations can use any MCP-compatible tool without writing integration code. You can also use Taskade from Claude Desktop, Cursor, Windsurf, and VS Code via the open-source
@taskade/mcp-serverserver. Workspace DNA stays consistent: Projects (Memory) + Agents (Intelligence) + Automations (Execution) + App UI (Interface). Try MCP →
The Four Layers of Workspace DNA
What is MCP?
The Model Context Protocol (MCP) is an open, standardized protocol that provides a consistent way for AI models to discover and interact with external tools, APIs, and data sources. Think of it as a "USB-C for AI" — one universal connector that works with everything.
Instead of building custom integrations for each service, MCP provides a single protocol that any tool can implement. This means:
- Universal connectivity — One protocol connects to any MCP-compatible service
- Standardized tool discovery — AI agents automatically discover what tools are available and how to use them
- Vendor-agnostic — Works across AI providers and tool ecosystems
- Growing ecosystem — Hundreds of MCP servers available for popular services
How MCP Works in Taskade
Taskade implements MCP at two levels:
1. Hosted MCP v2 (Recommended)
Taskade manages everything for you. Hosted connectors run on Taskade's infrastructure with:
- Zero setup — No server to deploy or maintain
- Automatic authentication — OAuth flows handled by Taskade
- High availability — Managed infrastructure with built-in retry logic
- Stateless mode — Lightweight connectors for simple integrations (v6.117.0+)
2. Custom MCP Servers (BYO)
Connect your own MCP-compatible servers for proprietary tools or custom APIs:
- Full control — Host on your own infrastructure
- Custom tools — Expose any API or internal service as an MCP tool
- On-premises data — Keep sensitive data within your network
Hosted MCP v2 Connectors
Taskade's Integrations Directory provides 100+ ready-to-use connectors. Browse them at taskade.com/integrations.
Native Integration Pieces (31)
These are deeply integrated with Taskade's automation engine and provide the richest experience:
| Category | Integrations |
|---|---|
| Communication | Slack (12 capabilities), Discord (6), Telegram Bot (11), Microsoft Teams (3), WhatsApp Business (3), Twilio (1) |
| Gmail (4), MailChimp (1) | |
| Google Workspace | Google Sheets (8), Google Drive (18), Google Calendar (4), Google Docs (4), Google Forms (1) |
| CRM & Sales | HubSpot (5), Apollo (1) |
| E-Commerce | Shopify (13), Stripe (20) |
| Social Media | LinkedIn (2), Twitter/X (2), Facebook Pages (2), Reddit (2), YouTube (2) |
| Developer | GitHub (11), HTTP Request (1) |
| Forms & CMS | Typeform (1), Webflow (1), WordPress (1) |
| Scheduling | Calendly (3), Schedule (1) |
| Content | RSS (2), Zoom (3) |
MCP-Extended Connectors
Beyond the 31 native pieces, MCP v2 enables connection to any service that supports the protocol. The ecosystem is rapidly growing with servers for:
- Database systems (PostgreSQL, MongoDB, Supabase)
- Cloud platforms (AWS, Azure, GCP)
- Development tools (Jira, Linear, Notion)
- Knowledge bases (Confluence, GitBook)
- Payment platforms (Square, PayPal)
- Analytics tools (Mixpanel, Amplitude)
- And many more...
Connecting an MCP Server
Adding a connector takes three short steps. Open your integrations settings, pick a hosted connector or add your own server, then turn on the tools you want your agents and automations to use.
Step 1: Open Integrations Settings
Navigate to your workspace Settings → Integrations or click the Integrations icon in the sidebar.
Step 2: Browse or Add Connectors
For hosted connectors:
- Browse the Integrations Directory
- Click the connector you want to add
- Follow the OAuth or API key setup flow
- The connector is now available for agents and automations
For custom MCP servers:
- Click Add MCP Server
- Enter your MCP server URL
- Taskade will discover available tools automatically
- Configure authentication if required
Step 3: Enable Tools
Once connected, MCP tools appear in:
- Agent tool settings — Toggle which MCP tools each agent can use
- Automation builder — MCP actions appear alongside native actions
Here is what the MCP Connectors picker looks like inside workspace settings. Connected servers sit at the top, the directory sits below, and a button lets you add your own server:
┌────────────────────────────────────────────────────────────────┐
│ Settings › Integrations › MCP Connectors │
├────────────────────────────────────────────────────────────────┤
│ Connected │
│ GitHub Hosted v2 Connected · Manage │
│ Slack Hosted v2 Connected · Manage │
│ PostgreSQL (custom) Your server Connected · Manage │
│ │
│ Integrations Directory [ Search ] │
│ Stripe Shopify Notion Linear │
│ Google Drive HubSpot Discord Calendly │
│ │
│ Bring your own │
│ [ + Add MCP Server ] paste a server URL, tools discovered │
└────────────────────────────────────────────────────────────────┘
Using MCP with AI Agents
MCP connectors give your Custom AI Agents the ability to interact with external services during conversations.
How Agents Use MCP Tools
- Tool discovery — The agent sees all available MCP tools with their descriptions and parameters
- Autonomous tool selection — During a conversation, the agent decides which tool to use based on the user's request
- Tool execution — The agent calls the MCP tool with appropriate parameters
- Response integration — Tool results are incorporated into the agent's response
An MCP connector is the bridge between your agent and the outside service. The agent calls a tool, the hosted connector handles auth and the request, and the live result flows back into the conversation:
Example: Agent with Database MCP
Connect a PostgreSQL MCP server → Your agent can now:
- Query database tables to answer questions
- Insert or update records based on conversation context
- Generate reports from live data
- Monitor database health and alert on anomalies
Example: Agent with GitHub MCP
Connect the GitHub MCP connector → Your agent can:
- Create and manage issues
- Review pull requests
- Search code repositories
- Monitor release activity
MCP tools are part of Taskade's Tools for AI Agents system. All tool usage follows your agent's permissions and knowledge training.
Using MCP with Automations
MCP connectors extend the Automation Engine with additional actions beyond the 31 native integration pieces.
How It Works
- In the automation builder, add a new action step
- Select an MCP tool from the connected servers
- Configure the tool parameters (can use variables from previous steps)
- The MCP action executes within your automation flow
Combining MCP with Native Actions
Create powerful workflows by chaining MCP actions with native Taskade actions:
- Trigger: New form submission (native)
- Action 1: Look up customer in CRM via MCP
- Action 2: Enrich data with AI agent (native)
- Action 3: Update external database via MCP
- Action 4: Send Slack notification (native)
Building Custom MCP Servers
Developers can build their own MCP servers to expose custom APIs as Taskade tools. This is ideal for:
- Internal tools — Connect proprietary APIs and internal services
- Custom data sources — Expose databases, knowledge bases, or file systems
- Specialized workflows — Build domain-specific tools for your agents
Getting Started
- Choose a framework — Use an MCP SDK (available for TypeScript, Python, Java, and more)
- Define your tools — Describe each tool with a name, description, and parameter schema
- Implement handlers — Write the logic for each tool invocation
- Deploy — Host your server on any infrastructure (cloud, edge, on-premises)
- Connect to Taskade — Add your server URL in workspace settings
MCP Server Best Practices
- Clear descriptions — Write human-readable descriptions so AI agents understand when and how to use each tool
- Structured parameters — Define clear input/output schemas for reliable tool execution
- Error handling — Return meaningful error messages that agents can interpret
- Idempotency — Design tools that can safely be retried on failure
- Security — Implement authentication and validate inputs
For detailed API documentation and MCP server specifications, see the Taskade Developer API guide.
MCP FAQ
Quick answers on models, credits, Taskade Genesis apps, and security. For more questions, see the Frequently Asked Questions accordion further down this page.
What AI models work with MCP?
MCP works with all 15+ frontier models available in Taskade, from OpenAI, Anthropic, and Google plus leading open-weight providers. Whichever model you pick routes its tool calls through Taskade's MCP connector layer.
Do MCP tools cost additional credits?
MCP tool calls use your plan's AI credits. Each tool invocation counts as part of the agent conversation or automation run that triggered it. There are no separate MCP fees.
Can I use MCP in Taskade Genesis apps?
Yes! Taskade Genesis apps can leverage MCP connectors through embedded agents and automations. This means your published apps can interact with external services, databases, and APIs.
What's the difference between hosted and self-hosted MCP?
Hosted (v2): Taskade manages the infrastructure. Zero setup, automatic scaling, built-in auth. Best for most users.
Self-hosted: You run the MCP server on your own infrastructure. Full control, access to private networks. Best for enterprise or custom tools.
Is MCP secure?
Yes. All MCP connections use encrypted HTTPS. Hosted connectors use Taskade's secure credential management. Self-hosted servers can implement their own authentication. All tool calls are logged in your automation history for full auditability.
Ready to connect your tools? Create a workspace and start connecting MCP servers to your agents and automations.
Connect Taskade to Claude Desktop, Cursor & Other AI Tools
Taskade also works as an MCP server — meaning external AI tools like Claude Desktop, Cursor, Windsurf, VS Code, and any MCP-compatible assistant can connect to your Taskade workspace and use its capabilities.
What external AI tools can do with your Taskade workspace:
- Manage projects, tasks, and databases
- Create and chat with AI agents
- Run automation workflows
- Access workspace data and media
Set Up: Connect Claude Desktop to Taskade
Step 1: Install the Taskade MCP server. Open your terminal and run:
npx -y @taskade/mcp-server
Step 2: Add Taskade to your Claude Desktop configuration. Open claude_desktop_config.json and add:
{ "mcpServers": { "taskade": { "command": "npx", "args": ["-y", "@taskade/mcp-server"], "env": { "TASKADE_API_KEY": "your-api-key-here" } } }}
Step 3: Get your Taskade API key from taskade.com/settings/api.
Step 4: Restart Claude Desktop. You should see Taskade listed in the available MCP tools.
Set Up: Connect Cursor to Taskade
In Cursor, go to Settings → MCP Servers and add:
{ "taskade": { "command": "npx", "args": ["-y", "@taskade/mcp-server"], "env": { "TASKADE_API_KEY": "your-api-key-here" } }}
The same configuration works for Windsurf, VS Code (with Copilot MCP support), and any other MCP-compatible tool.
Open source: The Taskade MCP server is available at github.com/taskade/mcp. You can also use it to generate MCP servers from any OpenAPI spec.
Frequently Asked Questions
What does an MCP connector let my agent do?
An MCP connector is a bridge between your AI agent and an outside service like GitHub, Slack, Stripe, or your own database. The agent picks the right tool, the hosted connector handles the sign-in and the request, and the live result flows straight back into the conversation. This means your agents can read data, create records, and take real actions in the tools your team already uses.
Which plan do I need for MCP connectors?
It depends on which direction you're connecting. Using Taskade from an external AI tool (Claude Desktop, Cursor, or any MCP client, via the hosted Taskade MCP server) is available on every paid plan — Starter ($6/mo) and up. Connecting your own external MCP servers to your Taskade agents and automations (MCP-as-client) is on Business ($40/mo) and up. See pricing for current details.
What is the difference between built-in tools and MCP connectors?
Built-in tools are the 34 native tools that ship with every AI agent, like web search, code, and file analysis. MCP connectors extend that set by linking agents to outside services and data sources through the open Model Context Protocol. Built-in tools work out of the box, while MCP connectors add the specific apps, databases, and APIs your work depends on.
How do I add an MCP connector?
Open your workspace Settings → Integrations, then either pick a hosted connector from the Integrations Directory or click Add MCP Server and paste your own server URL. Hosted connectors walk you through a quick sign-in, and Taskade discovers the available tools for you. The connector is then ready to toggle on for your agents and automations.
Can I use MCP connectors inside my Taskade Genesis apps?
Yes. Taskade Genesis apps use MCP connectors through their embedded agents and automations. This means a published app can look up a customer in your CRM, update a database, or post to Slack while a visitor uses it. Your app becomes a real product that talks to the services around it, not a static page.
Do MCP connectors work with every AI model?
Yes. MCP works across all 15+ frontier models in Taskade, from OpenAI, Anthropic, and Google plus leading open-weight providers. Whichever model you pick, its tool calls route through the same MCP connector layer. You can switch models without reconnecting anything.
Can I connect my own private tools and APIs?
Yes. Alongside the hosted connectors, you can add your own MCP server to expose internal APIs, private databases, or proprietary tools. You host the server on your own infrastructure, paste its URL into workspace settings, and Taskade discovers the tools automatically. This keeps sensitive data inside your network while still giving your agents access.
Related guides
- Tools for AI Agents — Native 34 built-in agent tools
- Custom AI Agents — Agents that use MCP-connected tools
- Automations — Use MCP tools inside automation flows
- Taskade API — Alternative: call Taskade from external code
- Integrations Directory — 100+ native connectors (no MCP setup needed)