> ## Documentation Index
> Fetch the complete documentation index at: /docs/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Overview

> Understanding the Model Context Protocol

## What is MCP?

**MCP (Model Context Protocol)** is an open protocol that allows AI agents to connect to external tools and services. Think of it as a universal adapter that lets your AI teammate interact with Slack, HubSpot, Calendly, and any other service.

## How MCP Works

```mermaid theme={null}
graph LR
    A[Your Teammate] --> B[MCP Protocol]
    B --> C[SendGrid Connector]
    B --> D[HubSpot Connector]
    B --> E[Slack Connector]
    B --> F[Custom Connector]
```

1. **AI teammate receives user request** - "Send an email to [john@example.com](mailto:john@example.com)"
2. **AI teammate decides to use a tool** - Determines SendGrid tool is needed
3. **MCP protocol bridges the connection** - Standardized communication
4. **Connector executes the action** - Actually sends the email via SendGrid API
5. **Result returns to AI teammate** - "Email sent successfully"

## Key Concepts

### Connectors

**Connectors** are MCP-compatible servers that provide tools to your AI teammate.

```javascript theme={null}
// A connector provides tools like:
{
  "name": "sendgrid",
  "tools": [
    "send_email",
    "read_emails",
    "search_emails",
    "reply_to_email"
  ]
}
```

### Tools

**Tools** are individual actions your AI teammate can perform through a connector.

```javascript theme={null}
// Example: SendGrid's send_email tool
{
  "name": "send_email",
  "description": "Send an email message",
  "parameters": {
    "to": "recipient@example.com",
    "subject": "Meeting reminder",
    "body": "Don't forget our 3pm meeting"
  }
}
```

### Tool Calling

When your AI teammate needs to use a tool:

1. **AI teammate analyzes user request** - Understands what action is needed
2. **AI teammate selects appropriate tool** - Chooses "send\_email" from SendGrid connector
3. **AI teammate prepares parameters** - Extracts to, subject, body from context
4. **MCP executes tool** - Connector sends the email
5. **AI teammate receives result** - Uses response to continue conversation

## Two Types of Connectors

### 1. Pre-built Connectors

BoostGPT provides 30+ ready-to-use connectors:

* **Managed by BoostGPT** - We handle hosting, updates, and maintenance
* **Checked before it is saved** - A credential the vendor refuses never becomes a connection
* **Connected once** - The workspace holds it; each AI teammate is then allowed to use it

**Example: connecting SendGrid**

```text theme={null}
Dashboard -> Connectors -> SendGrid -> Connect -> paste the API key
-> your teammate's Connectors tab -> add it
```

### 2. External MCP Servers

Connect any MCP-compatible server from the internet:

* **You provide the URL** - Point to any MCP server
* **Third-party or self-hosted** - Host your own or use community servers
* **Custom tools** - Access specialized tools not in our library

**Example: Connecting external server**

```text theme={null}
Teammate -> Tools Tab -> Add Tool -> Add New
-> Enter MCP URL: https://mcp.example.com -> Connect
```

## MCP Protocol Flow

```javascript theme={null}
// 1. Teammate decides to use a tool
User: "Send an email to john@example.com about the meeting"

// 2. Teammate makes MCP request
{
  "connector": "sendgrid",
  "tool": "send_email",
  "parameters": {
    "to": "john@example.com",
    "subject": "Meeting reminder",
    "body": "Don't forget our meeting at 3pm today"
  }
}

// 3. Connector executes via SendGrid API
SendGrid API.sendEmail({...})

// 4. MCP returns result
{
  "success": true,
  "message_id": "msg_abc123",
  "timestamp": "2025-01-05T15:30:00Z"
}

// 5. Teammate responds to user
Teammate: "I've sent the email to john@example.com"
```

## Authentication

### Signing in (connectors and remote servers)

```text theme={null}
1. User presses Connect
2. Redirected to the service to approve access
3. The code is exchanged server-side; the browser never sees a token
4. The connection is created — only now, and only if that succeeded
5. Its tools are read from the server and stored
```

### API Key (External Servers)

```text theme={null}
1. Get API key from MCP server provider
2. Enter URL when connecting to teammate
3. Optionally provide API key if required
4. Connector authenticates with external service
```

## Security

### Pre-built Connectors

* **OAuth 2.0** - Industry-standard secure authentication
* **Encrypted storage** - Tokens encrypted at rest
* **Scoped permissions** - Only request necessary permissions
* **Revokable access** - Disconnect anytime from Dashboard

### External Servers

* **HTTPS required** - All MCP servers must use HTTPS
* **You control access** - Manage authentication yourself
* **Audit logs** - See all tool executions in AI teammate Insights

## Real-World Example

### An AI teammate that keeps the marketing site honest

```text theme={null}
1. Connect, once, on the Connectors screen:
   - HubSpot     who asked, and what they asked about
   - Serper      what people search for before they find you
   - WordPress   the pages themselves

2. Allow them, per teammate, from their Connectors tab.

3. Then:

User:  "What are people asking sales that the pricing page doesn't answer?"
Teammate: *reads HubSpot deals and notes* "Six of the last twelve asked about
       per-seat vs usage billing. The pricing page never uses the word 'seat'."

User:  "What do people search for around that?"
Teammate: *uses Serper* "'per seat pricing', 'usage based pricing calculator',
       'how much does X cost for 5 users'."

User:  "Add a short section answering it."
Teammate: *edits the page in WordPress* "Added 'What counts as a seat?' under
       the pricing table."
```

## MCP vs Direct API Integration

| Feature | MCP Protocol | Direct API |
| - | - | - |
| **Setup** | Connect once, allow per AI teammate | Write custom code for each API |
| **Maintenance** | Automatic updates | Manual updates required |
| **Authentication** | Sign-in handled for you, and checked before it is saved | Implement OAuth yourself |
| **AI Teammate Access** | Automatic tool calling | Manual prompt engineering |
| **Multi-service** | One pattern for all | Different code per service |

## Supported Tool Types

MCP connectors can provide various tool types:

### Data Access

* Read data (emails, contacts, files)
* Search and filter
* Query databases

### Actions

* Send messages
* Create records
* Update information
* Delete items

### Scheduled Tasks

* Set reminders
* Schedule events
* Automate workflows

### Real-time

* Subscribe to events
* Stream data
* Webhooks

## Building Your Own Connector

Want to create a custom MCP connector? See our guide:

> [card] [Creating Connectors](/docs/integrations/custom/overview.md)
>
> Build your own MCP connector

> [card] [MCP Protocol Spec](/docs/integrations/custom/openapi.md)
>
> Technical protocol details

## Debugging Tools

### Insights

View all tool executions:

```text theme={null}
Teammate -> Insights Tab -> Tool Analytics
- See which tools are called
- View success/failure rates
- Monitor response times
```

### Test in the builder chat

```text theme={null}
Site -> Builder chat
- Ask teammate to use tools
- See real-time tool execution
- Debug parameter passing
```

## Limitations

### Rate limits

Every service has its own, and they are the vendor's to enforce: HubSpot allows 100 requests per 10 seconds,
most AI providers meter by tokens or images, and a free tier is usually stricter than a paid one. When a vendor
refuses a call, your AI teammate is told in the vendor's own words rather than being left to guess.

BoostGPT counts calls too — every connector call is logged and charged against your plan's allowance, whichever
connector made it.

### Permissions

An AI teammate can only use what you have connected and left switched on:

```text theme={null}
User:  "Create a HubSpot contact for this lead"
Teammate: "I don't have HubSpot connected. Add it from the Connectors screen and I can."
```

A tool switched off in a connection's settings is invisible to your AI teammate — it is not offered and then refused.

### How many connections

Each plan allows a number of **connections**, not connectors: two connections of the same service — a live
Stripe and a test one — count as two. The Connectors screen shows where you stand against your plan in its
header, and creating one past the limit is refused before anything is made.

## Next Steps

> [card] [Quickstart](/docs/integrations/quickstart.md)
>
> Connect your first service

> [card] [Browse Connectors](/docs/integrations/connectors/overview.md)
>
> See all available connectors

> [card] [Build Custom](/docs/integrations/custom/overview.md)
>
> Create your own connector

> [card] [Remote MCP servers](/docs/integrations/remote-mcp.md)
>
> Connect a server the vendor runs


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.