mcpField
T
toolc

toolc

Local
toolc.devAI & Agents0Updated 6w ago
RepositoryVisit website

About toolc

toolc compiles MCP servers, REST APIs, or documentation into a smaller agent-facing endpoint. Teams can tune tool consolidation and selection, while call logs and result compaction support operation and monitoring.

Key features

  1. 01Compile MCP and REST tool surfaces
  2. 02Rewrite descriptions and consolidate similar tools
  3. 03Expose catalogs through search_tools and call_tool
  4. 04Compact large results and log calls
  5. 05Import APIs from OpenAPI or documentation

Use cases

  1. 01Reduce tool definitions in agent context
  2. 02Unify tools from multiple MCP servers
  3. 03Add a REST API from its OpenAPI spec
  4. 04Review calls and recurring errors

MCP support

It accepts MCP servers as downstreams and runs a gateway as an MCP server for clients. The gateway can expose a compiled or mirrored tool surface.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
  "mcpServers": {
    "dev-toolc-toolc": {
      "command": "npx",
      "args": [
        "-y",
        "@toolc/cli"
      ],
      "env": {
        "ANTHROPIC_API_KEY": "<ANTHROPIC_API_KEY>"
      }
    }
  }
}
Run commandnpx -y @toolc/cli
Environment variables to set
ANTHROPIC_API_KEYSecretEnables the LLM-assisted compile passes (rewrite, consolidate). Without it, toolc serves a mirror of the original tool surface.

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
npm@toolc/cli0.1.1

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

toolc

The optimizing compiler for agent tool surfaces. Point it at your MCP servers, or just a REST API's OpenAPI spec, or even a docs page, and get back one endpoint that serves a smaller, smarter tool surface: cheaper for every agent that connects, more accurate on every task, with every call logged.

Connecting N MCP servers dumps every tool definition into the model's context, degrades tool selection, and forces improvised multi-hop call chains. toolc compiles the federation instead:

  • Rewrite: LLM-optimized descriptions with sibling disambiguation
  • Consolidate: families of near-duplicate tools (search_x/find_x/get_x) merge into single facade tools with deterministic routing
  • Selection: the whole catalog compresses behind two meta-tools (search_tools/call_tool) when you want maximum context savings
  • Compaction: oversized results are summarized at serve time, preserving identifiers and sourcing details
  • Compose: REST APIs join the pool straight from an OpenAPI spec, or from a drafted spec synthesized from their documentation
  • Observe: every call logged with arguments and results; recurring errors cluster into recommended fixes

Benchmark

131 tools across 5 live servers, 30 tasks × 3 trials, judged answers (full grid · consolidation run):

conditionsuccesscost / completed tasktool-def context
raw (all 131 tools)96.7%$0.2631~24,360 tok
compiled + consolidate96.7%$0.0411 (6.4× cheaper)~845 tok
consolidate, no selection100.0%$0.1335~14,506 tok

Consolidation dominates both ends of the frontier: the selection surface is the cost lever, consolidation lifts accuracy everywhere. Every pass is a config toggle; pick the tradeoff per deployment.

Quick start

git clone https://github.com/toolc-dev/toolc && cd toolc
pnpm install && pnpm -r test

# describe your federation
cp toolc.config.example.jsonc toolc.config.jsonc

# introspect it
node packages/cli/bin/toolc.mjs -c toolc.config.jsonc inspect

# compile (set ANTHROPIC_API_KEY for the rewrite/consolidate passes)
node packages/cli/bin/toolc.mjs -c toolc.config.jsonc compile

# serve the compiled surface over stdio (add to Claude as an MCP server)
node packages/cli/bin/toolc.mjs -c toolc.config.jsonc serve --mode compiled

A downstream can be an MCP server or a bare REST API:

{
  "downstream": [
    { "id": "gh", "transport": { "type": "http", "url": "https://api.githubcopilot.com/mcp/" } },
    { "id": "nws", "transport": { "type": "openapi", "spec": "https://api.weather.gov/openapi.json" } }
  ]
}

See SELF_HOSTING.md for Docker deployment.

Hosted

toolc.dev runs this same engine as a managed service: compiled HTTPS endpoints, a console with a playground and full-payload log explorer, docs-to-spec drafting, and error-driven fix recommendations.

Layout

  • packages/core: IR (Capability Graph), frontends (MCP, OpenAPI, docs synthesis), passes, emit
  • packages/gateway: runtime MCP server (mirror + compiled) with call logging and compaction
  • packages/cli: the toolc command
  • packages/harness: benchmark runner, grading, reports
  • packages/shared: config schema, errors

License

The engine (everything in this repository) is Apache-2.0, forever: anyone can compile and serve their own tool surfaces locally with the exact same compilation quality as the hosted product.

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.