okama-mcp

MCP (Model Context Protocol) server that exposes the okama investment portfolio toolkit and okama Planner to AI assistants — Claude Desktop, Claude Code, Cursor, Codex, and any other MCP-compatible client.

With okama-mcp installed, you can ask an AI things like:

"Backtest a portfolio of 30% gold and 70% real estate over the last 15 years."

"Run a Monte Carlo retirement forecast on that portfolio, withdrawing $1,000/month indexed to inflation, over 25 years."

"What's the tangency portfolio of SPY, BND, and GLD with a 3% risk-free rate?"

…and the AI uses the MCP tools to call okama directly — no Python code needed.

Built on FastMCP. Single codebase, two transports: stdio (for local clients) and streamable-http (for self-hosting). okama-mcp is free and open source. Run it locally or on your own server. The HTTP transport is intended for self-hosting; mcp.okama.io serves the project landing page, not a public MCP endpoint. Client registry tools and Excel exports require a compatible Planner companion and a configured local stdio installation.

Install

Requires Python ≥ 3.11 (same floor as okama itself); okama ≥ 4.0.0 and okama Planner 0.4.x (with report dependencies) are installed automatically.

3.0 upgrade: client identity intake through MCP has been removed. Names and contacts belong in Planner's human-operated local intake. The currently published Planner 0.4.1 lacks okama_planner.ai, so standard installs expose 50 market, portfolio, financial-plan and chart tools, without the two household Planner tools or local client/report integrations. Those integrations fail closed until a compatible companion is published; see compatibility issue #6 and the 3.0 migration notes. Core finplan_* tools use okama directly and remain available.

The easiest way — no clone, no venv — is uv or pipx:

uvx okama-mcp stdio          # run straight from PyPI
# or
pipx install okama-mcp

Plain pip works too:

pip install okama-mcp

To work on the code, install from source instead:

git clone https://github.com/mbk-dev/okama-mcp
cd okama-mcp
poetry install

Run

# stdio — for Claude Desktop, Claude Code, Cursor (local IPC)
okama-mcp stdio

# streamable HTTP — for self-hosting on your own server
okama-mcp http --host 127.0.0.1 --port 8765

When running from a source checkout, prefix each command with poetry run.

Connect a client

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "okama": {
      "command": "uvx",
      "args": ["okama-mcp", "stdio"]
    }
  }
}

Restart Claude Desktop; the server appears in the tools menu.

Claude Code

To make the server available in every project (works from any directory):

claude mcp add --scope user okama -- uvx okama-mcp stdio

Developers running from a source checkout can use claude mcp add okama -- poetry run okama-mcp stdio from the project root instead.

Or commit a .mcp.json at the project root so the whole team picks it up:

{
  "mcpServers": {
    "okama": {
      "command": "uvx",
      "args": ["okama-mcp", "stdio"]
    }
  }
}

Cursor

Add the server to .cursor/mcp.json in your project (or ~/.cursor/mcp.json to make it global):

{
  "mcpServers": {
    "okama": {
      "command": "uvx",
      "args": ["okama-mcp", "stdio"]
    }
  }
}

Codex (CLI & Desktop)

Add the server with one command:

codex mcp add okama -- uvx okama-mcp stdio

Or declare it in ~/.codex/config.toml (or a project-scoped .codex/config.toml in trusted projects):

[mcp_servers.okama]
command = "uvx"
args = ["okama-mcp", "stdio"]

The Codex CLI, desktop app, and IDE extension share this configuration — set it up once and it works in all three.

Self-hosting (streamable HTTP)

Run okama-mcp on your own server and share it across your MCP clients:

okama-mcp http --host 127.0.0.1 --port 8765 --path /mcp

(From source: poetry run okama-mcp http ...)

Then point your MCP client at http://<your-server>:8765/mcp. For a production setup put nginx + TLS in front; ready-made examples live in deploy/:

• deploy/systemd/okama-mcp.service — systemd unit (hardened, runs as a dedicated user)
• deploy/nginx/self-hosted.conf — nginx vhost: TLS, SSE-friendly proxying of /mcp

The server is open by design — free to run, no registration. If your instance must not be public, restrict access at the nginx level (allow-list, VPN, or HTTP basic auth).

Tool catalog

A multi-stage financial plan (contribute $1,000/month for 20 years into a 70/30 SPY/AGG portfolio, then withdraw $6,000/month indexed to inflation for 25 years), a Monte Carlo retirement forecast (30% gold / 70% real estate, withdrawing $1,000/month indexed to inflation over 25 years) and the efficient frontier of SPY/BND/GLD:

Financial tools are stateless — pass the full portfolio specification with every call. Optional local client tools use explicit stable registry codes and persistent creation request IDs. The server caches expensive okama objects (Portfolio, EfficientFrontier) by content hash, so repeated calls on the same spec are fast.

Nested portfolios. Wherever a list of assets is accepted — the assets field of PortfolioSpec/FrontierSpec, or the portfolios argument on the comparison tools — an entry may be a ticker string or a nested portfolio object (the same spec shape). This lets you treat a whole portfolio as a single component: e.g. compare a 60/40 portfolio against gold, or put a sub-portfolio on the efficient frontier.

Search & metadata

Single asset & comparisons

Portfolio backtest

Monte Carlo DCF

The mc argument accepts distribution_parameters to override the fitted distribution (e.g. a fixed Student-t df); see the MCSpec shape below.

Financial plan (multi-stage)

A plan is an ordered sequence of stages, each with its own portfolio, horizon and cash-flow regime. Scenarios are chained: the balance a Monte Carlo scenario ends a stage with is the balance it starts the next one with, so the retirement stage is funded by whatever the accumulation stage produced in that same scenario — not by a percentile of it. Use these instead of monte_carlo_forecast whenever the portfolio or the contribution/withdrawal regime changes partway through the horizon.

Distribution diagnostics

DCF (historical cash-flow analysis)

Efficient Frontier

Macro

Charts

Each tool renders a PNG (default 1500×900) and returns it as MCP image content — clients like Claude Desktop display it inline. Every chart tool also accepts optional width / height (pixels, 300–4000) for custom sizes and aspect ratios, and an optional save_path — the chart is then also written to that file and the path reported back. Use save_path in clients that don't render MCP images in their UI (e.g. Claude Code's terminal): ask for a chart "saved to /tmp/chart.png" and open the file reference. Note: in self-hosted (streamable-http) deployments save_path is written on the server's filesystem, not the client's machine.

Finding symbols and choosing tools

Start with list_namespaces(): its original namespaces description mapping is preserved, and usage explains what each namespace supports. Use search_assets(namespace="INDX") to browse an index catalog, or search_assets(query="bitcoin", namespace="CC") for cryptocurrencies. Search rows include namespace and supports_asset_returns (null when unknown).

Search is case-insensitive; exact symbol/ticker/ISIN matches rank first, then exact names, prefixes and other matches. Scoped queries match punctuation literally. With oldest_first=true, date order takes precedence. Symbol order breaks ties. Results are ordered before paging: repeat the same query and filters with offset=next_offset until has_more=false. count describes all filtered matches; truncated means the current page is not the entire result set, including the last page of a multi-page result. Pages reflect the current catalog, so data updates between calls can move page boundaries.

RATE, INFL and RATIO are macroeconomic series. Read their values and metadata with get_central_bank_rate, get_inflation and get_indicator, respectively. For example, RUS_RUB.RATE describes a deposit rate, whereas OKID.INDX is an investment-return index: they are different inputs. Asset tools reject a macro symbol with the appropriate next call; they never replace it with an index. Discover the intended index separately before comparing returns. Unknown upstream namespaces have no advertised MCP routes until support is implemented.

Spec shapes

The complex tools accept JSON objects described by complete Pydantic-generated input schemas in MCP tools/list: nested fields, required values, constraints, defaults and cash-flow variants are visible to the client. Definitions live in src/okama_mcp/schemas.py; here are the headline shapes:

// PortfolioSpec
{
  "assets":   ["GLD.US", "VNQ.US"],  // each entry: a ticker OR a nested PortfolioSpec
  "weights":  [0.3, 0.7],            // optional, must sum to 1.0
  "ccy":      "USD",
  "first_date": "2010-01",
  "last_date":  "2024-12",
  "rebalancing_strategy": {            // mirrors okama.Rebalance
    "period": "year",                  // month | quarter | half-year | year | none
    "abs_deviation": 0.05,             // optional, |actual - target| threshold, 0 < x <= 1
    "rel_deviation": 0.1               // optional, |actual / target - 1| threshold, > 0
  },
  "inflation": true
}

// MCSpec
{
  "distribution":  "norm",            // norm | lognorm | t
  "period_years":  25,
  "scenarios":     500,                // ≥ 1, no upper limit
  "percentiles":   [5, 50, 95],
  "random_seed":   42,                 // optional, for reproducibility
  "distribution_parameters": null      // optional; null = fit from history (MLE). Lengths: norm [mu, sigma]; lognorm/t [shape|df, loc, scale]. Any element null = fit that one (e.g. [4, null, null])
}

// CashflowSpec — discriminated by `type`
{ "type": "indexation",       "initial_investment": 1000000, "frequency": "month", "amount": -1000, "indexation": "inflation" }
{ "type": "percentage",       "initial_investment": 1000000, "frequency": "year",  "percentage": -0.04 }
{ "type": "time_series",      "initial_investment": 100000,  "events":    { "2030-06": -50000 }, "time_series_discounted_values": false }
{ "type": "vanguard",         "initial_investment": 1000000, "percentage": -0.04, "floor_ceiling": [-0.025, 0.05], "indexation": "inflation" }
{ "type": "cut_if_drawdown",  "initial_investment": 1000000, "frequency": "year",  "amount": -60000, "indexation": "inflation",
  "crash_threshold_reduction": [[0.2, 0.4], [0.5, 1.0]] }

// FinPlanSpec — a plan is a sequence of stages, chained per scenario
{
  "stages": [
    { "portfolio": { "assets": ["SPY.US", "AGG.US"], "weights": [0.7, 0.3] },
      "period_years": 20, "name": "accumulation",
      "cashflow": { "type": "indexation", "initial_investment": 100000, "frequency": "year", "amount": 12000, "indexation": 0.03 } },
    { "portfolio": { "assets": ["SPY.US", "AGG.US"], "weights": [0.3, 0.7] },
      "period_years": 25, "name": "retirement",
      "distribution": "t", "distribution_parameters": [5, null, null],
      "cashflow": { "type": "percentage", "initial_investment": 100000, "frequency": "year", "percentage": -0.04 } }
  ],
  "initial_investment": 100000,       // balance the first stage starts with
  "discount_rate": null,               // optional; null lets okama use inflation
  "scenarios": 500,
  "random_seed": 42,                   // optional
  "percentiles": [10, 50, 90],
  "name": "retirement plan"
}

// FrontierSpec
{
  "assets":   ["SPY.US", "BND.US", "GLD.US"],
  "ccy":      "USD",
  "bounds":   [[0.0, 0.7], [0.1, 1.0], [0.0, 0.3]],   // optional
  "n_points": 20,
  "rebalancing_strategy": { "period": "year" },
  "inflation": false
}

// Nesting — a portfolio used as a single component (works in PortfolioSpec /
// FrontierSpec `assets`, and the `portfolios` argument of the comparison tools):
{
  "assets": [
    "GLD.US",
    { "assets": ["SPY.US", "AGG.US"], "weights": [0.6, 0.4], "symbol": "bench6040.PF" }
  ],
  "weights": [0.3, 0.7]              // one weight per top-level entry
}

Development

The project follows TDD (see AGENTS.md). After every code change run:

poetry run pytest -q
poetry run ruff check .

To run the live-API integration test (hits api.okama.io):

poetry run pytest -m integration

Project layout

src/okama_mcp/
├── server.py          # FastMCP instance + registration entry point
├── transport.py       # CLI: `okama-mcp stdio | http`
├── schemas.py         # PortfolioSpec, MCSpec, CashflowSpec, FrontierSpec, FinPlanSpec
├── cache.py           # TTL+LRU cache keyed by sha256 of canonical spec
├── serialization.py   # pandas → JSON-safe with smart truncation
├── errors.py          # Translate okama exceptions to actionable MCP errors
└── tools/
    ├── search.py, asset.py, asset_list.py
    ├── portfolio.py, monte_carlo.py, finplan.py
    ├── frontier.py, macro.py
    └── plots.py

License

MIT — same license as okama itself.

Planner and local client workflows

Planner tools require a companion release providing okama_planner.ai. Older companions fail closed: household tools stay unavailable rather than exposing raw records. Market tools remain available. Local stdio configuration can enable nine client-code tools and Excel export; HTTP has no client or local report tools.

Names and contacts are entered locally by a human into Planner. MCP has no client_create tool, and the former packaged intake skill is retired. Client reads contain pseudonyms; updates accept only sex, birth_year and ips_sent_at. Planner owns database access, versioned plan writes and anonymization of free text. Forecasts carry a privacy proof; report export verifies it and returns only an opaque artifact filename. Tool errors contain fixed messages without private values, database details or filesystem paths.

See configuration and tool contracts and language behavior.

Explore the okama family

Tools for investing and financial planning.

Join the okama community →

Ask questions, share examples and discuss financial planning.