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.

BridgeMCP acts as the bridge between your AI coding agents (Cursor, Claude Code, Windsurf, BridgeCode) and the BridgeMind platform. It exposes project management, task orchestration, and agent configuration as MCP tools — so your agents always know what to build, what's in progress, and what's done.

Key Features

Universal agent support — Works with Cursor, Claude Code, Windsurf, BridgeCode, and any MCP-compatible client.
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	`command`
Command	`npx -y @bridgemind/mcp`

Then set the environment variable BRIDGEMIND_API_KEY to your API key.

Option B: Project config file

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

{
  "mcpServers": {
    "bridgemind": {
      "command": "npx",
      "args": ["-y", "@bridgemind/mcp"],
      "env": {
        "BRIDGEMIND_API_KEY": "your_api_key_here"
      }
    }
  }
}

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

Option C: Remote HTTP (no local process)

In .cursor/mcp.json, use the remote transport instead:

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

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 bridgemind -- npx -y @bridgemind/mcp

# Project scope (shared with team via .mcp.json)
claude mcp add --scope project bridgemind -- npx -y @bridgemind/mcp

# User scope (available in all your projects)
claude mcp add --scope user bridgemind -- npx -y @bridgemind/mcp

Then set your API key as an environment variable:

export BRIDGEMIND_API_KEY="your_api_key_here"

Option B: Remote HTTP transport

claude mcp add --transport http bridgemind https://mcp.bridgecode.dev/mcp \
  --header "Authorization: Bearer your_api_key_here"

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

Option C: Project config file

Create .mcp.json in your project root:

{
  "mcpServers": {
    "bridgemind": {
      "command": "npx",
      "args": ["-y", "@bridgemind/mcp"],
      "env": {
        "BRIDGEMIND_API_KEY": "your_api_key_here"
      }
    }
  }
}

One-Click Install

Download the BridgeMind extension bundle and double-click to install. Claude Desktop will prompt you for your API key and store it securely in your OS keychain.

Download bridgemind-mcp.mcpb

Manual Setup

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": {
      "command": "npx",
      "args": ["-y", "@bridgemind/mcp"],
      "env": {
        "BRIDGEMIND_API_KEY": "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": {
      "command": "npx",
      "args": ["-y", "@bridgemind/mcp"],
      "env": {
        "BRIDGEMIND_API_KEY": "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 bridgemind -- npx -y @bridgemind/mcp

Set your API key:

export BRIDGEMIND_API_KEY="your_api_key_here"

Option B: Edit config.toml directly

Add to ~/.codex/config.toml:

[mcp_servers.bridgemind]
command = "npx"
args = ["-y", "@bridgemind/mcp"]

[mcp_servers.bridgemind.env]
BRIDGEMIND_API_KEY = "your_api_key_here"

BridgeMind MCP is built in to BridgeCode. Authenticate and it's ready:

bridgecode auth login

This opens your browser for OAuth. Once authenticated, all BridgeMCP tools are available automatically — no configuration needed.

Core Concepts

The Vibe Coding Workflow

BridgeMind is designed for vibe coding — expressing intent in natural language and delegating execution to AI agents. BridgeMCP provides the tools your agents need to participate in this workflow:

You create tasks with clear instructions and knowledge context
Your agent reads the task via get_task and understands the requirements
Your agent builds using its own tools (file editing, shell commands, etc.)
Your agent updates the task to in-review when 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

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.

See the Authentication guide for details on generating and managing API keys.

Transport Protocols

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.