Gcf Proxy

io.github.blackwell-systemsPublished by GitHub account blackwell-systemsv0.10.2Updated Oct 24, 2026

Drop-in MCP proxy. 71% fewer tokens. Session dedup compounds to 92%. Zero code changes.

VerifiedSTDIODesktop onlyDeveloper ToolsAI & ML

Overview

AI-generated overview

A drop-in stdio proxy that sits in front of any MCP server and re-encodes JSON tool responses into a compact GCF format to cut token usage.

What you can do
  • Wrap any local MCP server command or remote HTTP MCP endpoint and pass its traffic through unchanged.
  • Re-encode structured JSON tool responses into GCF and log per-call byte and token savings.
  • Decode GCF strings found in tool call arguments back into JSON before forwarding them upstream.
  • Optionally enable session deduplication, response caching, delta updates, size thresholds and stats files.
  • Run as a Streamable HTTP service with a health endpoint, or chain it to a remote upstream.
When to use it
Useful when an existing MCP server returns large structured JSON payloads and you want fewer input tokens without modifying that server or client. It suits setups where the server is third-party or maintained by another team and a one-line config change is acceptable.
Requirements
Runs locally as a stdio process; installable from npm, PyPI or Go. Needs the wrapped MCP server command or an upstream HTTP URL. No authentication, environment variables or headers are declared.
Before you install
It sits in the middle of all MCP traffic, so it sees every request and response, including any credentials or data those carry. It rewrites responses and decodes arguments, which can alter what the model or server sees; verify behavior with your own server before relying on it.

Installation

In SourceWeft

  1. Open Gcf Proxy in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

[Playground] [Benchmarks] [License]

gcf-proxy

Bidirectional MCP proxy that translates between JSON and GCF. Drop-in, zero changes to your server or client. Works with any structured data format.

100% comprehension on every frontier model. 29% fewer tokens than TOON, 56% fewer than JSON (2,400+ evals, 11 models, 3 providers). Nested object flattening with opt-out for open-weight models. One line change in your MCP config.

Install

bash
pip install gcf-proxy                                         # PyPInpm install -g @blackwell-systems/gcf-proxy                   # npmgo install github.com/blackwell-systems/gcf-proxy@latest      # Go

Try it (30 seconds, no auth)

bash
gcf-proxy --verbose uvx yfinance-mcp

Use it with any MCP client. When tools return structured JSON, the proxy re-encodes to GCF and logs savings to stderr:

gcf-proxy: get_price_history              54.0KB -> 28.1KB (48% saved)gcf-proxy: get_ticker_info                10.0KB -> 7.4KB (26% saved)gcf-proxy: get_price_history              53.8KB -> 27.9KB (48% saved)
--- gcf-proxy session stats ---Tool calls rewritten:  3JSON bytes in:         117.8KBGCF bytes out:         63.4KBBytes saved:           54.4KB (46.2%)Est. tokens saved:     ~13.6K-------------------------------

Real live stock data from Yahoo Finance. 118KB of JSON reduced to 63KB. ~13,600 tokens saved in 3 tool calls.

Usage

Local server (stdio)

Add gcf-proxy in front of any MCP server command:

json
{  "mcpServers": {    "memory": {      "command": "gcf-proxy",      "args": ["npx", "-y", "@modelcontextprotocol/server-memory"]    }  }}

Remote server (HTTP)

Point --upstream at any Streamable HTTP MCP server:

json
{  "mcpServers": {    "remote": {      "command": "gcf-proxy",      "args": ["--upstream", "http://host:3000/mcp"]    }  }}

Supports JSON and SSE responses. Session ID tracking via Mcp-Session-Id is automatic.

Deploy as HTTP service

--http turns the proxy into a remote Streamable HTTP server:

bash
gcf-proxy --http :9090 --session your-mcp-server

Any MCP client that supports HTTP transport connects directly. Health check at /health. Chains with --upstream for fully remote deployments.

Both modes are bidirectional: server responses are encoded to GCF, GCF in tool call arguments is decoded to JSON. Neither side needs to change.

Flags

FlagDescription
--sessionEnable session dedup (bare refs for previously-transmitted symbols)
--cacheCache encoded responses for identical tool calls
--deltaSend only changed symbols when a tool's response changes slightly
--no-flattenUse expanded encoding for nested objects (open-weight models currently comprehend this form better; GCF still outperforms JSON either way)
--min-size NSkip encoding for responses smaller than N bytes (default: 100)
--stream-threshold NMin symbols before streaming mode activates (default: 5)
--stats-file PATHWrite JSON stats to file after each call
--upstream URLConnect to a remote MCP server over HTTP
--http ADDRServe MCP over Streamable HTTP
--no-progressDisable progress notifications
--verboseLog per-call savings to stderr

Responses: Server (JSON) -> LLM (GCF)

Before: {"tool":"context_for_task","symbols":[{"qualified_name":"pkg.Auth","kind":"function","score":0.78,...},...]}After:  GCF profile=graph tool=context_for_task budget=5000 tokens=1900 symbols=50 edges=20        ## targets        @0 fn pkg.Auth 0.78 lsp_resolved        ...

53-71% fewer input tokens.

Requests: LLM (GCF) -> Server (JSON)

If the LLM produces GCF in a tool call argument (63% fewer output tokens), the proxy decodes it to JSON before forwarding:

LLM sends:    {"tool": "process", "arguments": {"data": "GCF profile=generic\nname=Alice\nage=30\n"}}Server gets:  {"tool": "process", "arguments": {"data": {"name": "Alice", "age": 30}}}

Detection is a 4-byte prefix check (GCF ). Zero overhead. Non-GCF strings pass through untouched.

How it works

  1. Spawns your MCP server as a subprocess
  2. Proxies stdin/stdout between client and server
  3. Responses: intercepts JSON-RPC responses, re-encodes structured JSON as GCF
  4. Requests: scans tool call arguments for GCF strings, decodes to JSON
  5. Passes everything else through unchanged in both directions

Why not modify the server?

Sometimes you can't. The server is a third-party binary, or it's maintained by another team, or you just don't want to add a dependency. gcf-proxy gives you the token savings without touching server code.

If you control the server, use the GCF libraries directly for better control over session deduplication and delta encoding.

Benchmarks

100% general comprehension on every frontier model. 91.2% on adversarial code graphs (vs TOON 68.8%, JSON 54.1%). Wins 15/16 datasets on token benchmark.

EvalGCFTOONJSON
General comprehension100%100%100%
Adversarial code graphs (500 symbols)91.2%68.8%54.1%
Token efficiency (16 datasets)15/16 wins1/16baseline

Reproduce comprehension eval: git clone https://github.com/blackwell-systems/gcf-go && cd gcf-go/eval && GOWORK=off go test -run TestComprehension -v -timeout 0

Reproduce token benchmark: git clone https://github.com/blackwell-systems/toon && cd toon && git checkout gcf-comparison && cd benchmarks && pnpm install && pnpm benchmark:tokens

Links

More links

License

MIT - Dayna Blackwell / GCF

Source: README.md at commit d912add

Tools

0
SourceWeft has not started this package in its sandbox yet, so its tools are not known.

Version history

1
  1. v0.10.2LatestSep 16, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts