MCPC

Build agentic MCP servers by composing existing MCP tools.

MCPC is the SDK for building agentic MCP (Model Context Protocol) Servers. You can use it to:

1. Create Powerful Agentic MCP Tools: Simply describe your vision in text and reference tools from the expanding MCP community. As standard MCP tools, your agents work everywhere and collaborate seamlessly.
2. Fine-Tune Existing Tools: Flexibly modify existing tool descriptions and parameters, or wrap and filter results to precisely adapt them to your specific business scenarios.
3. Build Multi-Agent Systems: By defining each agent as a MCP tool, you can compose and orchestrate them to construct sophisticated, collaborative multi-agent systems.

Key Features

• Portability and agent interoperability: Build once, run everywhere as MCP tools - agents work across all MCP clients and can discover and collaborate with each other through standard MCP interfaces
• Simple composition and fine-tuning: Compose MCP servers as building blocks, select and customize tools, or modify their descriptions and parameters
• Logging and tracing: Built-in MCP logging and OpenTelemetry tracing support
• Flexible execution modes: Multiple specialized modes to fit different scenarios - interactive agent (agentic), structured workflow (agentic_workflow), autonomous sampling (agentic_sampling), workflow sampling (agentic_workflow_sampling), and secure code execution (code_execution) - each with dedicated implementations

Quick Start

Three Ways to Get Started

1. Use the Website (Fastest)

Visit mcpc.tech to browse servers from the official MCP registry, discover tools, and generate ready-to-use agents.

2. Use the Agent (Interactive)

Let AI help you discover servers and build agents:

Add to your MCP client:

{
  "mcpServers": {
    "mcpc-builder-agent": {
      "command": "npx",
      "args": ["-y", "@mcpc-tech/builder", "mcpc-builder-agent"]
    }
  }
}

3. Write Code (Full Control)

Use the SDK directly for complete customization. See examples below.

---

Installation

# npm (from npm registry)
npm install @mcpc-tech/core
# npm (from jsr)
npx jsr add @mcpc/core

# deno
deno add jsr:@mcpc/core

# pnpm (from npm registry)
pnpm add @mcpc-tech/core
# pnpm (from jsr)
pnpm add jsr:@mcpc/core

Or run directly with the CLI (no installation required):

# Run with remote configuration
npx -y @mcpc-tech/cli --config-url \
  "https://raw.githubusercontent.com/mcpc-tech/mcpc/main/packages/cli/examples/configs/codex-fork.json"

Examples: Create a Simple Codex/Claude Code Fork

Build your own Codex or Claude Code fork in minutes:

import { type ComposeDefinition, mcpc } from "@mcpc/core";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

// 1. Define MCP server dependencies
const deps: ComposeDefinition["deps"] = {
  mcpServers: {
    "desktop-commander": {
      command: "npx",
      args: ["-y", "@wonderwhy-er/desktop-commander@latest"],
      transportType: "stdio",
    },
    lsmcp: {
      command: "npx",
      args: ["-y", "@mizchi/lsmcp", "-p", "tsgo"],
      transportType: "stdio",
    },
    github: {
      transportType: "streamable-http",
      url: "https://api.githubcopilot.com/mcp/",
      headers: {
        Authorization: `Bearer ${process.env.GITHUB_PERSONAL_ACCESS_TOKEN}`,
      },
    },
  },
};

// 2. Write agent description with tool references
const description = `
You are a coding assistant with advanced capabilities.

Your capabilities include:
- Reading and writing files
- Searching the codebase using language server features  
- Executing terminal commands to build, test, and run projects
- Interacting with GitHub to create pull requests and manage issues

To perform these actions, you must use the following tools:
- To execute a shell command: <tool name="desktop-commander.execute_command" />
- To read a file's content: <tool name="desktop-commander.read_file" />
- To write content to a file: <tool name="desktop-commander.write_file" />
- To find symbol definitions: <tool name="lsmcp.definition" />
- To create a GitHub pull request: <tool name="github.create_pull_request" />
`;

// 3. Create and start the server
const server = await mcpc(
  [
    {
      name: "coding-agent",
      version: "0.1.0",
    },
    { capabilities: { tools: {}, sampling: {} } },
  ],
  [
    {
      name: "coding-agent",
      options: {
        mode: "agentic",
      },
      description,
      deps,
    },
  ],
);

const transport = new StdioServerTransport();
await server.connect(transport);

💡 Complete Example: See the full Codex fork tutorial for a step-by-step walkthrough.

How It Works

Three simple steps:

1. Define dependencies - List the MCP servers you want to use
2. Write agent description - Describe what your agent does and reference tools
3. Create server - Use mcpc() to build and connect your server

Execution Modes

MCPC provides multiple flexible execution modes to fit different scenarios:

Mode	Description	Use Case
agentic	Interactive step-by-step execution	Standard agent interactions
agentic_workflow	Structured workflow with predefined/dynamic steps	Multi-step processes
agentic_sampling	Autonomous execution with internal LLM loop	Fully autonomous agents
agentic_workflow_sampling	Autonomous workflow execution	Complex autonomous workflows
code_execution	Secure JavaScript sandbox with tool access	Code generation and execution

Quick Example

// Interactive agent (default)
{ options: { mode: "agentic" } }

// Autonomous agent
{ options: { mode: "agentic_sampling", samplingConfig: { maxIterations: 10 } } }

// Code execution with sandbox
import { createCodeExecutionPlugin } from "@mcpc/plugin-code-execution/plugin";
{
  plugins: [createCodeExecutionPlugin()],
  options: { mode: "code_execution" }
}

📖 Detailed Documentation: See Execution Modes Guide for comprehensive information on each mode, configuration options, and best practices.

Documentation

• Getting Started - Installation and first steps
• Creating Your First Agent - Complete tutorial
• Execution Modes - Comprehensive guide to all execution modes
• CLI Usage Guide - Using the MCPC CLI
• Logging and Tracing - MCP logging and OpenTelemetry tracing
• Examples - Real-world use cases
• FAQ - Common questions and answer

Examples

See working examples in the examples directory or check out the Codex fork tutorial.

Contributing

We welcome contributions! See CONTRIBUTING.md for details.

License

MIT License - see LICENSE for details.