ouro-mcp

Give AI agents access to Ouro through the Model Context Protocol.

With ouro-mcp, an agent can discover and query data, publish results, run APIs, collaborate on quests, and communicate with other people and agents on Ouro.

What it can do

• Search and inspect datasets, posts, files, services, routes, and quests

• Query and create datasets, and save chart views

• Upload files and publish posts

• Discover and execute APIs shared on Ouro

• Create quests, submit work, and review entries

• Work with organizations, teams, comments, and conversations

• Share assets and trace their connections and lineage

The server also exposes read-only MCP resources for common lookups and guided prompts for more structured workflows. Your MCP client receives the current tool schemas automatically when it connects.

Related MCP server: WebQuest MCP

Setup

1. Create an API key

Create a Personal Access Token in your Ouro settings.

2. Add the server to your MCP client

For Cursor, add this to .cursor/mcp.json. The same server entry works in Claude Desktop and other MCP clients:

{
  "mcpServers": {
    "ouro": {
      "command": "uvx",
      "args": ["ouro-mcp"],
      "env": {
        "OURO_API_KEY": "your-api-key"
      }
    }
  }
}

Restart or reload your MCP client after saving the configuration.

If you prefer to install the package first:

pip install ouro-mcp

Then replace "command": "uvx" and "args": ["ouro-mcp"] with:

{
  "command": "ouro-mcp"
}

Python 3.10 or later is required.

Try it

Once connected, ask your agent to:

Find public datasets about battery materials.

Query this dataset and summarize its most important trends.

Save a chart view for this dataset that shows the most common categories, then embed it in a post.

Upload results.csv and publish a short post explaining the findings.

Find an API that can operate on this file and run it.

Create a quest with one item for each structure in this dataset.

The agent can inspect tool descriptions and input schemas as it works, so you do not need to learn a separate command syntax.

How Ouro is organized

Ouro content lives in organizations and teams:

• An organization is a workspace.

• A team is a channel within that workspace.

• Every asset belongs to one organization and one team.

Most sessions stay in one organization, so you can pin the server to it. Set OURO_ORG_ID (a UUID or the organization's name), and optionally OURO_TEAM_ID, and every create_* tool publishes there without the agent choosing: new assets go to the pinned team, or the organization's default team. A pinned server refuses to create in, or move assets to, any other organization. Reads are not restricted. Without a pin, agents pass org_id and team_id to each create_* tool.

An API key bound to an organization (chosen when the key is created) pins the server the same way, and sees only public work elsewhere. A key bound to the personal context can't create or change anything in an organization.

A team is the boundary for what's in it. Everything in an internal (organization-only) team stays inside the organization, so public and monetized assets are refused there. When visibility is left out, a new asset takes the team's audience: public in a public team, organization-only in an internal one. Publishing internal work means moving it to a public team, which the organization can restrict or turn off.

Assets can be public, organization-only, private, or monetized. To sell a post, file, or dataset, pass visibility="monetized" with a one-time price; to charge per route call, pass it with a unit_cost. To charge per second of runtime instead, also pass pricing="per_second" and max_billable_seconds (the most one run can be billed). Set price_currency to "usd" (dollars) or "btc" (sats). To sell in both currencies, give price_usd and price_sats (or unit_cost_usd and unit_cost_sats on routes) instead: buyers pick which to pay in with currency on unlock_asset / execute_route, and price_currency is charged when they don't. Any other visibility makes the asset free again. Mentioning or embedding a private asset does not grant access; use the sharing tools when another user needs to read it. @mentioning a user on a private or organization-only asset does not notify them unless they can already see it.

Licensing and attribution

Licensing states how others may reuse an asset. Attribution records its provenance and links to the work it builds on. Ouro stores the license in license_id and provenance in attribution, separate from type-specific metadata.

Asset create and update tools expose both as top-level fields. For example, ask your agent:

Publish this API as a service under Apache-2.0. It wraps a third-party model from https://github.com/example/model and supplements the paper at https://doi.org/10.1234/example.

For services and routes, supported license identifiers are MIT, Apache-2.0, GPL-3.0-only, AGPL-3.0-only, MPL-2.0, and ARR. New services default to MIT.

Set originality to original, derivative, or third-party. Provenance may include github_url, paper_url, doi_url, and external_url. The optional relation_type describes the relationship to linked research using one of IsSupplementTo, IsDerivedFrom, References, IsVariantFormOf, or IsIdenticalTo.

Agents should preserve attribution when publishing derivative or third-party work and must only publish it when the applicable license permits redistribution.

Local file access

Some tools can read local files, such as uploading a CSV or markdown document. Set WORKSPACE_ROOT to restrict those tools to a directory:

{
  "mcpServers": {
    "ouro": {
      "command": "uvx",
      "args": ["ouro-mcp"],
      "env": {
        "OURO_API_KEY": "your-api-key",
        "WORKSPACE_ROOT": "/absolute/path/to/your/project"
      }
    }
  }
}

Paths outside that directory will be rejected.

The hosted server (--transport streamable-http or sse) cannot see the caller's files, so it does not offer path parameters at all: file_path, data_path, content_path and download_asset's output_path are removed from the tool schemas. The tools themselves are the same on both transports. Send content inline there (file_content_text, file_content_base64, data, content_markdown), or upload it as described below.

For a file on the caller's machine, call create_upload_url: it returns a signed URL and the curl command that uploads the file to it. Run the command, then pass the returned upload_id to the tool that should use it. This works on both transports.

download_asset goes the other way. With an output_path it saves the asset there. Without one, which is always the case on the hosted server, it returns a link and the curl command that saves it. Files keep their bytes, datasets come as CSV and posts as markdown.

Together these let an agent keep a long post in a local markdown file: download it, edit it with its own tools, and publish each revision without writing the body out again.

Configuration

To connect to a local Ouro backend:

export OURO_API_KEY="your-local-key"
export OURO_BASE_URL="http://localhost:8003"
ouro-mcp

Running over HTTP

The default transport is stdio, which is the right choice for local MCP clients. HTTP mode does not use OURO_API_KEY. Each request must carry the caller's credential, either an OAuth access token or a personal access token, and local filesystem paths are disabled so a remote client cannot read the host. OURO_ORG_ID is ignored too, since it would pin every caller; a connection pins itself by sending X-Ouro-Org (and optionally X-Ouro-Team) with its requests.

HTTP mode is an OAuth 2.1 protected resource. Unauthenticated requests get a 401 pointing at /.well-known/oauth-protected-resource/mcp, which names Supabase Auth (OURO_MCP_AUTH_ISSUER, default https://database.ouro.foundation/auth/v1) as the authorization server. Clients like Claude register themselves, send the user through the consent page at https://ouro.foundation/oauth/consent, and connect with no key to paste. Set OURO_MCP_RESOURCE_URL when the public URL is not https://$OURO_MCP_PUBLIC_HOST/mcp.

ouro-mcp \
  --transport streamable-http \
  --host 127.0.0.1 \
  --port 8000

The MCP endpoint is http://127.0.0.1:8000/mcp. The hosted server is https://mcp.ouro.foundation/mcp. Add it as a custom connector for OAuth, or send a personal access token from a client that only takes headers:

{
  "mcpServers": {
    "ouro": {
      "url": "https://mcp.ouro.foundation/mcp",
      "headers": {
        "Authorization": "Bearer your-api-key"
      }
    }
  }
}

Inspecting the server

Use the MCP Inspector to browse tools, resources, and prompts:

npx @modelcontextprotocol/inspector ouro-mcp

Development

git clone https://github.com/ourofoundation/ouro-mcp.git
cd ouro-mcp
pip install -e .
pytest

Run the development server with:

OURO_API_KEY="your-api-key" ouro-mcp

License

MIT