MCP工具

Prerequisites

• Docker Engine 20.10+
• Docker Compose v2
• Node.js 22+ (for npx mcp-remote)

Getting Started

Setup

```bash git clone <repo-url> cd mcp-codeforge

Build and start

docker compose up --build -d

Or use the helper script for a clean rebuild later (after pulling changes

./rebuild.sh # cache-friendly rebuild

./rebuild.sh --no-cache # full rebuild from scratch

Usage

Example: Cross-API Reconciliation

The client writes one TypeScript script that calls multiple APIs and processes data locally:

// Fetch orders from Shopify
const orders = await fetch("https://api.shopify.com/admin/api/2024-01/orders.json", {
  headers: { "X-Shopify-Access-Token": "SHOPIFY_AUTH_TOKEN" }
}).then(r => r.json());

// Fetch corresponding payments from Stripe
const payments = await Promise.all(
  orders.orders.map(o =>
    fetch(`https://api.stripe.com/v1/payment_intents/${o.payment_id}`, {
      headers: { "Authorization": "Bearer STRIPE_AUTH_TOKEN" }
    }).then(r => r.json())
  )
);

// Process locally — no tokens wasted sending raw data back to the LLM
const mismatches = orders.orders.filter((o, i) =>
  o.total_price !== payments[i].amount / 100
);

console.log(JSON.stringify({ total: orders.orders.length, mismatches }));

One code block, one inference pass, multiple API calls, data joined in the sandbox. The proxy transparently substitutes STRIPE_AUTH_TOKEN and SHOPIFY_AUTH_TOKEN with real credentials on the wire.

MCP Client Configuration

For Claude Desktop or any MCP client that takes a JSON config:

{
  "mcpServers": {
    "codeforge": {
      "command": "npx",
      "args": ["mcp-remote", "http://localhost:8080/mcp"]
    }
  }
}

For Claude Code (CLI), one command. Add --scope user to make CodeForge available in every project you open, not just the current one:

```bash

Runtime configuration (required)

cp .env.example .env

Edit .env — toggle YOLO_MODE if you want unrestricted egress

Configure at least one API

cp apis/example/config.json.example apis/myservice/config.json

Edit apis/myservice/config.json with your domains and real credentials

or editing apis/*/config.json):

Authenticated APIs without secrets in LLM context

Most "let the agent call REST APIs" patterns force a trade-off: either the agent sees real credentials (and so does any model context that handles them), or every API gets wrapped in a hand-rolled MCP server that holds the secret server-side and exposes it through curated tools. CodeForge takes a third path. Sandboxed code references credentials by name — STRIPE_AUTH_TOKEN, SHOPIFY_AUTH_TOKEN — as ordinary string literals in fetch() calls. A transparent mitmproxy on the sandbox's default route substitutes the real value per destination host on outbound and reverses the substitution on inbound, scoped so a token literal sent to any unconfigured host passes through unchanged. Real credentials live only in gitignored apis/*/config.json files and proxy process memory — never in the model's context window, never in the sandbox process, never in the logs. A prompt injection that exfiltrates everything the sandbox can see leaks token names, not real secrets. The sandbox can use authenticated APIs without ever being trusted with the keys to them. (Full mechanics in Secret Protection below.)

Skills — composable multi-API automations

A working script is not throwaway. CodeForge gives the sandbox a persistent /skills volume surfaced through MCP resources and a run_skill prompt — directly aligned with Anthropic's Equipping agents for the real world with Agent Skills progressive-disclosure model: load the skill body only when invoked, not on every session init.

Pair that with the single-sandbox-N-APIs design and skills become durable, deterministic automations that span multiple authenticated services. Both Anthropic and Cloudflare touch on the underlying point — Anthropic's post argues that intermediate results staying in the execution environment is what lets sensitive data flow through a workflow without entering model context; Cloudflare's Code Mode posts emphasize that an agent can compose many calls in one execution and return only the data it needs. CodeForge takes both observations to their natural endpoint: a single skill can fetch from Salesforce, enrich via Clearbit, open a Linear ticket, post to Slack, and write a row to BigQuery — five authenticated APIs, composed in-process — and return only {"status":"ok","ticket_id":"ENG-1234"} to the model. None of the raw payloads enter the LLM's context. The model invokes the skill by name, observes one line of output, and decides what to do next.

The result is a clean separation between the deterministic part of a workflow (in code, in a saved skill) and the open-ended reasoning (in the model), with per-call savings inside a session and per-skill savings across sessions stacking on top.

Adding a New API

1. Create apis/<name>/config.json:

   {
     "description": "Service description",
     "domains": ["api.example.com"],
     "credentials": {
       "EXAMPLE_AUTH_TOKEN": "your_real_key_here"
     },
     "reference": "https://docs.example.com/api",
     "restricted_methods": ["POST", "PUT", "DELETE"],
     "active": true
   }