BridgeMCP

Give your agents superpowers. A Model Context Protocol server that connects any AI coding agent to the BridgeMind ecosystem through a standardized, open protocol.

What is MCP? MCP (Model Context Protocol) is an open standard that lets AI agents call external tools and services. Think of it like a USB port for AI — any agent that speaks MCP can plug in and use the tools on the other end.

BridgeMCP is the BridgeMind-specific MCP server. It acts as the bridge between your AI coding agents (Cursor, Claude Code, Windsurf, and BridgeCode once it ships) and the BridgeMind platform, giving them access to your projects, tasks, and agent configurations — so your agents always know what to build, what's in progress, and what's done.

BridgeCode is still pre-launch. Use the Cursor, Claude Code, Claude Desktop, Windsurf, or Codex CLI setup below today; the BridgeCode tab shows the planned built-in experience once it ships.

Key Features

Universal agent support — Works with Cursor, Claude Code, Windsurf, Codex CLI, and any MCP-compatible client today, with BridgeCode planned for launch.
Project management — Create, list, and organize projects through MCP tools.
Task orchestration — AI-managed task workflows with a structured lifecycle (todo → in-progress → in-review → complete).
Agent configuration — Create and manage AI agents with custom system prompts scoped to projects.
Secure by default — API key authentication with scoped access to your projects and tasks.
Dual transport — Streamable HTTP (preferred) and SSE (legacy fallback).

Installation

Pick your agent client below.

One-Click Install

Click the button below to add BridgeMind MCP to Cursor instantly. You'll be prompted to confirm, then add your API key in Cursor settings.

After installing, open Settings → Tools & MCP → bridgemind and replace YOUR_API_KEY with your actual key (e.g. bm_live_xxx...).

Option A: Settings UI

Open Settings → Tools & MCP → Add new MCP server and fill in:

Field	Value
Name	`bridgemind`
Type	`streamableHttp`
URL	`https://mcp.bridgemind.ai/mcp`

Then add a header: Authorization: Bearer your_api_key_here

Option B: Project config file

Create .cursor/mcp.json in your project root:

{
  "mcpServers": {
    "bridgemind": {
      "type": "streamableHttp",
      "url": "https://mcp.bridgemind.ai/mcp",
      "headers": {
        "Authorization": "Bearer your_api_key_here"
      }
    }
  }
}

This file can be committed to your repo so the entire team gets BridgeMCP automatically.

Option A: CLI command (recommended)

Add via the claude mcp add command. Choose your preferred scope:

# Local scope (default — only you, this machine)
claude mcp add --transport http \
  --header "Authorization: Bearer your_api_key_here" \
  bridgemind https://mcp.bridgemind.ai/mcp

# Project scope (shared with team via .mcp.json)
claude mcp add --transport http --scope project \
  --header "Authorization: Bearer your_api_key_here" \
  bridgemind https://mcp.bridgemind.ai/mcp

# User scope (available in all your projects)
claude mcp add --transport http --scope user \
  --header "Authorization: Bearer your_api_key_here" \
  bridgemind https://mcp.bridgemind.ai/mcp

After adding, run /mcp inside Claude Code to verify the server is connected.

Option B: Project config file

Create .mcp.json in your project root:

{
  "mcpServers": {
    "bridgemind": {
      "type": "http",
      "url": "https://mcp.bridgemind.ai/mcp",
      "headers": {
        "Authorization": "Bearer your_api_key_here"
      }
    }
  }
}

Locate your config file:

Platform	Path
macOS	`~/Library/Application Support/Claude/claude_desktop_config.json`
Windows	`%APPDATA%\Claude\claude_desktop_config.json`
Linux	`~/.config/Claude/claude_desktop_config.json`

Or open it directly: Claude Desktop → Settings → Developer → Edit Config.

Add BridgeMind to the mcpServers object:

{
  "mcpServers": {
    "bridgemind": {
      "url": "https://mcp.bridgemind.ai/mcp",
      "headers": {
        "Authorization": "Bearer your_api_key_here"
      }
    }
  }
}

Restart Claude Desktop completely (closing the window isn't enough — quit and relaunch). Look for the hammer icon to confirm tools are loaded.

Option A: Command Palette

Open the Command Palette (Cmd+Shift+P on Mac / Ctrl+Shift+P on Windows)
Type and select "Windsurf: Configure MCP Servers"
This opens mcp_config.json — add the configuration below

Option B: Edit config file directly

Locate mcp_config.json:

Platform	Path
macOS	`~/.codeium/windsurf/mcp_config.json`
Windows	`%USERPROFILE%\.codeium\windsurf\mcp_config.json`
Linux	`~/.codeium/windsurf/mcp_config.json`

Add BridgeMind:

{
  "mcpServers": {
    "bridgemind": {
      "serverUrl": "https://mcp.bridgemind.ai/mcp",
      "headers": {
        "Authorization": "Bearer your_api_key_here"
      }
    }
  }
}

In Windsurf chat, click the MCP servers button (hammer icon) → Manage plugins → Refresh to connect.

Option A: CLI command (recommended)

codex mcp add --transport http \
  --header "Authorization: Bearer your_api_key_here" \
  bridgemind https://mcp.bridgemind.ai/mcp

Option B: Edit config.toml directly

Add to ~/.codex/config.toml:

[mcp_servers.bridgemind]
type = "http"
url = "https://mcp.bridgemind.ai/mcp"

[mcp_servers.bridgemind.headers]
Authorization = "Bearer your_api_key_here"

BridgeCode is still pre-launch.

When BridgeCode ships, BridgeMind MCP will be built in. Builders will be able to authenticate directly inside BridgeCode and get BridgeMCP access without separate configuration.

Public setup steps will be added here once BridgeCode is available.

Core Concepts

The Vibe Coding Workflow

Vibe coding means describing what you want in plain language and letting AI agents handle the execution. You act as the Technical Director — defining what needs to be built — while your agents write the code. Here's how that works with BridgeMCP:

You create a task — describe what you want built and add any relevant context
Your agent reads the task and understands the requirements
Your agent builds — writing code, running commands, creating files
Your agent updates the task to in-review when the work is done
You review and approve, marking the task complete

Task Lifecycle

Status	Description
`todo`	Task created with instructions. Waiting to be picked up.
`in-progress`	Agent has started working on the task.
`in-review`	Agent finished work and is requesting your review.
`complete`	You approved the work. Task is done.
`cancelled`	Task was cancelled and won't be executed.

Task Knowledge

Each task can carry a taskKnowledge field — up to 50,000 characters of context that the agent receives when it reads the task. Use this for:

Architecture decisions and constraints
Related file paths and code references
API specifications or data schemas
Links to documentation or design files
Any context that helps the agent ship the right thing

Available Tools

The following is a complete reference for every tool BridgeMCP exposes. You don't need to memorize these — your agent calls them automatically. This section is here for builders who want to understand what's happening under the hood.

Project Tools

`list_projects`

List all projects for the authenticated builder. Use this first to discover project IDs.

Parameters: None

Returns: Array of projects with id, name, and description.

`create_project`

Create a new project container.

Parameter	Type	Required	Description
`name`	string	Yes	Project name (1–255 characters)
`description`	string	No	Project description (max 2,000 characters)

Task Tools

`list_tasks`

List all tasks in a project.

Parameter	Type	Required	Description
`projectId`	UUID	Yes	The project to list tasks from

Returns: Array of tasks with id, status, instructions summary, and knowledge.

`get_task`

Get full details for a single task, including complete instructions, knowledge, and metadata.

Parameter	Type	Required	Description
`taskId`	UUID	Yes	The task to retrieve

`create_task`

Create a new task in a project.

Parameter	Type	Required	Description
`projectId`	UUID	Yes	The project to create the task in
`instructions`	string	Yes	What the agent should do (1–5,000 characters)
`taskKnowledge`	string	No	Context and reference material (max 50,000 characters)
`status`	string	No	Initial status. Default: `todo`

`update_task`

Update a task's status, instructions, or knowledge.

Parameter	Type	Required	Description
`taskId`	UUID	Yes	The task to update
`instructions`	string	No	Updated instructions
`taskKnowledge`	string	No	Updated knowledge context
`status`	string	No	New status (`todo`, `in-progress`, `in-review`, `complete`, `cancelled`)

At least one of instructions, taskKnowledge, or status must be provided.

Agent Tools

`list_agents`

List all agents configured for a project.

Parameter	Type	Required	Description
`projectId`	UUID	Yes	The project to list agents for

Returns: Array of agents with id, name, and systemPrompt.

`get_agent`

Get full details for a single agent.

Parameter	Type	Required	Description
`agentId`	UUID	Yes	The agent to retrieve

`create_agent`

Create a new agent with a custom system prompt, scoped to a project.

Parameter	Type	Required	Description
`projectId`	UUID	Yes	The project this agent belongs to
`name`	string	Yes	Agent name (1–255 characters)
`systemPrompt`	string	Yes	System prompt defining the agent's behavior (1–100,000 characters)

`update_agent`

Update an agent's name or system prompt.

Parameter	Type	Required	Description
`agentId`	UUID	Yes	The agent to update
`name`	string	No	Updated name
`systemPrompt`	string	No	Updated system prompt

At least one of name or systemPrompt must be provided.

`delete_agent`

Delete an agent.

Parameter	Type	Required	Description
`agentId`	UUID	Yes	The agent to delete

Authentication

BridgeMCP authenticates requests using API keys:

Header: Authorization: Bearer your_api_key_here
Query parameter (fallback): ?apiKey=your_api_key_here

Generate API keys from the BridgeMind dashboard at bridgemind.ai. Each key is scoped to your account — agents using your key can only access your projects, tasks, and agent configurations.

Generate API keys from the BridgeMind dashboard at bridgemind.ai.

Transport Protocols

Most builders don't need to think about this — the installation configs above handle transport automatically. This section is here for advanced setups.

Streamable HTTP (Recommended)

The preferred transport for modern MCP clients. Each request is independent and stateless.

Endpoint: POST /mcp
Used by Cursor, Claude Code, and other modern clients

Server-Sent Events (Legacy)

For older MCP clients that don't support Streamable HTTP.

SSE endpoint: GET /sse
Message endpoint: POST /messages
Session-based with 30-minute timeout

Project and task management workflows
Task lifecycle best practices
Error handling patterns
BridgeMind brand voice guidelines

Clients that support MCP prompts can use this to bootstrap agent context.