Connect a client

Quick start

Point any MCP-speaking client at Ogen. No SDK install, no local code.

Listed on the MCP Registry as com.ogenhq/ogen, on Smithery and on Glama.

Claude Code / Cursor / any Streamable HTTP client

{
  "mcpServers": {
    "ogen": {
      "type": "http",
      "url": "https://us.ogenhq.com/api/mcp",
      "headers": { "Authorization": "Bearer ogen_sk_…" }
    }
  }
}

Claude Code in auto mode. Its permission classifier sometimes refuses an Ogen call the first time — bind_source, commit_gated_action, discover_fields, or a curl carrying your key — because a request that sends a credential to a remote host looks like exfiltration to it. The call is safe; approve it at the prompt and the retry goes through. To stop the prompts, add this to your project's .claude/settings.json (or run in the default mode):

{
  "permissions": {
    "allow": ["mcp__ogen__*"]
  }
}

Also: an MCP entry is read when a session starts, so after changing the URL or key, reconnect with /mcp or start a new session — an old session keeps talking to the old host.

Regions. us.ogenhq.com runs in Virginia, with one database. Use that host. The earlier hosts keep working: ogen.noproduct.com as an alias, and eu.ogenhq.com and ogen-eu.noproduct.com redirect to us.ogenhq.com, path kept.

A stdio-only client

Bridge through mcp-remote:

{
  "mcpServers": {
    "ogen": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://us.ogenhq.com/api/mcp", "--header", "Authorization: Bearer ogen_sk_…"]
    }
  }
}

From your framework

Every major agent framework speaks MCP, so Ogen needs no adapter of its own — point the framework's MCP client at the URL with a key (sign-in works in clients that run an OAuth flow; frameworks in code usually take a key):

OpenAI Agents SDK (Python)

from agents.mcp import MCPServerStreamableHttp

async with MCPServerStreamableHttp(
    name="ogen",
    params={"url": "https://us.ogenhq.com/api/mcp",
            "headers": {"Authorization": "Bearer ogen_sk_…"}},
) as ogen:
    agent = Agent(name="ops", instructions="…", mcp_servers=[ogen])

LangGraph / LangChain (Python, langchain-mcp-adapters)

from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "ogen": {"transport": "streamable_http",
             "url": "https://us.ogenhq.com/api/mcp",
             "headers": {"Authorization": "Bearer ogen_sk_…"}},
})
tools = await client.get_tools()   # hand these to create_react_agent(...)

Vercel AI SDK (TypeScript)

import { experimental_createMCPClient as createMCPClient } from "ai";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const ogen = await createMCPClient({
  transport: new StreamableHTTPClientTransport(new URL("https://us.ogenhq.com/api/mcp"), {
    requestInit: { headers: { Authorization: "Bearer ogen_sk_…" } },
  }),
});
const tools = await ogen.tools();   // pass to generateText / streamText

CrewAI (Python, crewai-tools)

from crewai_tools import MCPServerAdapter

with MCPServerAdapter({"url": "https://us.ogenhq.com/api/mcp",
                       "transport": "streamable-http",
                       "headers": {"Authorization": "Bearer ogen_sk_…"}}) as tools:
    agent = Agent(role="ops", goal="…", tools=tools)

Whatever the framework, the tools behave the same: a read is live, an action goes ahead only when Ogen is sure and otherwise waits for a person, and nothing is guessed. Check each framework's own docs for the current import paths.

Sign in instead of a key

Any client that speaks MCP's OAuth flow can connect with no key at all — Claude Code, Claude's custom connectors, Cursor, and any client built on the official SDKs. Add the URL alone; the client discovers where to sign in, opens a browser, and you approve with your email:

claude mcp add --transport http ogen https://us.ogenhq.com/api/mcp

In claude.ai: Settings → Connectors → Add custom connector → https://us.ogenhq.com/api/mcp. An email that already asked for a free key lands in that tenant. A first-time email gets its own free account on the spot. Holding a key already? The sign-in page lets you link its tenant instead. See Keys.

Plain HTTP instead of MCP

Every tool is also a REST door: POST https://us.ogenhq.com/v1/rest/<tool> with the same bearer key and a JSON body of the tool’s arguments, answering the same JSON the MCP tool answers. POST /v1/rest/confirm releases a hold programmatically. The full description is /v1/rest/openapi.json (OpenAPI 3.1, no key needed to read it). That file is the REST reference; there is no separate REST page. Same roles, same plan, same per-minute limits as the MCP door — it is the same handler behind both.

First call

Call recall_live_fact with { "key": "customer.acme.address" } — a demo key every new account starts with, bound to two disagreeing address records. You'll get back ambiguous with both candidates, not a pick.

Demo source

Every new tenant starts with four demo keys, already live — no bind_source call needed to try the tools:

Two demo action kinds ride along, ready for commit_gated_action: email-customer depends on customer.acme.address and is reversible; send-refund depends on order.42.status and is expensive.