Connect your AI to your apps with MCP: The complete setup guide

TL;DR

• MCP is the interface that lets Claude search your Slack history, find free slots in Google Calendar, and draft replies from your Gmail inbox, without you copying and pasting context between tabs.

• Raw local setups require you to edit JSON config files by hand, manage OAuth credentials yourself, and re-authenticate manually every time a token expires, roughly every hour for Google connections.

• Composio replaces all of that with one managed URL: add the mcp-remote command block to Claude Desktop's config file or paste the URL directly into Cursor's MCP settings, authenticate your first app via the Connect Link, and you're live. Token refresh runs in the background. First integration typically takes under 30 minutes. Free tier includes 100,000 tool calls per month, no credit card required.

You want your AI assistant to search your Slack history, update your calendar, and draft a reply from your inbox. What you don't want is to spend your weekend debugging expired credentials and editing local configuration files. That's exactly where most people get stuck with MCP today. The standard interface itself is solid, but raw local setups are fragile and time-consuming. This guide walks you through the full picture: what MCP actually is, how to connect Claude and Cursor to your daily apps, and how to avoid the authentication headaches that break local setups, using Composio's managed MCP server to get a working connection in one sitting.

The core value of linking AI to your daily apps

How MCP bridges AI and your apps

Think of MCP as a USB-C port for software. Before USB-C, every device needed a different cable. Before MCP, every AI model needed a different custom integration for every app it connected to. With three AI models and ten apps, you were maintaining 30 separate integrations.

MCP collapses that into what engineers call the M+N problem. As Richard Hightower explains, MCP provides a standard interface: build one MCP server for your tool and any MCP-compatible AI client can use it. Build one MCP client and any MCP server works with it. One cable, any device.

![Diagram showing the M×N integration problem: without MCP, every AI model requires a custom integration for every app (M models × N apps = M×N integrations). With MCP, each model and each app connects once to the shared protocol layer (M+N total connections)]

MCP works in two parts: one part defines what the request looks like, and the other carries it between your AI and the app. When you ask Claude to find your free slots tomorrow, one part formats the request, the other sends it to the MCP server, which calls Google Calendar and sends back results Claude can read. No glue code, no one-off API wrappers. For a visual explanation, IBM Technology's MCP breakdown is worth a watch.

Why integrations save you hours

Without connected apps, every AI-assisted task has a manual hand-off in the middle. You pull context from your inbox, paste it into a chat window, get a response, and then go back to act on it. That's the workflow tax that compounds across your day.

The MCP ecosystem has scaled fast enough to signal this is becoming infrastructure rather than novelty. By mid-2026, MCP had reached 97 million monthly SDK downloads with 8,000 to 12,000 distinct servers, up from roughly 50 servers at launch in November 2024. About 41% of teams surveyed had moved to some form of production use. Once your AI can act directly inside your apps, the compounding starts working in your direction. One connected calendar means your AI finds free slots automatically. One connected inbox means it drafts replies without you copying context.

Supported tools for your AI stack

Our tool catalog covers 1,000+ pre-built integrations. The apps most relevant to solo operators and small teams include:

• Communication: Gmail (63 methods), Slack, Outlook, Telegram

• Productivity: Notion, Google Drive, Google Calendar, Asana

• Development: GitHub, Linear, Jira, Bitbucket

• Sales: Salesforce, HubSpot, Pipedrive, Apollo

• Finance: Stripe, FreshBooks, Xero, Wave Accounting, Zoho Books, Sage, NetSuite

Each integration returns structured, LLM-friendly JSON rather than raw API responses, which matters because an unprocessed Gmail search result is a wall of nested data that can degrade your AI's reasoning.

Behind the scenes of your AI connections

How MCP connectors bridge your apps

MCP works in two parts: one shapes the request into a format the app understands, the other carries it between your AI and the app. Here's how a typical tool call flows:

1. You ask Claude to find your free slots tomorrow.

2. MCP formats Claude's request into something the target app understands.

3. MCP sends that formatted request to the server, which calls Google Calendar.

4. Calendar returns available times as structured data.

5. Claude reads the response and gives you a plain-English answer.

Zapier and Make handle linear automations well when the sequence never changes. Our managed MCP server enables agentic workflows where the AI decides which tools to call and in what order based on what you ask. This is different from fixed trigger-action chains because the AI can dynamically select tools, branch based on intermediate results, and adapt to changing context. For a deeper look at how MCP differs from traditional API calls, IBM Technology's MCP vs. API video covers the distinction well.

Getting started with Claude MCP

Claude Desktop is the most common entry point. The raw local setup requires editing a configuration file directly on your machine.

Finding your config file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

• Windows: %APPDATA%\Claude\claude_desktop_config.json

A local multi-server setup looks like this:

{
  "mcpServers": {
    "gmail": {
      "command": "node",
      "args": ["/path/to/gmail-mcp-server/index.js"],
      "env": {
        "GMAIL_CLIENT_ID": "your-client-id",
        "GMAIL_CLIENT_SECRET": "your-client-secret"
      }
    },
    "slack": {
      "command": "python",
      "args": ["/path/to/slack-mcp-server/main.py"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-token"
      }
    }
  }
}

The problem with this approach is maintenance. A trailing comma in the JSON file causes a parsing error in strict JSON consumers like Claude Desktop, which can prevent the affected server from loading, though parsers with lenient settings may still process it. A wrong path in the args field, pointing to a server binary that doesn't exist at that location, prevents that specific server from loading, while other servers in the config are unaffected. And when your Google OAuth token expires after about an hour, the connection drops silently mid-task.

With Composio, the entire config collapses to a single managed URL:

{
  "mcpServers": {
    "composio": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.composio.dev/composio/server/YOUR_SERVER_ID"
      ]
    }
  }
}

One entry replaces every local server block. After saving, quit Claude Desktop completely and restart it for the server to load. To see the full setup in action, watch Vadym's Claude MCP walkthrough covering the process end-to-end, and the Composio Notion integration guide shows the same pattern for a specific app.

Mapping your apps to AI workflows

Before you start connecting everything, pick the setup path that matches your technical comfort level:

For most solo operators, the managed URL path gets you to a working connection fastest.

How to link Cursor to your app stack

Cursor uses the same MCP protocol, and adding Composio is straightforward. Here are the steps:

1. Open Cursor Settings with Cmd+, (macOS) or Ctrl+, (Windows) and navigate to the MCP tab.

2. Select Add new global MCP server.

3. Paste your Composio managed MCP URL.

4. Save and check Tools and MCP to confirm the server shows a green status indicator.

Cursor's Agent scans enabled MCP servers on startup and loads the tools they expose. With Composio connected, Cursor's Agent gains access to your full app stack automatically. For a practical walkthrough, AI Agents Simplified's Composio tutorial covers the Cursor setup alongside other AI clients.

Quick wins for your initial connection

Select your primary workflow integration

Start with the one app you open most before 10am. For most consultants and freelance operators, that's either email or calendar. Both have clear, testable outcomes: if your AI can find your next free slot or summarize your unread threads, you'll know immediately whether the connection is working.

Gmail's Composio toolkit covers a broad range of operations including search, send, label management, and thread handling. Check the toolkit page for the current full method list. Google Calendar covers event creation, slot finding, and attendee management. Either one gives you a fast, visible win. Once you've confirmed the first connection works, add one more. Don't try to connect your entire stack in the same session.

Common tasks to automate first

These four tasks work well as first tests because they're easy to verify and immediately useful:

1. Find free time: "What's my first available 30-minute slot tomorrow afternoon?" Routes to Google Calendar and returns available windows.

2. Search Slack history: "What did the team discuss about the Q3 launch last week?" Routes to Slack and returns relevant threads.

3. Summarize unread email: "What do I need to respond to in my inbox today?" Routes to Gmail and returns a prioritized summary.

4. Create a task: "Add a follow-up task for Thursday's client call to Asana." Routes to Asana and creates the item.

Watch Josh Hart's Claude demo to see how quickly these basic connections compound into more complex workflows once the foundation is in place.

How to confirm your MCP link

After restarting Claude Desktop or saving your Cursor MCP settings, test the connection with a direct question:

• In Claude: type "What tools do you have access to?" and check whether your connected apps appear in the response.

• In Cursor: open the Tools and MCP settings panel and look for a green status indicator next to the Composio server.

If tools don't appear, the most common causes are a missing restart (Claude Desktop must be fully quit and relaunched, not just closed and reopened) or a malformed JSON file. The Composio Q&A session on MCP setup covers the most common confirmation failures and how to resolve them.

Verified integrations for popular work tools

Syncing tasks with AI assistants

Task managers like Asana, Linear, and Jira all connect through our managed MCP server. Once connected, your AI can create, update, query, and close tasks directly from a conversation. Ask "what tasks are assigned to me this week in Linear?" and the agent queries Linear's API, parses the response, and returns a plain-English summary. GitHub connects the same way, covering issues, pull requests, commits, and repository management.

Connect Slack and email to your AI

This is where token management matters most. With raw local MCP setups, the OAuth refresh-token flow isn't handled for you, meaning connections can fail silently when access tokens expire. Google OAuth access tokens have a fixed lifespan of 3,600 seconds (about one hour). With a raw local setup, the connection drops and you have to re-authenticate manually every time.

We handle this without any action on your part. When you authenticate Gmail or Slack through our Connect Link (which appears when you first try to use a tool), we store your credentials across sessions and refresh tokens in the background before they expire.

"Since discovering Composio, things have become significantly easier. We were able to integrate all the necessary applications in no time. There's no longer any stress about managing user authentication, as Composio takes care of everything." - Noor Ul Ain S. on G2

Configure MCP for coding assistants

The GitHub toolkit and Linear connect to Cursor through the same Composio MCP URL you added in setup. Once connected, Cursor's Agent can create issues, search repos, update pull request descriptions, and query project status without switching windows.

Automate sales workflows with MCP

Connect Salesforce or HubSpot to automate CRM tasks like logging calls, updating contact records, or pulling pipeline status. Ask "what deals closed this week?" and your AI queries the CRM directly and returns a summary. The Composio Mastra AI integration shows how meeting intelligence tools like Leexi plug into the same MCP infrastructure, so post-call summaries flow directly into CRM records without manual data entry.

Building your own custom MCP connectors

If you need a tool that isn't in our catalog, our SDK lets you define custom tools in Python or TypeScript and expose them through the same managed infrastructure. One tradeoff to know: our pre-built tools are closed-source, so custom development is the path if you need to inspect integration code. The Composio CLI guide covers the basics.

How to audit your AI integration access

Managing your MCP data permissions

Every app connection grants the AI a specific set of permissions based on the OAuth scopes you approve during authentication. In the Composio dashboard, admins can restrict access by whitelisting or blacklisting specific toolkits per team:

• Whitelist: restrict the session to specific toolkit slugs only

• Blacklist: hide specific toolkits the AI shouldn't access

• Tags: filter tools by tags like readOnlyHint to prevent write operations

Start with read-only access for new integrations and expand permissions once you've confirmed the connection behaves as expected.

Managing authorization tokens in MCP

With a raw local setup, token management is entirely your responsibility. When a Google token expires, the connection silently fails and you have to re-authenticate manually, which means navigating the OAuth flow again, updating config files, and restarting your AI client.

Our Connect Link handles this differently. When you first authenticate an app, you follow a standard OAuth flow through the Connect Link URL. We store your credentials for future sessions and refresh tokens automatically in the background.

Managing active MCP connection states

Your active connections are visible in the Composio dashboard. You can see which apps are connected, their connection status, and which tool calls have been made. For teams deploying MCP across multiple users, the MCP Gateway adds per-user audit logs and role-based access controls so you can see exactly who called what tool and when. Individual MCP server instances can be listed and managed through the Composio MCP instances API.

Removing permissions for specific apps

To revoke access for a specific app:

1. Open the Composio dashboard and go to Connected Accounts.

2. Find the app you want to disconnect.

3. Select Revoke Access to invalidate the stored credentials.

After revoking, the stored credentials are invalidated. If the AI attempts to call a tool for that app, it will encounter an authentication error rather than completing the request.

How to solve frequent integration failures

Resolving connection and sync errors

The most common reason a new MCP connection fails is invalid JSON in the configuration file. As Skiln's MCP troubleshooting guide documents, the top causes are JSON syntax errors, wrong paths to server binaries, and missing environment variables for API keys. Configuration mistakes can prevent that server from loading.

If a tool doesn't appear after restart, confirm the app shows Connected status (not Pending or Error) in your Composio dashboard. If you denied a required OAuth scope during authentication, re-authenticate and grant the full scope set. Using the Composio managed URL eliminates most of these failure modes because there's no local server binary, no dependency installation, and no environment variable block to misconfigure.

Resolving expired access tokens

If a connection that worked yesterday fails today, the credential has likely expired. Google OAuth tokens and cloud platform credentials all have expiration windows. With a local setup, your only option is to regenerate the credential and update the config file manually.

With our managed auth layer, this scenario doesn't reach you. We refresh credentials in the background before expiry. If you do encounter a stale connection, navigate to your Composio dashboard, find the affected account under Connected Accounts, and select Re-authenticate to start a fresh OAuth flow. The new credential persists automatically.

Troubleshooting your first MCP connector

Typical setup time for new users

Getting a raw local MCP server running can be time-consuming: installing runtime dependencies (Node.js or Python), editing the JSON config correctly, running through the OAuth flow, testing the connection, and then repeating when the first token expires about an hour later.

With our managed MCP server, the steps are: create a free account, copy your managed URL, add the mcp-remote command block to Claude Desktop's config file or paste the URL into Cursor's MCP settings, restart the client, and authenticate your first app via the Connect Link. Users on SoftwareAdvice consistently report completing Gmail and Google Drive integrations in under 30 minutes. The AgenticFlow Composio MCP walkthrough shows the full flow from signup to first tool call.

Budgeting for your AI integrations

As of August 2026, our pricing tiers are:

The free tier includes 100,000 tool calls per month with no credit card required. That's enough for meaningful daily use across two or three connected apps. The Pro plan starts at $29 per month and adds usage-based capacity beyond the free tier, which suits higher-volume workflows like automated inbox triage or continuous Slack monitoring.

Nango charges per user per connection (roughly $20,000 per month at scale for 20,000 users across a single integration), while our Pro plan at $29 per month scales with usage rather than connection count, and our free tier gives you a genuine trial period without any billing commitment.

How to disable active integrations

To turn off a connector without deleting the configuration:

1. Go to Connected Accounts in your Composio dashboard.

2. Select the app you want to pause.

3. Toggle the connection to Inactive.

This preserves your OAuth credentials and configuration so you can reactivate without going through the full authentication flow again. For permanent removal, use the revoke access flow described in the permissions section above.

Compatibility with your current stack

Composio works with every major AI client and framework:

• AI clients: Claude Desktop, Cursor, ChatGPT (via MCP-compatible interface)

• AI SDKs: Anthropic (Python, TypeScript), OpenAI (Python, TypeScript), Vercel AI SDK (TypeScript), Google (Python, TypeScript)

• Agent frameworks: LangChain (Python, TypeScript), CrewAI (Python), LlamaIndex (Python, TypeScript), Mastra (TypeScript), AutoGen (Python)

The MCP URL approach works with any MCP-compatible client without framework-specific packages. The Composio Vercel AI SDK integration shows how this works for TypeScript-based agent builders.

Sign up for our free tier to get your managed MCP URL and connect your first app today. No credit card required, and we give you 100,000 tool calls free every month.

FAQs

How long does it take to connect an app using Composio's MCP server?

Most users complete their first integration in under 30 minutes. The setup requires copying a single managed URL into your AI client's configuration file, authenticating via the Connect Link, and restarting the client.

What is the cost of using Composio's managed MCP server?

Our free tier includes 100,000 tool calls per month with no credit card required. The Pro plan starts at $29 per month with usage-based capacity beyond the free tier. Visit composio.dev for current pricing.

How does Composio handle expired OAuth tokens?

We refresh OAuth tokens automatically in the background before they expire, preventing mid-task connection drops that are common with raw local MCP setups where you must re-authenticate manually.

What happens if a tool I need isn't in the catalog?

You can build a custom tool using our Python or TypeScript SDK and expose it through the same managed infrastructure. Our pre-built tools are closed-source, so custom development is the path if you need to inspect integration code.

Can I use Composio with ChatGPT as well as Claude and Cursor?

Yes, any MCP-compatible client can connect to our MCP server URL. For ChatGPT, you add the URL through the MCP configuration interface with no additional provider packages needed.

How do I know what data my AI can access after connecting an app?

Your active connections and their OAuth scopes are visible in the Composio dashboard under Connected Accounts. You can restrict access at the session level by filtering to specific toolkits, tools, or tags. For example, filter to tools tagged readOnlyHint to prevent write operations.

Key terms glossary

Model Context Protocol (MCP): A universal communication layer that allows AI models to read from and write to external applications through a standardized interface, eliminating the need for custom integration code for each model-app combination.

Tool Router: A Composio feature that inspects incoming AI requests and automatically routes them to the correct application based on your active connections, removing conditional logic from your agent code.

Connect Link: A secure URL we generate that allows you to authenticate your applications mid-conversation, with credentials persisting automatically for all future sessions.

OAuth token refresh: The process of replacing an expiring access token with a new one before the connection drops. Our managed auth layer handles this automatically, whereas raw local setups require manual re-authentication.

Managed MCP server: A cloud-hosted MCP endpoint that handles authentication, schema formatting, and tool routing on your behalf, replacing the multiple local server configurations you'd otherwise maintain on your own machine.