MCP Integration | Bootspring Docs

Bootspring uses the Model Context Protocol (MCP) to communicate with AI assistants. This open standard enables secure, standardized tool access across different AI platforms.

What is MCP?#

The Model Context Protocol (MCP) is an open protocol developed by Anthropic that enables AI assistants to securely access external tools and data sources.

┌─────────────────────────────────────────────────────────────────────────┐
│                        MCP Architecture                                  │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  ┌─────────────┐         ┌─────────────┐         ┌─────────────┐       │
│  │    AI       │  MCP    │   MCP       │  Tools  │  Bootspring │       │
│  │ Assistant   │◄──────►│   Server    │◄──────►│   Features  │       │
│  │ (Claude)    │Protocol │ (Bootspring)│         │             │       │
│  └─────────────┘         └─────────────┘         └─────────────┘       │
│                                                                         │
│  The AI assistant uses MCP to access Bootspring tools without          │
│  direct integration - the protocol handles all communication.           │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Why MCP?#

Benefit	Description
Standardized	Works with any MCP-compatible AI assistant
Secure	Controlled capability exposure
Extensible	Easy to add new tools
Portable	Works across platforms (Claude, Cursor, etc.)

Bootspring MCP Server#

Bootspring runs as an MCP server, exposing 19 tools for AI assistants:

Core Tools#

Tool	Purpose
`bootspring_assist`	General development assistance
`bootspring_context`	Project context access
`bootspring_agent`	Specialized agent invocation
`bootspring_skill`	Code pattern generation
`bootspring_quality`	Quality gate execution

Generation Tools#

Tool	Purpose
`bootspring_generate`	Context file generation
`bootspring_seed`	Project seeding/scaffolding
`bootspring_prd`	PRD document generation
`bootspring_mvp`	MVP planning
`bootspring_content`	Content generation

Workflow Tools#

Tool	Purpose
`bootspring_orchestrator`	Workflow management
`bootspring_loop`	Autonomous execution
`bootspring_todo`	Task tracking
`bootspring_dashboard`	Dashboard integration

Configuration Tools#

Tool	Purpose
`bootspring_plugin`	Plugin management
`bootspring_capabilities`	Feature discovery
`bootspring_telemetry`	Usage analytics
`bootspring_memory`	Persistent memory
`bootspring_autopilot`	Autopilot mode

Setting Up MCP#

Configuration File#

Create .mcp.json in your project root:

{
  "mcpServers": {
    "bootspring": {
      "command": "npx",
      "args": ["bootspring", "mcp"],
      "env": {
        "BOOTSPRING_API_KEY": "${BOOTSPRING_API_KEY}"
      }
    }
  }
}

Environment Variables#

Set your API key:

# .env.local
BOOTSPRING_API_KEY=bsk_your_api_key_here

Verifying Connection#

Test the MCP connection:

bootspring mcp --test

Expected output:

✓ MCP server running
✓ 19 tools registered
✓ Authentication valid
✓ Ready for connections

How Tools Work#

Tool Invocation Flow#

┌─────────────────────────────────────────────────────────────────────────┐
│                        Tool Invocation Flow                              │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  1. User Request                                                        │
│     "Help me add authentication"                                        │
│           │                                                             │
│           ▼                                                             │
│  2. AI Determines Tool                                                  │
│     → bootspring_agent with auth-expert                                 │
│           │                                                             │
│           ▼                                                             │
│  3. MCP Protocol                                                        │
│     AI ──► MCP Server ──► Bootspring                                    │
│           │                                                             │
│           ▼                                                             │
│  4. Tool Execution                                                      │
│     Bootspring processes request                                        │
│           │                                                             │
│           ▼                                                             │
│  5. Response                                                            │
│     Bootspring ──► MCP Server ──► AI ──► User                          │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Tool Schema#

Each tool has a defined schema:

// Example: bootspring_agent tool schema
{
  name: "bootspring_agent",
  description: "Invoke a specialized expert agent",
  inputSchema: {
    type: "object",
    properties: {
      agent: {
        type: "string",
        description: "Agent name (e.g., 'frontend-expert')"
      },
      task: {
        type: "string",
        description: "Task or question for the agent"
      },
      context: {
        type: "string",
        description: "Additional context"
      },
      outputFormat: {
        type: "string",
        enum: ["guidance", "code", "review", "plan"]
      }
    },
    required: ["agent", "task"]
  }
}

Tool Responses#

Tools return structured responses:

{
  "success": true,
  "data": {
    "agent": "frontend-expert",
    "response": {
      "summary": "Here's how to create...",
      "code": [...],
      "recommendations": [...]
    }
  },
  "meta": {
    "duration": 1234,
    "tokensUsed": 500
  }
}

Compatible Platforms#

Claude Desktop#

Native MCP support:

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "bootspring": {
      "command": "npx",
      "args": ["bootspring", "mcp"]
    }
  }
}

Claude Code (CLI)#

Automatic detection via .mcp.json:

# In your project directory
claude  # Automatically connects to Bootspring MCP

Cursor IDE#

Configure in settings:

// .cursor/mcp.json
{
  "mcpServers": {
    "bootspring": {
      "command": "npx",
      "args": ["bootspring", "mcp"]
    }
  }
}

VS Code (Copilot Chat)#

Coming soon with MCP support in Copilot.

Security Model#

Capability Exposure#

Bootspring only exposes safe operations:

┌─────────────────────────────────────────────────────────────────────────┐
│                        Security Model                                    │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  Exposed (Safe)          │  Not Exposed (Protected)                     │
│  ─────────────────────   │  ────────────────────────                    │
│  • Read project context  │  • Direct file system access                 │
│  • Generate code         │  • Shell command execution                   │
│  • Run quality checks    │  • Network requests                          │
│  • Access documentation  │  • Environment variables                     │
│  • Invoke agents         │  • Sensitive credentials                     │
│                          │                                              │
└─────────────────────────────────────────────────────────────────────────┘

API Key Scoping#

API keys have scoped permissions:

Key Type	Permissions
Development	Full access in local environment
CI/CD	Quality checks only
Read-only	Context and documentation

Request Validation#

All tool requests are validated:

Schema validation: Input matches expected format
Permission check: API key has required access
Rate limiting: Prevents abuse
Audit logging: All requests logged

Advanced Configuration#

Custom Tool Parameters#

Override default tool behavior:

// bootspring.config.js
module.exports = {
  mcp: {
    tools: {
      'bootspring_agent': {
        defaultVerbosity: 'detailed',
        timeout: 30000,
      },
      'bootspring_quality': {
        enabled: true,
        autoRun: ['pre-commit'],
      },
    },
  },
};

Tool Filtering#

Enable/disable specific tools:

module.exports = {
  mcp: {
    // Only expose these tools
    enabledTools: [
      'bootspring_assist',
      'bootspring_agent',
      'bootspring_skill',
      'bootspring_quality',
    ],

    // Or disable specific tools
    // disabledTools: ['bootspring_autopilot'],
  },
};

Custom Server Port#

Run on a specific port:

module.exports = {
  mcp: {
    port: 3100,  // Default: auto-assigned
    host: 'localhost',
  },
};

Debugging#

Enable Debug Logging#

DEBUG=bootspring:mcp npx bootspring mcp

View Tool Calls#

bootspring mcp --verbose

Output:

[MCP] Tool call: bootspring_agent
[MCP] Input: { agent: "frontend-expert", task: "..." }
[MCP] Duration: 1234ms
[MCP] Output: { success: true, data: {...} }

Test Individual Tools#

bootspring mcp --test-tool bootspring_agent

Troubleshooting#

Connection Issues#

Symptom: AI assistant can't connect to Bootspring

Solutions:

Verify .mcp.json exists and is valid JSON
Check BOOTSPRING_API_KEY is set
Run bootspring mcp --test
Restart the AI assistant

Tool Not Found#

Symptom: "Tool bootspring_xyz not found"

Solutions:

Check tool name spelling
Verify tool is enabled in config
Check tier access (some tools require Pro/Team)

Slow Responses#

Symptom: Tools take a long time to respond

Solutions:

Check network connectivity
Reduce context size
Use more specific queries
Check server status at status.bootspring.com

Authentication Errors#

Symptom: "Invalid API key" errors

Solutions:

Verify API key is correct
Check key hasn't expired
Ensure key has required permissions
Regenerate key in dashboard

Protocol Details#

Message Format#

MCP uses JSON-RPC 2.0:

// Request
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "bootspring_agent",
    "arguments": {
      "agent": "frontend-expert",
      "task": "Create a button component"
    }
  }
}

// Response
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Here's a button component..."
      }
    ]
  }
}

Transport#

Bootspring MCP supports:

stdio: Default for local development
HTTP: For remote/CI environments

module.exports = {
  mcp: {
    transport: 'stdio',  // or 'http'
  },
};

MCP Tools Reference - Full tool documentation
Configuration - Setup guide
Troubleshooting - Common issues
MCP Specification - Protocol details