sc-mcp

Verbinden Sie Ihr Scalable Capital-Depot mit jedem MCP-fähigen Assistenten. Dieser Server ist ein schlanker, lesefreundlicher Wrapper um Scalable Capitals offizielles sc-CLI – Agenten erhalten Ihr Portfolio, Trades, Analysen, Kurse, Charts, Watchlist und Alarme mit den gleichen Konfigurationsstücken in Claude Code, Claude Desktop, Codex, Cursor und VS Code.

Funktionen

• Live-Brokerdaten – Überblick, Bestände, Transaktionen, Analysen, Geldaufteilung, Performance-Charts, Kurse, Sicherheitsnachrichten.

• Portfolio-Management-Extras – Watchlist, Preisalarme, Portfoliogruppen und Sparplan-Konfiguration.

• Standardmäßig schnell – Leseantworten werden in einer SQLite-Datei zwischengespeichert (überlebt Neustarts, siehe Konfiguration).

• Sicherheit zuerst – keine Trades, keine Aufträge. Schreibwerkzeuge sind nur nach Zustimmung aktiv; geldbewegende Befehle sind bewusst nicht vorhanden.

• Läuft überall – einfaches stdio für Desktop-Clients, HTTP für den Fernzugriff oder ein vollständig eigenständiges Docker-Image.

[!Warnung] Inoffiziell. Ein Community-Wrapper um Scalable Capitals sc-CLI – nicht mit Scalable Capital verbunden oder von ihnen empfohlen. Ein Provisorium, bis ein offizieller MCP-Server existiert, und wird wahrscheinlich eingestellt, sobald dies der Fall ist.

Keine Garantie. Bereitgestellt „wie besehen“ unter der MIT-Lizenz; keine Haftung für Verlust, Schäden, fehlerhafte Daten oder finanzielle Konsequenzen. Keine Finanzberatung – überprüfen Sie alles, worauf Sie reagieren.

Werkzeuge

Nur-Lese-Werkzeuge greifen live auf den Broker zu; erfolgreiche Antworten werden für 5 Minuten (konfigurierbar) in einer SQLite-Datei zwischengespeichert, die Neustarts überlebt.

⚠️ = erfordert SC_MCP_ENABLE_WRITES=true, standardmäßig deaktiviert.

Das sc-CLI bietet auch trade und savings-plans add/remove. Diese werden bewusst nicht bereitgestellt – geldbewegende Befehle liegen vollständig außerhalb des Rahmens (die obigen Schreibwerkzeuge betreffen nur Watchlists, Alarme und Gruppen).

Schnellstart

Wählen Sie einen Pfad – alle drei enden mit einem funktionierenden Server:

Claude Code Plugin

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

Das registriert den scalable-capital MCP-Server und eine Fähigkeit, die Claude sagt, wann und wie die Werkzeuge zu verwenden sind.

uvx Einzeiler

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

Richten Sie jeden MCP-Client auf diesen Befehl (sc-mcp startet stdio, fixieren Sie den Tag pro Versionierung).

Voraussetzungen

1. uv im PATH – überspringen Sie dies mit Docker.

2. Das sc CLI im PATH (siehe Authentifizierung).

3. Eine authentifizierte Sitzung: sc login (siehe Authentifizierung).

Docker bündelt sowohl das CLI als auch diesen Server, sodass der einzige manuelle Schritt dort das untenstehende Login ist.

Authentifizierung

Jedes sc_*-Werkzeug ruft das offizielle sc-CLI von Scalable Capital auf, das pro Maschine (oder pro Docker-Volume) installiert und einmal eingeloggt sein muss.

CLI installieren

macOS (Homebrew):

brew install scalablecapital/tap/scalable-cli

Linux (auch das Binary, das im Docker-Image enthalten ist): Laden Sie den offiziellen Build für Ihre Architektur herunter und legen Sie sc in den 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

Überprüfen:

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

Einmal anmelden

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

Wenn ein Werkzeug später meldet „Sitzung möglicherweise abgelaufen – versuchen Sie sc login“, führen Sie einfach sc login erneut aus.

Wo die Sitzung gespeichert ist

~/.config/scalable-cli/:

Kopflose / Keyring-lose Umgebungen (Docker, CI, Server): Das CLI verwendet standardmäßig den OS-Keyring. Wenn keiner existiert, leiten Sie es auf eine einfache Datei um (das Docker-Image macht dies für Sie in docker/entrypoint.sh):

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

Führen Sie dann erneut sc login aus – die Sitzung landet in session.json und bleibt über Neustarts hinweg erhalten.

Tipp: Verwenden Sie eine Host-Sitzung in Containern wieder, anstatt sich zweimal anzumelden:

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

Behandeln Sie diese Datei wie ein Passwort – niemals einchecken.

Integration in Clients

Claude Code (manuell)

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

Cursor

Zu Cursor hinzufügen — oder zu .cursor/mcp.json (oder ~/.cursor/mcp.json) hinzufügen:

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

Codex

Zu ~/.codex/config.toml hinzufügen:

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

Claude Desktop (Bundle, keine Konfigurationsbearbeitung)

Laden Sie sc-mcp.mcpb herunter, dann in Claude Desktop gehen Sie zu Einstellungen → Erweiterungen → Erweiterung installieren und wählen die Datei aus.

[!Hinweis] Wenn Claude Desktop uvx nicht finden kann, öffnen Sie die Erweiterungseinstellungen und setzen Sie den vollständigen Pfad (z. B. /opt/homebrew/bin/uvx). GUI-Apps unter macOS erben nicht immer Ihren Shell-PATH.

VS Code / andere MCP-Clients

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

Fixieren Sie den Tag @v0.2.0 (siehe Versionierung). Lassen Sie ihn weg, um dem neuesten main zu folgen.

Docker

Der gesamte Stack – dieser Server und das sc-CLI – laufen in Containern, sodass Sie nur Docker benötigen (kein lokales uv, Python oder 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

Die Sitzung wird im Volume sc-cli-config gespeichert und überlebt Neustarts. Schreibzugriffe bleiben deaktiviert, es sei denn, Sie setzen SC_MCP_ENABLE_WRITES: "true" in docker-compose.yml.

Richten Sie jeden HTTP-fähigen MCP-Client auf die Server-URL:

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

Der Container kommuniziert direkt mit scalable.capital. Die Device-Flow-URL von sc login funktioniert genauso wie auf Ihrem Host; folgen Sie ihr einfach in einem Browser. Das Image enthält bereits die Konfiguration session_backend = "file" (siehe Authentifizierung).

Kompatibilität

Getestet mit sc 0.6.x. Das CLI ist vor 1.0 und seine Befehlsoberfläche kann sich zwischen Minor-Versionen ändern; der Server protokolliert beim Start eine Warnung auf stderr, wenn Ihr installiertes sc von der getesteten Major.Minor abweicht. sc ist ein externes Binary, keine Python-Abhängigkeit, daher ist dies die einzige mögliche Durchsetzung. Wenn Sie die Warnung sehen und ein Werkzeug sich falsch verhält, ist die Abweichung die wahrscheinliche Ursache.

Konfiguration

Entwickeln

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

Wie Sie mit sc synchron bleiben (wann Werkzeuge hinzugefügt/aktualisiert werden, SUPPORTED_SC_VERSION erhöht, Nur-Lese-Invarianten) ist in CLAUDE.md dokumentiert.

Versionierung

SemVer – die Werkzeuge sind die öffentliche API:

Releases werden mit vX.Y.Z getaggt; fixieren Sie einen Tag bei der Installation über uvx --from git+..., da dies sonst dem Standard-Branch folgt und Ihre Werkzeugoberfläche unter Ihnen ändern kann. Die meisten Erhöhungen werden durch Änderungen des sc-CLI verursacht (siehe Kompatibilität); die Version ist die dieses Pakets, nicht die sc-Version.

Lizenz

MIT