MCP server

Otis runs a remote MCP server per project. Any coding agent that speaks Model Context Protocol can connect to it, read live project state, and use Otis's reference material directly. Cursor is supported end-to-end via the setup script; other MCP clients can connect manually.

If you're on Claude Code, use the Claude Code skills — they're built on the same MCP server and bundle step-by-step workflows. If you'd rather Otis drive instrumentation automatically, use the GitHub App.

What the MCP server exposes

Three kinds of MCP surface, available to any connected agent:

Tools — live project state:

Tool	What it does
`getProjectMemories`	Read codebase profile, per-measurement state, declared span mappings
`searchProjectMemories`	Semantic search across your Otis project
`saveProjectMemory`	Write profile, measurement state, or span mappings back
`removeProjectMemory`	Delete an entry
`getIngestionHealth`	Check whether spans are arriving from prod or dev in the last 24 hours

Prompts — dynamic project context:

Prompt	Contents
`lens-catalog`	The list of measurements available to your project, with active ones marked

Resources — reference material:

Resource	Contents
`otis://integration-guide`	SDK installation and configuration
`otis://sdk/{slug}`	SDK reference pages (tracing, nextjs, feedback, identity, serverless, etc.)
`otis://memory-taxonomy`	Conventions for writing back to your Otis project
`otis://lens-parameter-schema/{lensId}`	Parameter schema for a lens

Endpoint

https://app.runotis.com/mcp/{team-slug}/{project-slug}

Auth is Clerk OAuth. Agents that support MCP OAuth natively (Claude Code, Cursor) handle this automatically — you sign in with the same credentials you use for the Otis dashboard. There are no API keys to manage.

Cursor

npx @runotis/setup --agent cursor --team <team-slug> --project <project-slug>

Writes:

.cursor/mcp.json pointing at your Otis project.
.cursor/rules/otis-{analyze,instrument,verify,status}.mdc — the same four workflows as the Claude Code skills, in Cursor's rule-file format.
.otis-cache/docs/ with prefetched SDK and measurement reference material.

Re-run with --refresh to pull the latest rules and docs.

The four workflows mirror what's described on the Claude Code skills page — analyze, instrument, verify, status. Cursor invokes them as rules rather than slash commands, but the behaviour is the same.

Other MCP clients

Any client that can be pointed at an MCP URL will work. Manual setup:

Add the endpoint to your client's MCP config, for example:

{
  "mcpServers": {
    "otis": {
      "url": "https://app.runotis.com/mcp/<team-slug>/<project-slug>"
    }
  }
}

Sign in when your client prompts for Otis OAuth.
Your agent now has access to the tools, prompts, and resources listed above.

MCP alone isn't a workflow

The MCP server gives your agent data and reference material. It does not include step-by-step workflow orchestration — that's what the skill files (Claude Code) and rule files (Cursor) add on top.

If your agent supports a rule / instructions file convention, you can adapt the workflow content to it: the canonical source is in the @runotis/instrumentation-content package, and the Cursor .mdc files are a concrete example of that content rendered for a specific agent format.

If your agent doesn't have an equivalent concept, you have two options:

Drive the workflow yourself. Paste the steps into context one at a time: "profile the codebase and save the result via saveProjectMemory", then "for each measurement the lens-catalog prompt recommends, read the reference doc and add instrumentation", and so on.
Use Claude Code or Cursor for instrumentation. Once the instrumentation PR has landed, you can go back to your primary agent for ongoing development. The MCP server stays connected and your primary agent can still read and update project state.

Auth for clients that don't support MCP OAuth

API key auth for MCP isn't offered today. If your agent requires a different auth scheme and OAuth isn't an option, contact us.

What gets written to your repo (Cursor)

.cursor/mcp.json — points at your Otis project. Commit this.
.cursor/rules/otis-*.mdc — the four workflows. Commit these.
.otis-cache/docs/ — prefetched reference. Gitignored; regenerate with npx @runotis/setup --agent cursor.

Working alongside the other paths

The MCP server is the same backend all three instrumentation paths share. Whether you start with the GitHub App, Claude Code skills, or a manual MCP client, changes propagate to the same project state. You can mix paths: start with the GitHub App for initial instrumentation, refine from Cursor, check status from any other MCP client.

MCP server

On this page