opennodes
OfficialThis read-only MCP server lets you discover, compare, vet, and cost-estimate AI inference offerings in the OpenNodes registry without invoking models or spending money.
Recommend the best node and model for a task using local prompt-feature extraction, constraints, and ranked candidates.
Search inference offerings with filters for text, language, model family, modality, trust tier, payment scheme, supported features, context size, and price; sort by rank, price, TTFT, or throughput.
Get full details for a specific offering, including endpoints, pricing, capabilities, data policy, trust tier, and probe results.
Get provider/node details, including operator, regions, endpoints, hardware, trust history, probe availability, and offerings.
Estimate the cost of one or more invocation-chain steps before spending, including per-step cost bounds, pinned card revisions, and chain totals.
Ships an OpenNodes router for Ollama that presents one Ollama-compatible endpoint spanning local Ollama models, other Ollama/Node Kit servers on the LAN (auto-discovered via mDNS), and verified public nodes from the registry, with auto/auto-cheap/auto-fast/auto-quality/auto-private routing, pinned prices, budget caps, and signed receipts for public calls.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
# OpenNodes
AI inference, measured — not just claimed. OpenNodes is an open protocol (ONP) and registry for AI inference endpoints, from your own Ollama box to sovereign EU clouds. The registry checks what each endpoint really serves — which model, how much context actually works, how fast it answers, on what hardware, at what price — and your prompts go straight to the endpoint you pick: OpenNodes is never in the data path.
Browse: registry.opennodes.io — 10,000+ offerings from about 250 providers, with trust tiers and measured results
Learn: opennodes.io · Integrations (one-click install for Cursor and VS Code; Claude, Kiro, Open WebUI, OpenAI SDKs, agents)
Status: ONP Draft 0.1 with errata (2026-10-23) and revisions 2 and 3 (2026-10-31, 2026-11-02; changes), a working proposal not affiliated with any standards body yet; reference stack live, with project-run reference nodes in Germany and Finland. Operators: list your endpoint or write to operators@opennodes.io.
Quick start
npx @opennodes/ollama-router # OpenNodes for Ollama: one Ollama endpoint over local + LAN + verified public models
npx @opennodes/cli mcp --print-config # MCP tools for Cursor / VS Code / Claude Desktop / Kiro (or use https://registry.opennodes.io/mcp)
npx @opennodes/cli gateway --port 4141 # OpenAI-compatible gateway with onp/auto routing; base URL http://127.0.0.1:4141/v1
npx @opennodes/registry # run your own registry: web app + API + MCP on http://127.0.0.1:4300
pipx install onp-node # Node Kit: list a vLLM / Ollama / TGI deployment, or an API you already runnpm: @opennodes/core · @opennodes/cli · @opennodes/registry · @opennodes/ollama-router — PyPI: onp-node

OpenNodes for Ollama (impl/packages/ollama-router): point Open WebUI, Continue, Zed, or the ollama CLI at OLLAMA_HOST=127.0.0.1:11435 and one model list spans your local Ollama, other machines on your LAN (plain Ollama servers or Node Kit nodes, auto-discovered via mDNS), and verified public nodes from the registry — with auto, auto-cheap, auto-fast, auto-quality, auto-private (never leaves the LAN), auto-eu and auto-ca or any auto-<country> (LAN plus operators in that jurisdiction) routed by the advisor, pinned prices, budget caps, and signed receipts for public calls.
MCP server — five read-only tools: recommend (best node and model for a task; the prompt is analysed locally and only its features are sent), search_offerings, get_offering, get_node, estimate. Listed on the MCP Registry (as io.github.opennodes-io/opennodes, stdio and remote), Glama and mcprush:
Related MCP server: Kairos Signal MCP Server
Why a protocol
MCP standardized how AI applications reach tools; the OpenAI API shape standardized how they invoke models — but nothing standardizes how a client finds an inference endpoint it doesn't already know about: what model it serves, how big it is, what hardware backs it, how well it benchmarks, what it costs per token, and whether it's up. ONP fills exactly that gap and composes the rest from existing standards: a signed Node Card at /.well-known/open-node.json, a registry API with automated verification, OpenAI-compatible invocation with pinned prices, and signed usage receipts.
Documents
Start here
00 — Project overview — the concept, architecture, implementation status, completed development stages, and next steps in one document.
Research (why this standard, and why now)
01 — Protocol & standards landscape — MCP + Registry, WebMCP, A2A, AGNTCY, ANP, NANDA, OpenAI-compatible APIs, DIDs/VCs, x402, UCAN, model cards, MLPerf; full gap analysis.
02 — Market landscape & demand evidence — OpenRouter, HF Inference Providers, gateways, DePIN/decentralized compute, OS-level AI runtimes, payment rails; viability assessment.
05 — OpenNodes and European digital sovereignty — one-page brief: no middlebox, EU/EEA jurisdiction filter, signed self-descriptions and receipts, mapped to GDPR, the AI Act and the Data Act (web version).
04 — Universal AI client landscape — AI browsers, branded assistants, neutral/BYOK clients, multi-homing data, distribution economics; assessment of the "primary access point" client idea.
Specification suite
ONP-2 — The Node Card — self-description document at
/.well-known/open-node.jsonONP-3 — Registry & Discovery API — registration, verification, search, health, ranking, federation
ONP-4 — Invocation profiles — bindings for text, image/diffusion, embeddings, agents
ONP-5 — Settlement — price advertisement, payment schemes (x402 / prepaid / free), signed usage receipts
ONP-6 — Bridging — connecting discovered nodes to MCP servers, WebMCP sites, and conventional web data
Known issues → Draft 0.2 — what external reviews raised about Draft 0.1, and what was fixed (errata 2026-10-23), planned, or not adopted
Development requirements
REQ-001 — Discovery Service (registry) — MVP registry: registration, admission battery, search, estimation, MCP surface; acceptance criteria.
REQ-002 — Test client — CLI + OpenAI-compatible gateway + MCP modes; compatibility matrix (Cursor, VS Code, Open WebUI…).
REQ-003 — Node Kit — reverse-proxy wrapper turning vLLM/Ollama/TGI into a conforming node: card generation, receipts, registration, self-test.
Implementation
schemas/open-node.schema.json — normative JSON Schema for the Node Card (Phase 0 deliverable).
impl/ — reference stack source (registry + fixture node +
onpCLI/gateway);npm install && npm testinimpl/.node-kit/ — Python Node Kit (REQ-003): wraps any OpenAI-compatible engine (vLLM/Ollama/TGI) into a conforming node; cross-language e2e against the JS registry.
Ecosystem
Clients and products consuming ONP — independent of the standard, listed here for discovery:
Claude Code plugin —
/plugin marketplace add opennodes-io/opennodes, then/plugin install opennodes@opennodes. Before bulk AI work it quotes the options across providers (what you use now, your own machine, checked hosts, the cheapest, an in-region one), each with a data label, and runs nothing until you choose; an agent then pilots the chosen option through the local gateway. The same behaviour for Cursor is a project rule: plugins/cursor/opennodes-quote.mdc (install line on the Integrations page).Surge (desktop client, pre-release — Windows installer; macOS and Linux build from source) — a desktop "browser for MCP" and the reference OpenNodes client: the model picker is fed live from the registry (trust tier, measured latency, price), Auto runs the advisor on your machine to pick a node per prompt, and every call is pinned to the node's card revision and comes back with a signed receipt Surge verifies. A spend policy is on from first launch, a dashboard keeps the ledger, and one click switches to private mode (local Ollama and LAN only). The first client to span both discovery layers (models via ONP, tools via MCP).

Your client here — ONP is an open standard; any client can implement discovery via ONP-3 and invocation via ONP-4. Open a PR to be listed.
Design principles
Standardize the gap, reuse the rest. ONP defines only the Node Card, the Registry API, and thin profiles binding existing standards together. Invocation is OpenAI-compatible; payment is x402/prepaid; identity is domain-based with optional DIDs; tool access is MCP.
Registry as a protocol, not a place. Like the MCP Registry, ONP specifies an OpenAPI interface any registry can implement. Anyone can run a registry; clients can query several; a root "meta-registry" is a bootstrap convenience, not an architectural requirement.
Metadata is claims + attestations. Nodes self-report; registries and third-party attesters verify (liveness probes, conformance tests, benchmark attestations as Verifiable Credentials). Rank is computed by registries from declared, transparent components — ONP standardizes the signal format, not the ranking formula.
Curated trust tiers, permissionless entry. Anyone can publish a Node Card and register (Community tier). Paid production traffic concentrates in Verified/Attested tiers — this is the lesson of Bittensor/Akash vs. OpenRouter/HF.
The client is the orchestrator. Multi-node scenarios, MCP bridging, and WebMCP access are client-side composition over standard primitives — ONP specifies the primitives and a portable scenario format, not an orchestration runtime.
Available Tools
5 toolsestimateEstimate the cost of a chainARead-onlyIdempotentInspect
Pre-price an invocation chain BEFORE spending money. Each step is either a concrete offering ("node_id/offering_id") or a select query that picks the best match, plus expected input and output tokens. Returns per-step cost bounds in USD, the pinned card_revision that makes each estimate enforceable at invocation, and chain totals. Use it to compare routes or budget a multi-model pipeline; nothing is invoked or charged.
Inputs: steps (required).
get_nodeGet one nodeARead-onlyIdempotentInspect
Who runs a node and how it has behaved: operator, country and regions, endpoints, declared hardware, trust tier and its history (verifications, suspensions, reinstatements, with reasons), recent registry probe results with an availability summary, and its offerings with context window and price. Use it to vet a provider before relying on it; take node_id from search_offerings, recommend or get_offering results. For one offering's full card, use get_offering.
Inputs: node_id (required), offering_limit.
get_offeringGet one offeringARead-onlyIdempotentInspect
Full detail for one offering: endpoints, pricing, serving capabilities (context window, supported features, languages, hardware), data policy, trust tier, and the registry's observed probe results. Take node_id and offering_id from search_offerings or recommend results.
Inputs: node_id (required), offering_id (required).
recommendRecommend a node and modelARead-onlyIdempotentInspect
Recommend the best AI node + model for a task, with an enforceable cost estimate and human-readable reasons. Use this first when you know the task but not the model. Features (task class, size, language, needs) are extracted LOCALLY from task and only those features are sent to the registry — the prompt never leaves this machine. Returns ranked candidates with score components, a cost estimate pinned to the node's card revision, an optional cheaper two-step scenario, and MCP tool categories the task likely needs. To browse instead, use search_offerings; to price a specific chain, use estimate.
Inputs: task (required), policy, est_output_tokens.
search_offeringsSearch inference offeringsARead-onlyIdempotentInspect
Search AI inference offerings in the OpenNodes registry — registered nodes AND imported catalogs (OpenRouter, Hugging Face Inference Providers, models.dev, local nodes). All filters are optional and combine with AND. Returns { offerings, total }: each offering has node_id, offering_id, model, pricing (USD per MTok), trust tier, serving capabilities, measured probe results, and a rank explanation. Use get_offering for one offering's full card, recommend to let the advisor choose.
Inputs: q, lang, sort, tier, +7 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
Each tool has a fairly distinct role: search_offerings browses, get_node and get_offering drill into details, recommend picks a model, and estimate prices a chain. The two pairs (search vs recommend, get_node vs get_offering) could be momentarily confused, but descriptions explicitly cross-reference each other ('Use get_offering for one offering's full card', 'To browse instead, use search_offerings'), which resolves most ambiguity.
Three tools follow a verb_noun pattern (search_offerings, get_node, get_offering), but estimate and recommend are bare verbs, so the convention is mixed. Names remain readable and predictable enough to guess intent, but the set is not uniformly patterned.
Five tools is well within the ideal range and each covers a distinct facet of the registry/advisory workflow: browse, node details, offering details, recommend, and estimate. Nothing appears redundant or padded, and the scope (advisory/pricing, not invocation) justifies the count.
The surface covers discovery (search_offerings), provider vetting (get_node), offering detail (get_offering), recommendation (recommend), and cost projection (estimate), which is a coherent advisory lifecycle. Minor gaps exist—no direct comparison or bulk listing tool beyond search/recommend—but agents can work around these.
Maintenance
Related MCP Connectors
Discover and execute versioned AI capabilities with worker leases and trial-credit settlement.
Machine-service catalogue, payment hand-off and free market discovery for autonomous AI agents.
Marketplace and payment rail for AI agents: list, buy and settle with signed receipts.
AI agent infrastructure for discovery, authorization, execution, identity, and signed receipts.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables listing and discovery of DePIN infrastructure capacity (storage, compute, GPU, etc.) with real USDC/USDT settlement across multiple chains.MIT
- AlicenseAqualityCmaintenanceEnables AI agents to access verifiable DePIN supply-side telemetry, browse and purchase data products using credits, query datasets, and verify data provenance with cryptographic and zero-knowledge tools.1031 npmMIT

GateCoreofficial
AlicenseNot gradedqualityCmaintenanceEnables AI agents to discover governed capabilities, inspect machine-readable contracts, and request policy-checked procurements with signed receipts and audit trails.Apache 2.0- AlicenseNot gradedqualityCmaintenanceEnables AI agents to autonomously discover services, negotiate binding quotes, make idempotent purchases, and receive cryptographically verifiable deliverables.MIT