sc-mcp

Conecta tu bróker de Scalable Capital a cualquier asistente compatible con MCP. Este servidor es un envoltorio ligero y de solo lectura alrededor de la CLI oficial sc de Scalable Capital: los agentes obtienen tu cartera, operaciones, analíticas, cotizaciones, gráficos, lista de seguimiento y alertas con la misma configuración en Claude Code, Claude Desktop, Codex, Cursor y VS Code.

Funciones

• Datos del bróker en vivo — resumen, posiciones, transacciones, analíticas, desglose de efectivo, gráficos de rendimiento, cotizaciones, noticias de valores.

• Extras de gestión de cartera — lista de seguimiento, alertas de precios, grupos de cartera y configuración de planes de ahorro.

• Rápido por defecto — las respuestas de lectura se cachean en un archivo SQLite (sobrevive a reinicios, ver Configuración).

• Seguridad ante todo — sin operaciones, sin órdenes. Las herramientas de escritura están desactivadas salvo que optes por activarlas; los comandos que mueven dinero están ausentes por diseño.

• Funciona en cualquier lugar — stdio simple para clientes de escritorio, HTTP para acceso remoto, o una imagen Docker totalmente autónoma.

[!Warning] Extraoficial. Un envoltorio comunitario alrededor de la CLI sc de Scalable Capital — no afiliado ni respaldado por Scalable Capital. Un parche provisional hasta que exista un servidor MCP oficial, y probablemente se retirará cuando llegue.

Sin garantía. Proporcionado "tal cual" bajo la Licencia MIT; sin responsabilidad por pérdidas, daños, datos incorrectos o cualquier consecuencia financiera. No es asesoramiento financiero: verifica cualquier cosa antes de actuar.

Herramientas

Las herramientas de solo lectura consultan al bróker en vivo; las respuestas correctas se cachean durante 5 minutos (configurable) en un archivo SQLite que sobrevive a reinicios.

⚠️ = requiere SC_MCP_ENABLE_WRITES=true, desactivado por defecto.

La CLI sc también expone trade y savings-plans add/remove. Esos deliberadamente no están expuestos — los comandos que mueven dinero quedan completamente fuera de alcance (las herramientas de escritura anteriores solo tocan listas de seguimiento, alertas y grupos).

Inicio rápido

Elige una opción — las tres terminan con un servidor funcionando:

Plugin de Claude Code

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

Eso registra el servidor MCP scalable-capital y una habilidad que le indica a Claude cuándo y cómo usar las herramientas.

One-liner con uvx

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

Apunta cualquier cliente MCP a ese comando (sc-mcp inicia stdio, fija la etiqueta según Versiones).

Requisitos

1. uv en PATH — omite esto con Docker.

2. La CLI sc en PATH (ver Autenticación).

3. Una sesión autenticada: sc login (ver Autenticación).

Docker incluye tanto la CLI como este servidor, así que el único paso manual allí es el inicio de sesión que se indica a continuación.

Autenticación

Cada herramienta sc_* invoca la CLI oficial sc de Scalable Capital, que debe estar instalada y con sesión iniciada una vez por máquina (o por volumen de Docker).

Instalar la CLI

macOS (Homebrew):

brew install scalablecapital/tap/scalable-cli

Linux (también es el binario incluido en la imagen Docker): descarga la compilación oficial para tu arquitectura y coloca sc en 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

Verifica:

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

Iniciar sesión (una vez)

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

Si alguna herramienta informa luego "la sesión puede haber expirado — prueba sc login", solo vuelve a ejecutar sc login.

Dónde se guarda la sesión

~/.config/scalable-cli/:

Entornos sin interfaz gráfica / sin llavero (Docker, CI, servidores): la CLI usa por defecto el llavero del sistema. Cuando no existe ninguno, indícalo en un archivo simple (la imagen Docker lo hace por ti en docker/entrypoint.sh):

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

Luego ejecuta sc login de nuevo — la sesión queda en session.json y persiste entre reinicios.

Consejo: reutiliza una sesión del host dentro de los contenedores en lugar de iniciar sesión dos veces:

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

Trata ese archivo como una contraseña — nunca lo subas a un repositorio.

Integración con clientes

Claude Code (manual)

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

Cursor

Añadir a Cursor — o añádelo a .cursor/mcp.json (o ~/.cursor/mcp.json):

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

Codex

Añade a ~/.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 (paquete, sin editar configuración)

Descarga sc-mcp.mcpb y luego en Claude Desktop ve a Configuración → Extensiones → Instalar extensión y selecciona el archivo.

[!Note] Si Claude Desktop no puede encontrar uvx, abre la configuración de la extensión y establece la ruta completa (p. ej. /opt/homebrew/bin/uvx). Las aplicaciones con interfaz gráfica en macOS no siempre heredan el PATH de tu shell.

VS Code / otros clientes MCP

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

Fija la etiqueta @v0.2.0 (ver Versiones). Elimínala para seguir la última main.

Docker

Toda la pila — este servidor y la CLI sc — se ejecuta en contenedores, así que solo necesitas Docker (sin uv, Python o sc locales):

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

La sesión se guarda en el volumen sc-cli-config y sobrevive a reinicios. Las escrituras permanecen desactivadas salvo que establezcas SC_MCP_ENABLE_WRITES: "true" en docker-compose.yml.

Apunta cualquier cliente MCP compatible con HTTP a la URL del servidor:

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

El contenedor se comunica directamente con scalable.capital. La URL del flujo de dispositivo de sc login funciona igual que en tu host; solo tienes que abrirla en un navegador. La imagen ya incluye la configuración session_backend = "file" (ver Autenticación).

Compatibilidad

Probado con sc 0.6.x. La CLI es anterior a 1.0 y su superficie de comandos puede cambiar entre versiones menores; el servidor registra una advertencia en stderr al inicio si tu sc instalado difiere de la versión mayor.menor probada. sc es un binario externo, no una dependencia de Python, así que esa es la única verificación disponible. Si ves la advertencia y alguna herramienta se comporta mal, el desajuste es la causa probable.

Configuración

Desarrollo

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

Cómo mantenerse sincronizado con sc (cuándo añadir/actualizar herramientas, subir SUPPORTED_SC_VERSION, invariantes de solo lectura) está documentado en CLAUDE.md.

Versiones

SemVer — las herramientas son la API pública:

Los lanzamientos se etiquetan como vX.Y.Z; fija una etiqueta al instalar mediante uvx --from git+..., que de lo contrario sigue la rama predeterminada y puede cambiar tu superficie de herramientas sin que lo notes. La mayoría de los incrementos se deben a cambios en la CLI sc (ver Compatibilidad); la versión es propia de este paquete, no la versión de sc.

Licencia

MIT