Skip to content
Back to search

mcpc

Build agentic-MCP servers by composing existing MCP tools.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mcpc-tech--mcpc/badge.svg)](/listings/mcpc-tech--mcpc)

HTML

<a href="/listings/mcpc-tech--mcpc"><img src="/api/listings/mcpc-tech--mcpc/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Three Ways to Get Started

1. Use the Website (Fastest)

Visit **[mcpc.tech](https://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

import { mcpc } from "@mcpc/core";

const server = await mcpc(
  [{ name: "coding-agent", version: "0.1.0" }, { capabilities: { tools: {} } }],
  [{
    name: "coding-agent",
    description: `
      You are a coding assistant with advanced capabilities.

      Your capabilities include:
      - Reading and writing files
      - Executing terminal commands to build, test, and run projects
      - Interacting with GitHub to create pull requests and manage issues

      Available tools:
      <tool name="desktop-commander.execute_command" />
      <tool name="desktop-commander.read_file" />
      <tool name="desktop-commander.write_file" />
      <tool name="github.create_pull_request" />
    `,
    deps: {
      mcpServers: {
        "desktop-commander": {
          command: "npx",
          args: ["-y", "@wonderwhy-er/desktop-commander@latest"],
          transportType: "stdio",
        },
        github: {
          transportType: "streamable-http",
          url: "https://api.githubcopilot.com/mcp/",
        },
      },
    },
  }],
);

> **Complete Example**: See the full > [Codex fork tutorial](docs/examples/creating-a-codex-fork.md).

Install the MCPC Core Skill

Install the `mcpc-core` skill into your project using [skills.sh](https://skills.sh):

npx skills add mcpc-tech/mcpc

This installs the skill into `.agents/skills/mcpc-core/`, giving your agent on-demand access to the full `@mcpc/core` API reference, usage patterns, plugin guide, and gotchas.

---

Examples: Load Agent Skills

For complex agents where inline `description` becomes unwieldy, use [Agent Skills](https://agentskills.io) to organize domain knowledge in separate files that are loaded on-demand.

import { createBashPlugin, createSkillsPlugin } from "@mcpc/core/plugins";

const server = await mcpc(
  [{ name: "my-agent", version: "1.0.0" }, { capabilities: { tools: {} } }],
  [{
    name: "my-agent",
    description: 'An agent with domain knowledge\n\n<tool name="bash"/>',
    plugins: [
      createSkillsPlugin({ paths: ["./skills"] }),
      createBashPlugin(),
    ],
  }],
);

Skills load domain knowledge on-demand, while bash plugin enables script execution. For scripts in `scripts/` directory, skills returns the path - use bash tool to execute.

> **Complete Examples**: See > [14-skills-plugin.ts](packages/core/examples/14-skills-plugin.ts) and > [25-skills-with-bash.ts](packages/core/examples/25-skills-with-bash.ts).

Examples: Progressive Manual Disclosure

For agents with detailed instructions, use the `manual` field to reduce initial prompt length - the full manual is fetched on-demand via `man { manual: true }`:

const server = await mcpc(
  [{ name: "code-reviewer", version: "1.0.0" }, {
    capabilities: { tools: {} },
  }],
  [{

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 296 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # MCPC
  2. [![JSR](https://jsr.io/badges/@mcpc/core)](https://jsr.io/@mcpc/core)
  3. [![npm](https://img.shields.io/npm/v/@mcpc-tech/core)](https://www.npmjs.com/package/@mcpc-tech/core)
  4. **Build agentic MCP servers by composing existing MCP tools.**
  5. MCPC is the SDK for building agentic MCP (Model Context Protocol) Servers. You
  6. can use it to:
  7. 1. **Create Powerful Agentic MCP Tools:** Simply describe your vision in text
  8. and reference tools from the
  9. [expanding MCP community](https://registry.modelcontextprotocol.io/docs#/operations/list-servers).
  10. As standard MCP tools, your agents work everywhere and collaborate
  11. seamlessly.
  12. 2. **Fine-Tune Existing Tools:** Flexibly modify existing tool descriptions and
  13. parameters, or wrap and filter results to precisely adapt them to your
  14. specific business scenarios.
  15. 3. **Build Multi-Agent Systems:** By defining each agent as a MCP tool, you can
  16. compose and orchestrate them to construct sophisticated, collaborative
  17. multi-agent systems.
  18. ## Key Features
  19. - **Portability and agent interoperability**: Build once, run everywhere as MCP
  20. tools - agents work across all MCP clients and can discover and collaborate
  21. with each other through standard MCP interfaces
  22. - **Simple composition and fine-tuning**: Compose MCP servers as building
  23. blocks, select and customize tools, or modify their descriptions and
  24. parameters
  25. - **Logging and tracing**: Built-in MCP logging and OpenTelemetry tracing
  26. support
  27. - **Skills support**: Define domain-specific knowledge following the
  28. [Agent Skills specification](https://agentskills.io) - deploy to production,
  29. share via MCP, and declare tool dependencies
  30. - **Flexible execution modes**: Multiple specialized modes to fit different
  31. scenarios - interactive agent (`agentic`), AI SDK sampling (`ai_sampling`), AI
  32. ACP mode (`ai_acp`), secure code execution
  33. ([`code_execution`](packages/plugin-code-execution/)), and sandbox + sampling
  34. ([`code_execution_sampling`](packages/plugin-code-execution-sampling/)) - each
  35. with dedicated implementations
  36. ## Quick Start
  37. ### Three Ways to Get Started
  38. #### 1. Use the Website (Fastest)
  39. Visit **[mcpc.tech](https://mcpc.tech)** to browse servers from the official MCP
  40. registry, discover tools, and generate ready-to-use agents.
  41. #### 2. Use the Agent (Interactive)
  42. Let AI help you discover servers and build agents:
  43. **Add to your MCP client:**
  44. ```json
  45. {
  46. "mcpServers": {
  47. "mcpc-builder-agent": {
  48. "command": "npx",
  49. "args": ["-y", "@mcpc-tech/builder", "mcpc-builder-agent"]
  50. }
  51. }
  52. }
  53. ```
  54. #### 3. Write Code (Full Control)
  55. Use the SDK directly for complete customization. See examples below.
  56. ---
  57. ### Installation
  58. ```bash
  59. # npm (from npm registry)
  60. npm install @mcpc-tech/core
  61. # npm (from jsr)
  62. npx jsr add @mcpc/core
  63. # deno
  64. deno add jsr:@mcpc/core
  65. # pnpm (from npm registry)
  66. pnpm add @mcpc-tech/core
  67. # pnpm (from jsr)
  68. pnpm add jsr:@mcpc/core
  69. ```
  70. Or run directly with the CLI (no installation required):
  71. ```bash
  72. # Run with remote configuration
  73. npx -y @mcpc-tech/cli --config-url \
  74. "https://raw.githubusercontent.com/mcpc-tech/mcpc/main/packages/cli/examples/configs/codex-fork.json"
  75. ```
  76. ### Examples: Create a Simple Codex/Claude Code Fork
  77. ```typescript
  78. import { mcpc } from "@mcpc/core";
  79. const server = await mcpc(
  80. [{ name: "coding-agent", version: "0.1.0" }, { capabilities: { tools: {} } }],
  81. [{
  82. name: "coding-agent",
  83. description: `
  84. You are a coding assistant with advanced capabilities.
  85. Your capabilities include:
  86. - Reading and writing files
  87. - Executing terminal commands to build, test, and run projects
  88. - Interacting with GitHub to create pull requests and manage issues
  89. Available tools:
  90. <tool name="desktop-commander.execute_command" />
  91. <tool name="desktop-commander.read_file" />
  92. <tool name="desktop-commander.write_file" />
  93. <tool name="github.create_pull_request" />
  94. `,
  95. deps: {
  96. mcpServers: {
  97. "desktop-commander": {
  98. command: "npx",
  99. args: ["-y", "@wonderwhy-er/desktop-commander@latest"],
  100. transportType: "stdio",
  101. },
  102. github: {
  103. transportType: "streamable-http",
  104. url: "https://api.githubcopilot.com/mcp/",
  105. },
  106. },
  107. },
  108. }],
  109. );
  110. ```
  111. > **Complete Example**: See the full
  112. > [Codex fork tutorial](docs/examples/creating-a-codex-fork.md).
  113. ### Install the MCPC Core Skill
  114. Install the `mcpc-core` skill into your project using
  115. [skills.sh](https://skills.sh):
  116. ```bash
  117. npx skills add mcpc-tech/mcpc
  118. ```
  119. This installs the skill into `.agents/skills/mcpc-core/`, giving your agent
  120. on-demand access to the full `@mcpc/core` API reference, usage patterns, plugin
  121. guide, and gotchas.
  122. ---
  123. ### Examples: Load Agent Skills
  124. For complex agents where inline `description` becomes unwieldy, use
  125. [Agent Skills](https://agentskills.io) to organize domain knowledge in separate
  126. files that are loaded on-demand.
  127. ```typescript
  128. import { createBashPlugin, createSkillsPlugin } from "@mcpc/core/plugins";
  129. const server = await mcpc(
  130. [{ name: "my-agent", version: "1.0.0" }, { capabilities: { tools: {} } }],
  131. [{
  132. name: "my-agent",
  133. description: 'An agent with domain knowledge\n\n<tool name="bash"/>',
  134. plugins: [
  135. createSkillsPlugin({ paths: ["./skills"] }),
  136. createBashPlugin(),
  137. ],
  138. }],
  139. );
  140. ```
  141. Skills load domain knowledge on-demand, while bash plugin enables script
  142. execution. For scripts in `scripts/` directory, skills returns the path - use
  143. bash tool to execute.
  144. > **Complete Examples**: See
  145. > [14-skills-plugin.ts](packages/core/examples/14-skills-plugin.ts) and
  146. > [25-skills-with-bash.ts](packages/core/examples/25-skills-with-bash.ts).
  147. ### Examples: Progressive Manual Disclosure
  148. For agents with detailed instructions, use the `manual` field to reduce initial
  149. prompt length - the full manual is fetched on-demand via `man { manual: true }`:
  150. ```typescript
  151. const server = await mcpc(
  152. [{ name: "code-reviewer", version: "1.0.0" }, {
  153. capabilities: { tools: {} },
  154. }],
  155. [{
  156. name: "code-reviewer",
  157. description: "AI code reviewer for quality and security analysis.",
  158. manual: `Detailed review guidelines...
  159. <tool name="desktop-commander.read_file"/>
  160. <tool name="desktop-commander.write_file"/>
  161. ## Review Categories
  162. 1. Code Quality - readability, naming, complexity
  163. 2. Security - SQL injection, XSS, credentials
  164. ...`,
  165. deps: {
  166. mcpServers: {
  167. "desktop-commander": {
  168. command: "npx",
  169. args: ["-y", "@wonderwhy-er/desktop-commander@0.1.20"],
  170. transportType: "stdio",
  171. },
  172. },
  173. },
  174. }],
  175. );
  176. ```
  177. > **Complete Example**: See
  178. > [21-progressive-manual.ts](packages/core/examples/21-progressive-manual.ts).
  179. ## How It Works
  180. Three simple steps:
  181. 1. **Define dependencies** - List the MCP servers you want to use
  182. 2. **Write agent description** - Describe what your agent does and reference
  183. tools
  184. 3. **Create server** - Use `mcpc()` to build and connect your server
  185. ## Execution Modes
  186. MCPC provides multiple flexible execution modes to fit different scenarios:
  187. | Mode | Description | Use Case | Requires Plugin |
  188. | ------------------------- | --------------------------------------------- | ---------------------------------------------------- | --------------- |
  189. | `agentic` | Interactive step-by-step execution | Standard agent interactions | Built-in |
  190. | `ai_sampling` | AI SDK sampling mode | Autonomous AI SDK execution | Built-in |
  191. | `ai_acp` | AI SDK ACP mode | Coding agents (Claude Code, etc.) | Built-in |
  192. | `code_execution` | Secure JavaScript sandbox with tool access | Code generation and execution | External |
  193. | `code_execution_sampling` | Secure sandbox plus MCP sampling-backed calls | Sandbox execution that can also ask the client model | External |
  194. > **Note:** `agentic`, `ai_sampling`, and `ai_acp` are built-in modes — just set
  195. > `options.mode` and they work. `code_execution` and `code_execution_sampling`
  196. > require installing and loading their respective plugin packages.
  197. ### Quick Example
  198. ```typescript
  199. // Interactive agent (default)
  200. { options: { mode: "agentic" } }
  201. // Autonomous agent
  202. { options: { mode: "ai_sampling", samplingConfig: { maxIterations: 10 } } }
  203. // Code execution with sandbox
  204. import { createCodeExecutionPlugin } from "@mcpc/plugin-code-execution/plugin";
  205. {
  206. plugins: [createCodeExecutionPlugin()],
  207. options: { mode: "code_execution" }
  208. }
  209. ```
  210. > **Detailed Documentation**: See
  211. > [Execution Modes Guide](docs/execution-modes.md) for comprehensive information
  212. > on each mode, configuration options, and best practices.
  213. ## Documentation
  214. - **[Getting Started](docs/quickstart/installation.md)** - Installation and
  215. first steps
  216. - **[Creating Your First Agent](docs/quickstart/create-your-first-agentic-mcp.md)** -
  217. Complete tutorial
  218. - **[Execution Modes](docs/execution-modes.md)** - Comprehensive guide to all
  219. execution modes
  220. - **[CLI Usage Guide](docs/quickstart/cli-usage.md)** - Using the MCPC CLI
  221. - **[Logging and Tracing](docs/logging-and-tracing.md)** - MCP logging and
  222. OpenTelemetry tracing
  223. - **[Examples](docs/examples/)** - Real-world use cases
  224. - **[FAQ](docs/faq.md)** - Common questions and answer
  225. ## Examples
  226. See working examples in the [examples directory](packages/core/examples/) or
  227. check out the [Codex fork tutorial](docs/examples/creating-a-codex-fork.md).
  228. ## Contributing
  229. We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
  230. ## License
  231. MIT License - see [LICENSE](LICENSE) for details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.