MCP server

Endpoint: POST https://api.protogrid.dev/mcp, streamable HTTP, stateless (no sessions, plain JSON responses). It speaks the 2026-07-28 protocol (server/discover, the tool list cacheable for an hour) and still answers clients that open with the older initialize handshake, with the same tools. No authentication required (the registry’s own server is R0). An optional API key in X-API-Key raises the limits. The same limits as REST apply per HTTP request. GET and DELETE on /mcp answer 405.

Tools

tool	arguments	returns
search	q, limit?, class?[], transport?, category?, min_trust?, flags?[], exclude_flags?[], min_quality?, quality_flags?[], exclude_quality_flags?[], owner_verified?	the /v1/search body
get_server	name, schemas?	the descriptor
list_tools	name, limit?, cursor?	the /v1/servers/{name}/tools body
get_connection	name, target?	the /v1/servers/{name}/connection body
gate	name, min_quality?, min_trust?, no_fail?[], exclude_quality_flags?[], exclude_flags?[], class?[], owner_verified? (at least one rule)	the /v1/servers/{name}/gate body: pass or fail with every broken rule
check_server	url?, id?, wait?	the /v1/check body: pass url to check a server (waits up to 25 s by default), or id to read an earlier check

Results are returned twice: as structuredContent, described by each tool’s outputSchema, and as one text content block with the same JSON. When the REST status would be 400 or above the result has isError: true and only the text block, whose JSON carries error plus next_actions (clients check structuredContent against the output schema, so errors do not use it). next_actions[].action is a tool name and next_actions[].arguments can be passed straight back.

Add it to a client

Claude (web, desktop, mobile): add protogrid from the Claude directory, as a connector or as the protogrid plugin, which adds two skills: find-mcp-server (a task to compared candidates and a ready configuration for your client) and check-mcp-server (a server URL to quality and directory readiness, explained). The plugin’s source is public at protogrid-dev/claude-plugin.

Claude Code, with the plugin and its skills:

claude plugin marketplace add protogrid-dev/claude-plugin
claude plugin install protogrid@protogrid

Claude Code, the server only:

claude mcp add --transport http -s user protogrid https://api.protogrid.dev/mcp

Codex (~/.codex/config.toml):

[mcp_servers.protogrid]
url = "https://api.protogrid.dev/mcp"

OpenCode (opencode.json):

{ "mcp": { "protogrid": { "type": "remote", "url": "https://api.protogrid.dev/mcp", "enabled": true } } }

Any client that reads mcpServers:

{ "mcpServers": { "protogrid": { "type": "http", "url": "https://api.protogrid.dev/mcp" } } }

Cursor, VS Code and the rest are in Getting started.

Raw JSON-RPC

curl -s https://api.protogrid.dev/mcp \
  -H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"search","arguments":{"q":"send an email","class":["R0","R1"],"limit":3}}}'

Stateless mode means no initialize handshake is required for a single call, though standard clients still perform one.

With the official SDK

import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";

const client = new Client({ name: "my-agent", version: "1.0.0" }, { versionNegotiation: { mode: "auto" } }); // 2026-07-28
await client.connect(new StreamableHTTPClientTransport(new URL("https://api.protogrid.dev/mcp")));
const found = await client.callTool({ name: "search", arguments: { q: "query postgres", class: ["R0", "R1"] } });
const first = found.structuredContent.results[0];
const conn = await client.callTool({ name: "get_connection", arguments: { name: first.name } });
// conn.structuredContent.connection is the mcpServers block with ${SECRET} placeholders

The v1 package (@modelcontextprotocol/sdk, Client from @modelcontextprotocol/sdk/client/index.js) works the same way and speaks the 2025 protocol, which this server still serves.

The server’s instructions (sent on initialize) summarize the flow and the connection classes for agents that read them.