MCP

What is MCP?

Model Context Protocol (MCP) is an open-source standard for connecting AI applications to external systems. Think of MCP like a USB-C port for AI applications—just as USB-C provides a standardized way to connect electronic devices, MCP provides a standardized way to connect AI applications to external systems.

Using MCP, AI applications like Claude, ChatGPT, or GitHub Copilot can connect to:

Data sources (e.g., local files, databases)
Tools (e.g., search engines, calculators)
Workflows (e.g., specialized prompts)

This enables them to access key information and perform tasks in a standardized way.

What is CBK MCP?

CBK MCP is ChatBotKit's implementation of the Model Context Protocol. It provides AI assistants with structured access to ChatBotKit resources and capabilities through a standardized interface.

The CBK MCP server is hosted at https://mcp.cbk.ai/mcp and provides:

Platform Content Access: Search and retrieve documentation, manuals, and tutorials
GraphQL API Integration: Execute queries and mutations against the ChatBotKit platform
Guided Workflows: Pre-built prompts for common development tasks

Why Use CBK MCP?

Instead of building custom integrations for each AI assistant, MCP provides a standardized way for AI assistants to interact with your ChatBotKit platform.

Benefits:

For Developers: Reduces development time and complexity when integrating AI assistants with ChatBotKit
For AI Assistants: Provides access to ChatBotKit's ecosystem of conversational AI features and data
For End Users: Results in more capable AI assistants that can access ChatBotKit resources and take actions on your behalf

Since ChatBotKit specializes in conversational AI technology, the MCP server provides deep integration with all platform features, ensuring AI assistants can leverage the full power of ChatBotKit.

Setup Instructions

Configure your MCP client to connect to https://mcp.cbk.ai/mcp. Below are platform-specific setup instructions:

Claude Desktop

Add the following to your claude_desktop_config.json file:


{
  "mcpServers": {
    "cbk": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-fetch",
        "https://mcp.cbk.ai/mcp"
      ],
      "env": {
        "CBK_SECRET": "your-api-secret-here"
      }
    }
  }
}
json

Replace your-api-secret-here with your ChatBotKit API secret from the ChatBotKit Console.

Learn more about MCP setup in Claude Desktop →

Claude Code

Use the Claude CLI to add the MCP server:


claude mcp add --transport http cbk https://mcp.cbk.ai/mcp \
  --header "Authorization: Bearer your-api-secret-here"
bash

Alternatively, within Claude Code, type /mcp to authenticate and manage MCP servers.

Learn more about MCP setup in Claude Code →

GitHub Copilot (VS Code)

Option 1: Using Command Palette

Open VS Code Command Palette (Cmd/Ctrl + Shift + P)
Run "MCP: Add Server" command
Configure the server:
- Server Name: cbk
- Type: http
- URL: https://mcp.cbk.ai/mcp
- Headers: Authorization: Bearer your-api-secret-here

Option 2: Configuration File

Create/edit .vscode/mcp.json in your workspace:


{
  "servers": {
    "cbk": {
      "type": "http",
      "url": "https://mcp.cbk.ai/mcp",
      "headers": {
        "Authorization": "Bearer your-api-secret-here"
      }
    }
  }
}
json

Learn more about MCP setup in VS Code →

GitHub Copilot Coding Agent

To configure CBK MCP for GitHub Copilot Coding Agent in your repository:

Navigate to your repository on GitHub
Go to Settings → Code & automation → Copilot → Coding agent
Add the following MCP configuration:


{
  "mcpServers": {
    "cbk": {
      "type": "http",
      "url": "https://mcp.cbk.ai/mcp",
      "headers": {
        "Authorization": "$COPILOT_MCP_CBK_SECRET"
      },
      "tools": ["*"]
    }
  }
}
json

Add your API secret to the Copilot environment:
- Go to Settings → Environments
- Create or select the copilot environment
- Add a secret named COPILOT_MCP_CBK_SECRET with your API secret

Learn more about MCP setup in GitHub Copilot Agent →

Cursor

Option 1: Using Settings UI

Open Cursor Settings (Cmd/Ctrl + ,)
Navigate to "Features" → "MCP" or search for "MCP"
Click "Add New MCP Server"
Configure with:
- Server Name: cbk
- Type: http
- URL: https://mcp.cbk.ai/mcp
- Headers: Authorization: Bearer your-api-secret-here

Option 2: Configuration File

Edit ~/.cursor/mcp.json:


{
  "servers": {
    "cbk": {
      "type": "http",
      "url": "https://mcp.cbk.ai/mcp",
      "headers": {
        "Authorization": "Bearer your-api-secret-here"
      }
    }
  }
}
json

Learn more about MCP setup in Cursor →

OpenAI Codex

Use the Codex CLI:


codex mcp add cbk -- npx -y @modelcontextprotocol/server-fetch https://mcp.cbk.ai/mcp
bash

To add authentication, edit ~/.codex/config.toml:


[mcp_servers.cbk]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-fetch", "https://mcp.cbk.ai/mcp"]

[mcp_servers.cbk.env]
CBK_SECRET = "your-api-secret-here"
toml

Learn more about MCP setup in OpenAI Codex →

Gemini Code Assist

Create or edit your MCP configuration file:


{
  "mcpServers": {
    "cbk": {
      "type": "http",
      "url": "https://mcp.cbk.ai/mcp",
      "headers": {
        "Authorization": "Bearer your-api-secret-here"
      }
    }
  }
}
json

Note: Gemini Code Assist MCP support is still evolving. Check the official documentation for the latest setup instructions.

Learn more about MCP setup in Gemini Code Assist →

Available Tools

The CBK MCP server provides the following tools:

Content Search Tool (`cbk.platform.search`)

Search ChatBotKit content by type (docs, manuals, or tutorials).

Input Schema:

type: The type of content to search (doc, manual, or tutorial)
search: The search query to find relevant content

Content Types:

Docs: High-level information about developing conversational AI and AI agents, including API guides, SDK usage examples, and platform feature overviews
Manuals: Detailed technical information about how ChatBotKit works internally, including system architecture, technical specifications, and implementation details
Tutorials: Step-by-step guides and instructional content on using ChatBotKit features and capabilities

Example:


{
  "type": "doc",
  "search": "conversation management"
}
json

Content Fetch Tool (`cbk.platform.fetch`)

Fetch specific ChatBotKit content entries by ID and type.

Input Schema:

type: The type of content to fetch (doc, manual, or tutorial)
ids: Array of content IDs to fetch

Example:


{
  "type": "manual",
  "ids": ["api-architecture", "database-schema"]
}
json

GraphQL Call Tool (`cbk.graphql.call`)

Execute GraphQL queries and mutations against the ChatBotKit platform API.

Input Schema:

query: The GraphQL query or mutation string to execute
variables (optional): Variables for the GraphQL operation as a JSON object
operationName (optional): Name of the operation to execute

Example:


{
  "query": "query ListBots { bots { items { id name } } }",
  "variables": {}
}
json

Security Model:

Uses the caller's Authorization header (not built-in service credentials)
Requires valid authentication for platform resource access
All responses and errors are passed through directly from the platform API

Guided Prompts

The CBK MCP server provides pre-built prompts for common development tasks:

Create App Feature

Prompt: create-cbk-app-feature

Create a new feature for an application using ChatBotKit SDK and platform capabilities.

Parameters:

description: Description of the feature to create (minimum 10 characters)

This prompt guides the AI assistant through:

Researching ChatBotKit documentation and manuals
Understanding the feature requirements
Implementing the feature using ChatBotKit SDK
Following best practices and platform conventions

Update App Feature

Prompt: update-cbk-app-feature

Update an existing feature using ChatBotKit SDK and platform capabilities.

Parameters:

description: Description of the feature update or enhancement (minimum 10 characters)

This prompt guides the AI assistant through:

Analyzing existing code implementation
Researching relevant documentation
Planning the update approach
Implementing changes correctly and safely

Authentication

Public Access (No Authentication Required)

The following operations can be performed without authentication:

Searching platform content (docs, manuals, tutorials)
Fetching platform content by ID

These operations use anonymous client access to provide developers with easy access to ChatBotKit documentation and resources.

Authenticated Access (API Secret Required)

The following operations require authentication with your ChatBotKit API secret:

Executing GraphQL queries and mutations
Accessing private ChatBotKit resources
Managing conversations, datasets, files, and other platform objects

Getting Your API Secret:

Visit the ChatBotKit Console
Navigate to Settings → API Keys
Generate a new API secret or copy an existing one

Authentication Methods:

Depending on your MCP client, provide authentication using:

Environment Variable: CBK_SECRET
HTTP Header: Authorization: Bearer your-api-secret-here

Security and Privacy

CBK MCP is designed with security and privacy at its core:

Authenticated Access: All connections to private resources are authenticated using your ChatBotKit API secret
Account Isolation: The server only provides access to resources within your ChatBotKit account
Data Privacy: Your data remains private and is never shared with other users
Least Privilege: Grants AI assistants only the permissions necessary to perform requested operations
Audit Logging: All API calls are logged for security auditing purposes

Common Usage Examples

Researching Documentation

AI Assistant: Search for documentation about conversation management
Tool Call: cbk.platform.search
{
  "type": "doc",
  "search": "conversation management"
}

Creating a Bot via GraphQL

AI Assistant: Create a new chatbot named "Support Bot"
Tool Call: cbk.graphql.call
{
  "query": "mutation CreateBot($input: BotCreateInput!) { createBot(input: $input) { id name } }",
  "variables": {
    "input": {
      "name": "Support Bot",
      "backstory": "A helpful support assistant"
    }
  }
}

Building a Feature

AI Assistant: I want to create a feature that manages conversations
Prompt: create-cbk-app-feature
{
  "description": "Create a conversation management feature that lists, filters, and displays conversation history with support for pagination"
}

Best Practices

Use Content Search First: Before implementing features, search documentation and manuals to understand ChatBotKit capabilities
Fetch Specific Content: When you find relevant content IDs, use the fetch tool to get complete information
Leverage Guided Prompts: Use the create-cbk-app-feature and update-cbk-app-feature prompts for complex development tasks
Secure Your API Secret: Keep your ChatBotKit API secret secure and never commit it to version control
Test GraphQL Queries: Test GraphQL queries in the ChatBotKit Console before using them via MCP
Monitor API Usage: Check your API usage in the Console to ensure you stay within your plan limits

Help and Support

For help with CBK MCP:

Join the ChatBotKit Discord Server
Visit the ChatBotKit Documentation
Review the Model Context Protocol Documentation
Contact ChatBotKit Support

What is MCP?

What is CBK MCP?

Why Use CBK MCP?

Setup Instructions

Claude Desktop

Claude Code

GitHub Copilot (VS Code)

GitHub Copilot Coding Agent

Cursor

OpenAI Codex

Gemini Code Assist

Available Tools

Content Search Tool (cbk.platform.search)

Content Fetch Tool (cbk.platform.fetch)

GraphQL Call Tool (cbk.graphql.call)

Guided Prompts

Create App Feature

Update App Feature

Authentication

Public Access (No Authentication Required)

Authenticated Access (API Secret Required)

Security and Privacy

Common Usage Examples

Researching Documentation

Creating a Bot via GraphQL

Building a Feature

Best Practices

Help and Support

Additional Resources

Content Search Tool (`cbk.platform.search`)

Content Fetch Tool (`cbk.platform.fetch`)

GraphQL Call Tool (`cbk.graphql.call`)