pctx MCP — Anwendungsfälle, Installieren & Live-Demo

Warum nutzen

Hauptfunktionen

Code Mode: one LLM code block can chain many MCP tool calls in one turn
Deno sandbox: no FS, no env, allowlisted network only
Aggregates multiple upstream MCP servers behind one pctx
Credential-proofing: LLM never sees keys — pctx injects them
Install via Homebrew, npm -g, or curl-pipe script

Live-Demo

In der Praxis

pctx.replay ▶ bereit

0/0

Installieren

Wählen Sie Ihren Client

~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "pctx": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/portofcontext/pctx"
      ],
      "_inferred": true
    }
  }
}

Öffne Claude Desktop → Settings → Developer → Edit Config. Nach dem Speichern neu starten.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "pctx": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/portofcontext/pctx"
      ],
      "_inferred": true
    }
  }
}

Cursor nutzt das gleiche mcpServers-Schema wie Claude Desktop. Projektkonfiguration schlägt die globale.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "pctx": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/portofcontext/pctx"
      ],
      "_inferred": true
    }
  }
}

Klicken Sie auf das MCP-Servers-Symbol in der Cline-Seitenleiste, dann "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "pctx": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/portofcontext/pctx"
      ],
      "_inferred": true
    }
  }
}

Gleiche Struktur wie Claude Desktop. Windsurf neu starten zum Übernehmen.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "pctx",
      "command": "TODO",
      "args": [
        "See README: https://github.com/portofcontext/pctx"
      ]
    }
  ]
}

Continue nutzt ein Array von Serverobjekten statt einer Map.

~/.config/zed/settings.json

{
  "context_servers": {
    "pctx": {
      "command": {
        "path": "TODO",
        "args": [
          "See README: https://github.com/portofcontext/pctx"
        ]
      }
    }
  }
}

In context_servers hinzufügen. Zed lädt beim Speichern neu.

claude mcp add pctx -- TODO 'See README: https://github.com/portofcontext/pctx'

Einzeiler. Prüfen mit claude mcp list. Entfernen mit claude mcp remove.

Anwendungsfälle

Praxisnahe Nutzung: pctx

Run a chain of 20 tool calls as one code block

👤 Agent builders whose token bills spike on long sequential flows ⏱ ~20 min advanced

Wann einsetzen: A task needs many tool calls (fetch N issues, enrich each, post summary).

Voraussetzungen

pctx installed and configured — brew install portofcontext/tap/pctx; pctx config add <upstream-mcp>

Ablauf

Register upstreams with credentials

pctx config add github --env GITHUB_TOKEN=... and add sentry --env SENTRY_TOKEN=....✓ Kopiert

→ Upstreams listed
Ask agent to write Code Mode

In pctx Code Mode, write a function that fetches the 10 newest Sentry issues, for each finds the releasing commit via github, and returns a summary array.✓ Kopiert

→ Code block + single execution result
Inspect the result

Summarize the array in English and flag any issue whose releasing commit was by a specific author.✓ Kopiert

→ Final answer grounded in the data

Ergebnis: 10x fewer tool-call round-trips, major token savings, same result.

Fallstricke

Sandboxed code errors are opaque if you don't surface stderr — Wrap the code in try/catch and print caught errors so the LLM can self-correct
Network allowlist too tight — legitimate calls blocked — Start broad, narrow based on actual host usage from logs

Kombinieren mit: github · sentry

Isolate credentials from the LLM

👤 Security-conscious teams adopting MCPs ⏱ ~15 min intermediate

Wann einsetzen: Your threat model says 'LLM must never see the token in any form'.

Ablauf

Store creds in pctx

Add a keychain-backed credential to pctx for github.✓ Kopiert

→ Credential stored, not visible to callers
Verify from the other side

Ask the LLM to 'print the GitHub token' — confirm it cannot.✓ Kopiert

→ LLM has no way to access the secret

Ergebnis: A reproducible answer to 'can the LLM exfiltrate our tokens?' — no.

Aggregate many MCPs into one sandboxed code interface

👤 Teams wanting a single safe surface ⏱ ~25 min advanced

Wann einsetzen: You want Code Mode semantics across github, postgres, filesystem in one place.

Ablauf

Register each

Add github, postgres (read-only), and filesystem (scoped to /data) to pctx.✓ Kopiert

→ All three callable from code
Write a cross-MCP job

Write pctx code that reads a SQL query result and writes CSV to /data/out.csv, then creates a GitHub gist with that CSV.✓ Kopiert

→ Single execution, three upstreams used

Ergebnis: A unified, sandboxed execution plane for mixed-upstream workflows.

Kombinieren mit: github · postgres · filesystem

Kombinationen

Mit anderen MCPs für 10-fache Wirkung

pctx + github + sentry

Cross-reference Sentry issues with GitHub commits in one sandboxed code block

Via pctx Code Mode: for every new Sentry issue, find the GitHub commit that introduced it and return a table.✓ Kopiert

pctx + postgres

Query + transform + export in one sandbox

pctx code that runs a Postgres read, pivots the result in JS, and writes /data/report.json.✓ Kopiert

Werkzeuge

Was dieses MCP bereitstellt

Werkzeug	Eingaben	Wann aufrufen	Kosten
execute_code	code: str (JavaScript, access to injected MCP SDK)	Anytime the task needs >2 tool calls that compose	upstream tool calls inside the code
list_upstream_tools	(none)	Agent discovery — what's available to call from code	free

Kosten & Limits

Was der Betrieb kostet

API-Kontingent: No pctx quota; upstream calls inside code incur their own
Tokens pro Aufruf: Code Mode is far cheaper token-wise than many sequential tool calls
Kosten in €: Free, open source
Tipp: For tasks over 5 tool calls, Code Mode typically saves 50%+ tokens vs sequential calling.

Sicherheit

Rechte, Secrets, Reichweite

Credential-Speicherung: Env vars, OS keychain, or external command — LLM never sees credentials

Datenabfluss: Only to hosts explicitly allowlisted per upstream

Niemals gewähren: Allowlist the open internet in the sandbox — pin to specific hosts

Review what upstream tools the LLM-generated code calls — sandbox is network-scoped, not semantic.
Deno sandbox is strong but not infinite — treat it as defense in depth, not the only control.

Fehlerbehebung

Häufige Fehler und Lösungen

Network denied in sandbox

Add the host to the upstream's allowlist in pctx config.

Prüfen: pctx config show

Credential not injected

Credential name mismatch; pctx logs the resolved key on startup.

Prüfen: pctx run --debug

Code Mode returns a vague 'sandbox violation'

Enable verbose logs; most violations are env or FS access attempts the LLM shouldn't make.

Prüfen: pctx logs --tail

Alternativen

pctx vs. andere

Alternative	Wann stattdessen	Kompromiss
proxy-2 / 1mcp-agent	You want aggregation but not Code Mode / sandboxing	LLM calls each tool separately; can see whatever the MCP returns
Bare execution via shell MCP	You want code execution but don't need MCP proxying	No credential isolation, no allowlist

Mehr

Ressourcen

📖 Offizielle README auf GitHub lesen

🐙 Offene Issues ansehen

🔍 Alle 400+ MCP-Server und Skills durchsuchen