sc-mcp

Connect your Scalable Capital brokerage to any MCP-capable assistant. This server is a thin, read-friendly wrapper around Scalable Capital's official sc CLI — agents get your portfolio, trades, analytics, quotes, charts, watchlist and alerts with the same pieces of config across Claude Code, Claude Desktop, Codex, Cursor and VS Code.

Features

• Live broker data — overview, holdings, transactions, analytics, cash breakdown, performance charts, quotes, security news.

• Portfolio management extras — watchlist, price alerts, portfolio groups and savings-plan config.

• Fast by default — read responses are cached in a SQLite file (survives restarts, see Configuration).

• Safety first — no trades, no orders. Write tools are off unless you opt in; money-moving commands are absent by design.

• Runs anywhere — plain stdio for desktop clients, HTTP for remote access, or a fully self-contained Docker image.

[!Warning] Unofficial. A community wrapper around Scalable Capital's sc CLI — not affiliated with or endorsed by Scalable Capital. A stopgap until a first-party MCP server exists, and likely to be retired once it does.

No warranty. Provided "as is" under the MIT License; no responsibility for loss, damage, incorrect data or any financial consequence. Not financial advice — verify anything you act on.

Tools

Read-only tools hit the broker live; successful responses are cached for 5 minutes (configurable) in a SQLite file that survives restarts.

⚠️ = requires SC_MCP_ENABLE_WRITES=true, off by default.

The sc CLI also exposes trade and savings-plans add/remove. Those are deliberately not exposed — money-moving commands are out of scope entirely (the write tools above only touch watchlists, alerts and groups).

Quick start

Pick one path — all three end with a working server:

Claude Code plugin

/plugin marketplace add NinjaEde/mcp-scalable-capital
/plugin install sc-mcp

That registers the scalable-capital MCP server and a skill that tells Claude when and how to use the tools.

uvx one-liner

uvx --from git+https://github.com/NinjaEde/mcp-scalable-capital@v0.2.0 sc-mcp

Point any MCP client at that command (sc-mcp started stdio, pin the tag per Versioning).

Requirements

1. uv on PATH — skip this with Docker.

2. The sc CLI on PATH (see Authentication).

3. An authenticated session: sc login (see Authentication).

Docker bundles both the CLI and this server, so the only manual step there is the login below.

Authentication

Every sc_* tool shells out to Scalable Capital's official sc CLI, which must be installed and logged in once per machine (or per Docker volume).

Install the CLI

macOS (Homebrew):

brew install scalablecapital/tap/scalable-cli

Linux (also the binary baked into the Docker image): download the official build for your architecture and put sc on PATH:

ARCH=$(uname -m)   # x86_64 or aarch64
curl -fSL "https://github.com/ScalableCapital/scalable-cli/releases/download/v0.6.0/sc-v0.6.0-linux-${ARCH}-gnu.tar.gz" -o /tmp/sc.tar.gz
tar xzf /tmp/sc.tar.gz -C /tmp
sudo install -m 0755 /tmp/sc-v0.6.0-linux-${ARCH}-gnu/sc /usr/local/bin/sc

Verify:

sc --version   # e.g. "sc 0.6.0"

Log in (once)

sc login       # device flow: open the printed URL, confirm, done
sc whoami      # confirm the session works

If a tool later reports "session may have expired — try sc login", just re-run sc login.

Where the session lives

~/.config/scalable-cli/:

Headless / keyring-less environments (Docker, CI, servers): the CLI defaults to the OS keyring. Where none exists, point it at a plain file (the Docker image does this for you in docker/entrypoint.sh):

# ~/.config/scalable-cli/config.toml
[auth]
session_backend = "file"

Then run sc login again — the session lands in session.json and persists across restarts.

Tip: reuse a host session inside containers instead of logging in twice:

docker cp ~/.config/scalable-cli/session.json sc-mcp:/home/sc/.config/scalable-cli/session.json
docker compose restart

Treat that file like a password — never commit it.

Integrating with clients

Claude Code (manual)

claude mcp add scalable-capital -- uvx --from git+https://github.com/NinjaEde/mcp-scalable-capital@v0.2.0 sc-mcp

Cursor

Add to Cursor — or add to .cursor/mcp.json (or ~/.cursor/mcp.json):

{
  "mcpServers": {
    "scalable-capital": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/NinjaEde/mcp-scalable-capital@v0.2.0", "sc-mcp"]
    }
  }
}

Codex

Add to ~/.codex/config.toml:

[mcp_servers.scalable-capital]
command = "uvx"
args = ["--from", "git+https://github.com/NinjaEde/mcp-scalable-capital@v0.2.0", "sc-mcp"]

Claude Desktop (bundle, no config editing)

Download sc-mcp.mcpb, then in Claude Desktop go to Settings → Extensions → Install Extension and pick the file.

[!Note] If Claude Desktop can't find uvx, open the extension's settings and set the full path (e.g. /opt/homebrew/bin/uvx). GUI apps on macOS don't always inherit your shell PATH.

VS Code / other MCP clients

{
  "mcpServers": {
    "scalable-capital": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/NinjaEde/mcp-scalable-capital@v0.2.0", "sc-mcp"]
    }
  }
}

Pin the @v0.2.0 tag (see Versioning). Drop it to track the latest main.

Docker

The whole stack — this server and the sc CLI — runs in containers, so you only need Docker (no local uv, Python, or sc):

docker compose up -d --build              # build + start on http://localhost:8000/mcp
docker compose run --rm sc-login          # first time only — interactive device flow

The session is stored in the sc-cli-config volume and survives restarts. Writes stay off unless you set SC_MCP_ENABLE_WRITES: "true" in docker-compose.yml.

Point any HTTP-capable MCP client at the server URL:

{
  "mcpServers": {
    "scalable-capital": {
      "type": "http",
      "url": "http://localhost:8000/mcp"
    }
  }
}

The container talks to scalable.capital directly. The device-flow URL from sc login works the same as on your host; just follow it in a browser. The image already ships the session_backend = "file" config (see Authentication).

Compatibility

Tested against sc 0.6.x. The CLI is pre-1.0 and its command surface can change between minor versions; the server logs a warning to stderr at startup if your installed sc differs from the tested major.minor. sc is an external binary, not a Python dependency, so that's the only enforcement available. If you see the warning and a tool misbehaves, the mismatch is the likely cause.

Configuration

Develop

uv sync
uv run sc-mcp          # starts the stdio server
# or
SC_MCP_TRANSPORT=streamable-http uv run sc-mcp
uv run pytest

How to stay in sync with sc (when to add/update tools, bump SUPPORTED_SC_VERSION, read-only invariants) is documented in CLAUDE.md.

Versioning

SemVer — the tools are the public API:

Releases are tagged vX.Y.Z; pin a tag when installing via uvx --from git+..., which otherwise tracks the default branch and can change your tool surface under you. Most bumps are driven by sc CLI changes (see Compatibility); the version is this package's own, not the sc version.

License

MIT