Skip to main content
Glama

Metrecept — open client tools

Proof, not trust. Metrecept issues a signed Ed25519 receipt (compact JWS) for every call an autonomous AI agent makes through it — model completions, compliant public-web fetches, and calls to third-party business APIs — and can roll a whole agent run into one signed session receipt. Anyone can verify a receipt against Metrecept's published public keys, with no account and no Metrecept code.

Metrecept is a recorder, not a governor: it does not stop a bad call, and a receipt does not grade the work. It proves what was called, when, and what it cost. It is built for autonomous AI agent companies that need a record a customer or auditor can check, and for stablecoin and settlement firms that need a verifiable record of each agent-initiated call.

Site: https://metrecept.co.uk · API: https://api.metrecept.co.uk/v1 · Docs: https://metrecept.co.uk/docs


What's in this repo

This is the public, MIT-licensed thin client for Metrecept — an MCP server (23 metrecept_* tools in three toolsets: core, cache, receipts), Python and TypeScript SDK helpers, an n8n node, receipt verifiers and demos, plus a redacted tour of the architecture behind the hosted gateway. The hosted gateway is proprietary, and every real call needs a Metrecept API key. Nothing here requires trusting prose: every claim below links to a command you can run yourself.

Path

What it is

docs/

Architecture exhibition — how the gateway is built, what a signed receipt is, how compliant web fetch works, why this shape instead of a routing proxy

demo/

Runnable scripts that prove the claims against the live hosted API — no Metrecept code required to verify a receipt

sdks/python/

Python OpenAI base_url helper (at-utility-sdk on PyPI)

sdks/typescript/

TypeScript/JS helper (@at-utility/sdk on npm)

packages/metrecept-mcp/

MCP server for Cursor/Claude agents (pip install metrecept-mcp; command metrecept-mcp)

templates/

Ready-to-clone agent integration templates

actions/receipt-link/

GitHub Action: comment the run's signed session receipt on a pull request as a link (https://metrecept.co.uk/verify#<jws>) — whoever opens it checks the Ed25519 signature in their browser against the public key directory, no account

Related MCP server: MCP Billing Gateway SDK

What's not in this repo

The gateway (gateway-rs Rust edge + Python control plane), the cache engine internals, the adaptive model routing, and the billing/compliance core are proprietary and stay closed — no self-hosting option, and that's a deliberate, permanent split, not a staged reveal. What's below is a genuine architectural tour of how the gateway is shaped and what it commits to publicly, not a copy of the implementation. See LICENSE and NOTICE for the exact split.

Architecture at a glance

flowchart TB
  clients["Clients<br/>Shell · MCP · SDK"]
  subgraph ephemeral ["Ephemeral Side"]
    edge["Edge (Rust)<br/>HIT path"]
    trees["Cache trees"]
  end
  subgraph pipeline ["Pipeline System"]
    auth["Tenant / keys / org"]
    meters["Meters -> ledger"]
    ingest["Compliance ingest"]
    route["Provider route"]
    trust["Signed receipts<br/>(JWKS)"]
  end
  labs["Upstream labs<br/>(BYOK)"]
  web["Public web"]
  clients --> edge
  edge -->|HIT| trust
  edge -->|MISS| route
  route --> labs
  clients --> ingest
  ingest --> web
  auth --> edge
  meters --> auth
  route --> meters
  ingest --> meters

One OpenAI-compatible ingress. Every call is metered and signed: the response carries a receipt you can verify independently. Exact repeats can be served from the tenant's cache. Full walkthrough: docs/ARCHITECTURE.md.

Verify it yourself

Prose is cheap; every claim below ships with the command that checks it against the live, hosted gateway — nothing in this table depends on trusting this README.

Claim

Check

The gateway is up

curl -s https://api.metrecept.co.uk/health && curl -s https://api.metrecept.co.uk/ready

Exact repeats are served from cache and billed as hits

Send the same body twice — second response has X-AT-Cache: HIT + X-AT-Billed-USD — see demo/hit_miss_demo.sh

Every call carries a signed receipt

Responses carry a signed JWS receipt header (X-Metrecept-Receipt, legacy X-Metrecept-Receipt) — verify with zero Metrecept code: python demo/verify_receipt.py "<receipt>" — see docs/RECEIPTS.md

The bytes you got are the bytes the receipt names

Crossing receipts may carry response_sha256. Recompute it from your own capture with zero Metrecept code: python demo/response_digest.py body.json for a JSON body, python demo/response_digest.py --sse stream.txt for the raw stream you received (the gateway's assembly rule is in the file). A stream that never finished carries no digest

Signing keys are public

curl -s https://api.metrecept.co.uk/.well-known/http-message-signatures-directory

The run's receipt is a link a stranger can open

Tag calls with X-Metrecept-Session: <id>, then GET /v1/sessions/<id> returns a signed kind: "session" receipt. Put it after https://metrecept.co.uk/verify# and send the link: the Ed25519 check runs in the browser against the directory above, no account. The session receipt is $0. It proves Metrecept signed this record of the run; it does not grade the work, and it did not stop anything

Published limits and refusals

curl -s https://api.metrecept.co.uk/v1/public/honesty — what the gateway won't do, with the endpoint that proves each item

Cross-tenant savings counter

curl -s https://api.metrecept.co.uk/v1/public/stats (always estimate_only: true)

Quickstart

Every real call needs an API key. Get one ($0 seat, no card) at metrecept.co.uk/billing/intermediate, then:

from at_utility_sdk import openai_client

client = openai_client("sk-at-...", base_url="https://api.metrecept.co.uk/v1")
completion = client.chat.completions.create(
    model="mock",  # or gpt-*/claude-*/etc. with your own upstream key (BYOK)
    messages=[{"role": "user", "content": "Hello"}],
)

Or jump straight to the proof: demo/ makes a call, captures its receipt and verifies it in under a minute.

License

MIT (see LICENSE). This repo is a periodically-synced mirror of the public-facing directories in Metrecept's private monorepo, not the primary development location — see the per-directory LICENSE files.

Available Tools

23 tools
metrecept_archive_cache_treeCache: Archive cache treeA

Archive a cache tree: make it read-only and hide it from metrecept_list_cache_trees, keeping every entry so it can be restored later; archived=false restores it to the status it had before (active or frozen). Use it to retire a finished experiment's tree without losing it. Not for a temporary write lock: use metrecept_freeze_cache_tree. Not for freeing storage: use metrecept_delete_cache_tree. Archived trees still serve hits, but writes, eviction, reset and freeze return 409 tree_archived, and they cannot be a fork parent or promote target. List them with include_archived=true. Idempotent, not billed, audit-logged. Errors: 409 cannot_archive_main, 404 tree_missing. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: tree_id (required), archived. Returns: result

metrecept_call_apiCore: Call APIA

Make a read-only GET call to a registered third-party API through the gateway and return the vendor's response body, with a signed receipt that stores only a hash of path and query. Use it for authenticated vendor JSON APIs mid-session. Register the service first with metrecept_register_api_service. Not for public web pages: use metrecept_fetch_web_pages. path must sit under the service's allowed_path_prefix (e.g. prefix "/v1" allows "/v1/lookup"); query is sent as the URL query string. Pass the same session_id as your chat and fetch calls to group them into one metrecept_get_session_receipt receipt. Billed per call at the plan rate. Unknown service returns 404 service_not_found; vendor errors and prefix violations return JSON {"error", "status"}. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: path (required), service (required), query, purpose, +2 more. Returns: result

metrecept_create_chat_completionCore: Create chat completionA

Send one user message to a model through the Metrecept gateway (OpenAI-compatible) and return the reply text; an exact repeat of a request is served from the tenant's cache. Use it for model answers, optionally grounded in public pages via fetch_urls. Not for the page content itself: use metrecept_fetch_web_pages. Start with model "mock" to test without an upstream key; pick real ids from metrecept_list_models. purpose only applies when fetch_urls is set; check allowed values with metrecept_get_fetch_policy. Pass one session_id across a run's chat, fetch and API calls, then read metrecept_get_session_receipt. Metered and receipted per call. Failures (bad model, missing BYOK key, refused fetch, rate limit) return JSON {"error", "status"}. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: prompt (required), model, purpose, fetch_urls, +2 more. Returns: result

metrecept_delete_cache_treeCache: Delete cache treeA

Delete a whole non-main cache tree: its metadata, digest index, references and the cached responses it owns. Use it to clean up after an experiment, typically after metrecept_manage_cache_tree promote. Find ids with metrecept_list_cache_trees. Not for a single entry: use metrecept_evict_cache_entry. Destructive and immediate, no undo; not billed. Refuses "main" (409 cannot_delete_main) and trees with children (409 tree_has_children; delete children first). Responses another tree references after a promote are kept until their TTL. A missing or already-deleted tree returns 404 tree_missing. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: tree_id (required). Returns: result

metrecept_evict_cache_entryCache: Evict cache entryA

Evict one cached response from a cache tree by its request digest, so the next identical request in that tree is a fresh miss sent upstream and billed as a miss. Use it to drop a stale or wrong cached answer. Get the digest from metrecept_list_cache_entries. Not for removing a whole tree: use metrecept_delete_cache_tree. Ownership: eviction removes only this tree's own copy or reference. An entry inherited from a parent is untouched; evict it in the parent. If this tree owns the bytes, trees referencing them after a promote also lose the entry. Destructive and immediate, no undo; not billed. Errors: 404 tree_missing or entry_missing (also on a repeat), 409 tree_frozen, 400 invalid_digest. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: digest (required), tree_id. Returns: result

metrecept_fetch_web_pagesCore: Fetch web pagesA

Fetch public web pages through the Metrecept compliance filter and return redacted markdown or JSON context, metered and receipted. Use it when you need the page content itself. Not for a model answer grounded in pages: pass fetch_urls to metrecept_create_chat_completion. Not for an authenticated JSON API you hold a key for: use metrecept_call_api. Call metrecept_get_fetch_policy first to pick a valid purpose and stay within its character caps; a few URLs per call is the norm. Pass the same session_id you use on chat and API calls to group them into one metrecept_get_session_receipt receipt. Behaviour: the tenant must have accepted Terms/DPA at Checkout, otherwise the call is refused. robots.txt is respected (fail-closed), PII is redacted, and login walls, 401/403 and 402 pay-per-crawl refusals are honoured, never bypassed. Never cached. Failures return JSON {"error", "status"} with secrets redacted. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: urls (required), query, format, purpose, +1 more. Returns: result

metrecept_freeze_cache_treeCache: Freeze cache treeA

Freeze a cache tree so it keeps serving its cached responses but accepts no new writes, or unfreeze it (frozen=false) back to active. Use it to pin a known-good cache, for example a release branch's tree, while experiments continue in forks. Not for hiding or retiring a tree: use metrecept_archive_cache_tree. Not for removing it: use metrecept_delete_cache_tree. While frozen, misses are served upstream but not stored, eviction returns 409 tree_frozen and the tree cannot be a fork parent or promote target. Idempotent, not billed, audit-logged. Errors: 409 cannot_freeze_main, 409 tree_archived (restore it first), 404 tree_missing. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: tree_id (required), frozen. Returns: result

metrecept_get_fetch_policyCore: Get fetch policyA

Read the web-fetch compliance policy enforced for this tenant: allowed purpose values, robots.txt and PII-redaction settings, whether Terms/DPA acceptance is required, and per-source and total character caps. Use it before metrecept_fetch_web_pages or a metrecept_create_chat_completion with fetch_urls, or after a refused fetch to see which rule applied. Not for third-party APIs: metrecept_call_api uses registered services instead. Read-only, not billed. A bad or missing key returns the gateway's 401 JSON error. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: no named parameters. Returns: result

metrecept_get_savingsCore: Get savingsA

Read the tenant's cumulative savings ledger: cache hit ratio and hit tokens, estimated upstream spend avoided by cache replays, what Metrecept billed for hits and misses, net saving and ROI. Use it for the money view. Not for raw meters or plan: use metrecept_get_usage; for per-day meters use metrecept_get_usage_history. To share these numbers publicly use metrecept_publish_savings_receipt. Avoided-spend figures are list-price estimates (the response carries a disclaimer); billed figures are exact. Read-only, not billed, never cached. A bad or missing key returns the gateway's 401 JSON error. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: no named parameters. Returns: result

metrecept_get_session_receiptReceipts: Get session receiptA

Get one signed, aggregated receipt for a session: every chat completion, web fetch and API call tagged with the same session_id, with event count, total billed USD, cache hits/misses, fetch and API counts, first/last timestamps, the compact JWS and a verify_url. Use it at the end of an agent run and put verify_url in the PR, ticket or email the run produced; anyone can verify it in a browser, no account needed. Not for a public savings snapshot: use metrecept_publish_savings_receipt. Not for tenant totals: use metrecept_get_usage. Read-only, makes no upstream call, not billed. An unknown id returns event_count 0, not an error. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: session_id (required). Returns: result

metrecept_get_usageCore: Get usageA

Read the tenant's live lifetime usage meters: requests, cache hit/miss tokens and ratio, web fetches, API calls, billed USD per meter and total, today's UTC-day values, plan, billing status and whether the soft web-fetch cap is lifted. Use it for 'how much have I used / what plan am I on'. Not for per-day trends: use metrecept_get_usage_history. Not for money saved: use metrecept_get_savings. Not for one run's signed record: use metrecept_get_session_receipt. Read-only, not billed, never cached. A bad or missing key returns the gateway's 401 JSON error. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: no named parameters. Returns: result

metrecept_get_usage_historyCore: Get usage historyA

Read the tenant's usage meters as a per-UTC-day series, oldest day first, plus window totals: requests, cache hit/miss tokens and USD, prewarm, web fetches, API calls, custody and statement meters, upstream cache tokens and billed_usd. Use it for trends or 'what did I spend each day'. Not for lifetime totals or plan: use metrecept_get_usage. Not for spend avoided: use metrecept_get_savings. Read from the durable per-day ledger; idle days are 0, nothing is estimated. Read-only, not billed. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: days. Returns: result

metrecept_list_api_servicesCore: List API servicesA

List the tenant's registered third-party API services: name, base URL, path prefix, auth header name and purpose. No credentials are stored, so none are returned. Use it to confirm a service name before metrecept_call_api. Register new ones with metrecept_register_api_service; remove with metrecept_unregister_api_service. Read-only, not billed, live, not paginated. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: no named parameters. Returns: result

metrecept_list_cache_entriesCache: List cache entriesA

List entries cached in one tree: request digest, model, token count, byte size and TTL remaining. Metadata only; never returns prompt or response content. Use it to inspect a tree or to get the digest that metrecept_evict_cache_entry needs. Get tree ids from metrecept_list_cache_trees. Page through with offset = previous offset + limit until fewer than limit entries come back. Read-only, not billed, live. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: limit, offset, tree_id. Returns: result

metrecept_list_cache_treesCache: List cache treesA

List every cache tree (isolated exact-replay namespace) the tenant owns, always including the default "main", ordered main first then by creation time. All trees come back in one call. Each tree reports its status: active, frozen or archived. Use it to find a tree_id for the other cache tools. Not for a tree's contents: use metrecept_list_cache_entries. To create, fork or promote use metrecept_manage_cache_tree; to remove a non-main tree use metrecept_delete_cache_tree. Archived trees are hidden unless include_archived=true. Read-only, not billed, live. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: include_archived. Returns: result

metrecept_list_modelsCore: List modelsA

List model ids the gateway can route chat to (mock plus examples for OpenAI, Anthropic, Gemini, DeepSeek, Moonshot, Z.ai, Qwen, xAI) and the prefix routing table. Use it before metrecept_create_chat_completion to pick a model; any id under a routed prefix is forwarded verbatim. Not for which vendors are actually configured: use metrecept_list_providers. Static list, read-only, not billed. Non-mock models need your own upstream key (BYOK). Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: no named parameters. Returns: result

metrecept_list_providersCore: List providersA

Show which upstream vendors the gateway has configured and ready (mock, openai, anthropic and each OpenAI-compatible vendor), with BYOK header name and billing model. Use it to debug a failed metrecept_create_chat_completion or check a vendor is ready. Not for picking a model id: use metrecept_list_models. Reports key presence only; keys are never validated upstream or returned. Read-only, not billed, live. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: no named parameters. Returns: result

metrecept_manage_cache_treeCache: Manage cache treeA

Create, fork or promote a cache tree (an isolated exact-replay namespace). Use it to isolate cache for an experiment or PR: fork main, send chat calls into the fork, promote it back when good, then remove it with metrecept_delete_cache_tree. Not for listing trees: use metrecept_list_cache_trees. Not for deleting a tree or entry: use metrecept_delete_cache_tree or metrecept_evict_cache_entry. create and fork give the new tree an empty local index that reads its parent chain copy-on-write, so it serves parent entries by reference with zero bytes copied; its own new entries stay local. promote adds references to tree_id's own entries in the target tree (bytes_copied is always 0) and leaves the child intact; it never swaps trees, main stays the default and cannot itself be promoted. Not billed; audit-logged. Errors return ok=false with status and error: 409 tree_exists, 404 parent_missing, 404 tree_missing, 409 cannot_promote_main, 409 parent_frozen, 409 tree_archived or parent_archived, 400 invalid_cache_tree. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: action (required), into, name, parent, +1 more. Returns: Structured result of metrecept_manage_cache_tree (fields depend on action).

metrecept_mint_receiptReceipts: Mint receiptA

Mint one fresh signed Ed25519 receipt (compact JWS) of a chosen kind by making the smallest real gateway call that produces it, and return the receipt with its kid, iat and a verify_url. Use it to show or test receipt verification end to end, or to attach a real receipt to a demo or bug report. Not for a run you already made: use metrecept_get_session_receipt. Not for a public savings page: use metrecept_publish_savings_receipt. Each kind makes real calls billed as normal (cache_miss, finops, cache_bypass, web_fetch and api_call are metered; cache_hit bills one miss then a hit). Anyone can check verify_url in a browser against the public key directory. Errors come back as JSON {"error", ...}: no_api_service when kind api_call has no registered service, no_receipt when none of that kind came back. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: kind (required), label. Returns: result

metrecept_prewarm_cacheCache: Prewarm cacheA

Refresh an about-to-expire Anthropic prompt-cache breakpoint for a session with a one-token call, so the next real turn reads the cache instead of paying a fresh cache write. Use it from an idle timer when a long Claude conversation is about to sit past the cache TTL. Not for the gateway's own exact-replay cache (it never touches it): use metrecept_create_chat_completion. Not for OpenAI or other vendors, whose prompt caching is automatic. Sends your transcript and your upstream key exactly like a chat call; nothing is stored. Unbilled by the gateway (returns billed:false, billed_usd 0; the vendor still charges its own tokens) and audit-logged. Errors: 400 prewarm_unsupported_model for non-claude models, 400 cache_autopilot_disabled when the gateway has cache autopilot off, 401/402 for a missing upstream key. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: model (required), messages (required), session_id (required), upstream_api_key. Returns: result

metrecept_publish_savings_receiptReceipts: Publish savings receiptA

Publish a public, shareable savings receipt: an immutable Ed25519-signed snapshot of current savings at metrecept.co.uk/r/, plus a README badge snippet. Use it when the user wants to share savings outside the tenant. Not for checking the numbers privately: use metrecept_get_savings (call it first to review). Not for a per-run record: use metrecept_get_session_receipt. Side effect: creates a public page that lives 90 days and shows only display_name, never the tenant id or key. Not billed. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: display_name. Returns: result

metrecept_register_api_serviceCore: Register API serviceA

Register or update a third-party API service so metrecept_call_api can make receipted GET calls to it. Use it once per vendor before metrecept_call_api; confirm with metrecept_list_api_services, remove with metrecept_unregister_api_service. Stores only the non-secret shape (base URL, path prefix, auth header name, purpose); the credential travels per call as metrecept_call_api's service_key and is never stored. Re-using a name overwrites that service. Private/internal base URLs are rejected. Not billed. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: name (required), base_url (required), purpose, auth_header_name, +1 more. Returns: result

metrecept_unregister_api_serviceCore: Unregister API serviceA

Unregister one of the tenant's third-party API services so metrecept_call_api can no longer reach it. Use it to retire a vendor integration; check exact names with metrecept_list_api_services. Not for changing settings: re-register the same name with metrecept_register_api_service. Destructive and immediate, no undo, though no credential is lost because none is stored. Later calls and repeat unregisters return 404 service_not_found; 404 feature_disabled means API passthrough is off. Not billed. Requires a Metrecept API key (METRECEPT_API_KEY env on stdio, or Authorization: Bearer on remote HTTP); results are scoped to that key's tenant only.

Inputs: name (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 23 tools

    Disambiguation5/5

    Every description explicitly names sibling tools and states 'not for X: use Y', which removes practically all overlap between the many get/list/receipt/cache tools. The cache-tree family (list, list_entries, manage, freeze, archive, delete, evict) and the three receipt tools (session, savings, mint) are cleanly delineated by purpose and lifecycle stage.

    Naming Consistency4/5

    All tools use a uniform metrecept_ prefix and snake_case verb_noun pattern (list_/get_/create_/delete_/evict_/publish_), which is highly predictable. The main deviation is metrecept_manage_cache_tree, a bundled multi-action tool (create/fork/promote) whose verb doesn't map to a single operation like its siblings.

    Tool Count4/5

    23 tools is at the upper edge of comfortable, but the surface spans genuinely distinct sub-domains (chat, web fetch, API passthrough, cache-tree lifecycle, usage/savings, receipts), so each tool earns its place. The cache-tree lifecycle alone accounts for seven tools, which is the heaviest concentration but still justified by distinct states.

    Completeness4/5

    Coverage is strong: full service CRUD (register/list/unregister with overwrite-as-update), complete cache-tree lifecycle including fork/promote/freeze/archive/evict, and read-only usage, savings, and signed-receipt surfaces. Minor gaps exist around chat (single-message only, no streaming or multi-turn/history) and no listing of past sessions or receipts, but core workflows are end-to-end.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers