MCP Integration Guide

Embercore is an MCP (Model Context Protocol) server. This means you can use it as a tool from any MCP-compatible client — Claude Desktop, VS Code with GitHub Copilot, Cursor, and others.

What is MCP?

The Model Context Protocol is an open standard that lets AI assistants call external tools. Instead of using Embercore only through its CLI, you can ask Claude (or another AI) to run Embercore’s marketing pipeline directly in your conversation.

How Embercore Implements MCP

The engine binary (embercore-engine / main.go) starts an MCP server that registers 8 tools. It supports two transports:

Transport	Flag	Use Case
stdio	(default)	Local clients: Claude Desktop, Cursor, VS Code
Streamable HTTP	`-http -addr :8080`	Remote / cloud: Claude.ai, shared servers

In stdio mode, the client launches the embercore-engine process and communicates over stdin/stdout.

In HTTP mode, the server listens on the specified address and exposes the MCP endpoint at <addr>/mcp.

Available Tools

`run_workflow`

Run the full multi-agent product launch pipeline end-to-end.

Parameter	Type	Required	Description
`brief_path`	string	No	Path to brief file (default: `./product_brief.md`)
`resume`	boolean	No	Force resume from last stage (default: true if session exists)

Orchestrates: PM Plan → Research → Brand → UX → GTM → Assemble. Auto-resumes from the last completed stage if called again after a crash. All outputs written to ./output/.

`pm_plan`

PM Agent reads the product brief and writes a focused brief for the Research agent.

Parameter	Type	Required	Description
`brief_path`	string	No	Path to brief file (default: `./product_brief.md`)

Run this first if using individual tools instead of run_workflow.

`run_research`

Market research, ICP classification, competitor analysis. Uses web search.

Parameter	Type	Required	Description
`extra_notes`	string	No	Notes from a prior iterate decision to incorporate

Reads pm_brief_for_agent1.md from ./output/. Writes 01_research.md.

`run_brand`

Positioning statement, brand voice, messaging pillars.

Parameter	Type	Required	Description
`extra_notes`	string	No	Iteration notes

Reads 01_research.md. Writes 02_brand_messaging.md.

`run_ux`

Wireframe briefs, screen list, user flows, image-prototype prompts.

Parameter	Type	Required	Description
`extra_notes`	string	No	Iteration notes

Writes 03_ux.md.

`run_gtm`

Social media (4a) and B2B outreach (4b) run in parallel via goroutines.

Parameter	Type	Required	Description
`extra_notes`	string	No	Iteration notes

Writes 04_go_to_market.md.

`request_approval`

Present a stage summary to the human and wait for their approve/iterate decision.

Parameter	Type	Required	Description
`checkpoint`	string	Yes	Stage identifier: `H1`, `H2`, `H3`, or `H4`
`summary`	string	Yes	PM Agent summary — 5 to 10 bullets
`questions`	string[]	Yes	2–3 specific questions for the human

Blocks until input is received. In HTTP mode (non-TTY stdin), auto-approves.

`assemble_plan`

PM Agent assembles all stage outputs into final_product_plan.md.

Parameter	Type	Required	Description
`product_name`	string	No	Optional product name for the title

Call after the last checkpoint (H4) is approved.

Client Configuration

Claude Desktop

Edit your Claude Desktop config file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "embercore": {
      "command": "embercore-engine",
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

If the binary isn’t on your PATH, use the full path:

{
  "mcpServers": {
    "embercore": {
      "command": "/Users/you/projects/embercore/packages/engine/embercore-engine",
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

Restart Claude Desktop after editing.

VS Code (GitHub Copilot)

Add to .vscode/mcp.json in your workspace:

{
  "servers": {
    "embercore": {
      "command": "embercore-engine",
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

Or add to your User Settings (settings.json):

{
  "mcp": {
    "servers": {
      "embercore": {
        "command": "embercore-engine",
        "env": {
          "ANTHROPIC_API_KEY": "sk-ant-..."
        }
      }
    }
  }
}

Cursor

Add to your Cursor MCP configuration (.cursor/mcp.json):

{
  "mcpServers": {
    "embercore": {
      "command": "embercore-engine",
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

HTTP Mode (Claude.ai / Remote)

For remote or cloud deployments, run in HTTP mode:

ANTHROPIC_API_KEY=sk-ant-... embercore-engine -http -addr :8080

The MCP endpoint is http://your-server:8080/mcp.

Configure your client to connect to this URL. The server handles graceful shutdown on SIGINT/SIGTERM.

Note: In HTTP mode, request_approval auto-approves checkpoints since there is no interactive stdin. This is the correct behaviour for unattended remote execution.

Example: Using Embercore Through Claude

Once configured, you can interact naturally:

You: “I’m launching a B2B analytics SaaS. Create a product brief file and run the full Embercore pipeline.”

Claude will:

Write a product_brief.md file
Call run_workflow to start the pipeline
At each checkpoint (request_approval), present you with a summary and questions
You approve or request changes
After all stages, call assemble_plan to produce the final deliverable

Individual tool usage

You can also use tools individually for more control:

You: “Run just the research stage for my product brief.”

Claude calls pm_plan first, then run_research, and presents the output.

You: “The research missed competitor X. Re-run with that note.”

Claude calls run_research with extra_notes: "Include competitor X — they offer...".

Pipeline Stage Flow

┌────────────┐    ┌──────────────┐    ┌────────────┐    ┌──────────┐    ┌──────────┐
│  pm_plan   │───▶│ run_research │───▶│ run_brand  │───▶│ run_ux   │───▶│ run_gtm  │
│            │    │              │    │            │    │          │    │          │
│ Reads:     │    │ Reads:       │    │ Reads:     │    │ Reads:   │    │ Reads:   │
│ brief      │    │ pm_brief     │    │ research   │    │ all prev │    │ all prev │
│            │    │              │    │            │    │          │    │          │
│ Writes:    │    │ Writes:      │    │ Writes:    │    │ Writes:  │    │ Writes:  │
│ pm_brief   │    │ 01_research  │    │ 02_brand   │    │ 03_ux    │    │ 04_gtm   │
└────────────┘    └──────────────┘    └────────────┘    └──────────┘    └──────────┘
                                                                              │
                       ┌──────────────┐                                       │
                       │assemble_plan │◄──────────────────────────────────────┘
                       │              │
                       │ Writes:      │
                       │ final_plan   │
                       └──────────────┘

Between each stage, request_approval is called to pause for human review.

Troubleshooting

“ANTHROPIC_API_KEY is not set”

The engine requires an API key at startup. Set it in your environment or the MCP config’s env block.

Tool not appearing in Claude Desktop

Verify the binary path is correct and executable
Check Claude Desktop logs for MCP connection errors
Restart Claude Desktop after config changes
Test the binary directly: echo '{}' | embercore-engine — it should not crash immediately

HTTP mode: connection refused

Ensure the port is not blocked by a firewall and the address is correct:

# Listen on all interfaces
embercore-engine -http -addr 0.0.0.0:8080

# Test connectivity
curl http://localhost:8080/mcp

Checkpoint timeout

In stdio mode, request_approval blocks waiting for input. If you’re using a client that doesn’t support interactive input, consider HTTP mode (which auto-approves) or use run_workflow with the resume parameter.

MCP Integration

Using Embercore as an MCP server with Claude Desktop, Cursor, and other clients.