Trading algorítmico con Claude Code: conectar Alpaca por MCP y administrar el riesgo

Módulo: Casos en tendencia 2026 | Tiempo: unos 30 min de teoría + 60 min de práctica (paper trading)

Lo esencial

Claude Code puede manejar una cuenta de trading, analizar el mercado y armar estrategias a través del MCP oficial de Alpaca y su API. Esto no es "la IA predice el precio" (eso no se puede hacer de forma confiable). Es "la IA automatiza la ejecución de la estrategia, el manejo del portafolio y la administración del riesgo". Hay que empezar con paper trading, con dinero virtual, hasta que estés seguro de tu estrategia. La lección enseña a trabajar con las herramientas, no promete ingresos.

🎨 Imagínalo así: Claude Code en el trading es como un director de operaciones contratado. Tú pones las reglas: "compra cuando pase X, vende cuando pase Y, nunca arriesgues más del 5%". Él las ejecuta. No duerme, no entra en pánico, no vende por miedo, no aguanta por codicia.

⚠️ Aviso obligatorio

Esta es una lección educativa, no asesoría financiera ni una recomendación de inversión. El trading algorítmico conlleva riesgos reales de perder capital, y el resultado en una cuenta virtual no garantiza el resultado en una cuenta real. Una parte importante de los traders minoristas pierde dinero: los brokers publican, por exigencia de los reguladores, el porcentaje de cuentas con pérdidas; busca esa cifra con tu broker. Empieza siempre con paper trading. Dinero real, solo después de una larga prueba en cuenta virtual, de entender cada línea del código y de consultar con un profesional con licencia.

Conceptos clave

• Alpaca: un broker con API (interfaz de programación de aplicaciones) para trading algorítmico (acciones de EE. UU., cripto)
• Alpaca MCP: el servidor MCP oficial de Alpaca para Claude Code
• Paper trading: operar con dinero virtual (gratis, solo necesitas registrarte en el sitio del broker)
• Position limit: el tamaño máximo de una posición (en la lección, 5% como ejemplo de estudio)
• Stop-loss: cierre automático cuando hay pérdida (en la lección, -8% como ejemplo de estudio)
• Backtesting: probar una estrategia con datos históricos

Teoría

Alpaca: un broker que empieza por la API

Alpaca es un broker estadounidense creado especialmente para el trading algorítmico. A diferencia de los brokers minoristas con una app bonita, el producto principal de Alpaca es la API.

🎨 Imagínalo así: Alpaca es como un banco para programadores. Un banco normal: app bonita, pero la API es cerrada o de pago. Alpaca: la API es gratuita y está documentada; la app es lo secundario.

Funciones (las condiciones del broker cambian, revísalas en su sitio):

Registro para paper trading:

1. alpaca.markets → Sign Up
2. Crea la cuenta → obtienes una cuenta de paper trading y tus claves
3. Paper trading: un saldo en dólares virtuales (el monto actual lo indica Alpaca en su sitio)
4. Las claves están en tu panel → API Keys

Alpaca MCP: conectarlo a Claude Code

Alpaca tiene un servidor MCP oficial (repositorio alpacahq/alpaca-mcp-server). Se ejecuta con uvx (un gestor de paquetes de Python):

# Conexión con un solo comando
claude mcp add alpaca --scope user --transport stdio uvx alpaca-mcp-server

O con un archivo .mcp.json en la carpeta del proyecto:

{
  "mcpServers": {
    "alpaca": {
      "command": "uvx",
      "args": ["alpaca-mcp-server"],
      "env": {
        "ALPACA_API_KEY": "tu_key_id",
        "ALPACA_SECRET_KEY": "tu_secret_key",
        "ALPACA_PAPER_TRADE": "true"
      }
    }
  }
}

Para comprobar que el servidor se conectó, usa el comando /mcp.

ALPACA_PAPER_TRADE=true: dinero virtual (es el valor por defecto) ALPACA_PAPER_TRADE=false con claves reales: dinero de verdad. No lo cambies hasta haber pasado todas las revisiones de esta lección.

No pegues las claves directo en un archivo que vaya a terminar en git: guárdalas en variables de entorno o en un gestor de contraseñas (más detalle en la lección Seguridad en Claude Code).

🎨 Imagínalo así: la diferencia entre el modo paper y el modo real es como la de un simulador de vuelo y un avión de verdad. Se ven igual, se comportan igual. Pero en el simulador puedes estrellarte contra una montaña y volver a intentar.

Qué puede hacer Claude Code a través de Alpaca MCP

Ya conectado, le preguntas a Claude Code:

"Muéstrame el saldo actual y las posiciones abiertas"
"Compra 10 acciones de AAPL a precio de mercado"
"Vende 5 acciones de MSFT con límite de $420"
"Muéstrame el historial de operaciones de la última semana"
"Cierra todas las posiciones abiertas"
"¿Cuál es mi P&L de hoy?"

Claude Code convierte las solicitudes en llamadas a la API de Alpaca y te devuelve los resultados.

Python + la API de Alpaca: control total

Para estrategias más complejas, código Python directo.

Importante: el ejemplo de abajo usa la biblioteca alpaca-trade-api. Su repositorio pasó a archivo (junio de 2026), y para código nuevo Alpaca recomienda el SDK oficial alpaca-py. La lógica de las revisiones (tamaño de posición, stop-loss, límite diario) no depende de la biblioteca: al pasar a alpaca-py solo cambian las llamadas a la API.

pip install alpaca-trade-api pandas numpy

import alpaca_trade_api as tradeapi
import pandas as pd
import os

# Conexión a paper trading
api = tradeapi.REST(
    os.environ['ALPACA_API_KEY'],
    os.environ['ALPACA_SECRET_KEY'],
    'https://paper-api.alpaca.markets',
    api_version='v2'
)

def check_account():
    """Revisa el estado de la cuenta"""
    account = api.get_account()
    print(f"Saldo: ${float(account.equity):.2f}")
    print(f"Poder de compra: ${float(account.buying_power):.2f}")
    print(f"Estado: {account.status}")

def get_positions():
    """Posiciones actuales"""
    positions = api.list_positions()
    for pos in positions:
        pnl = float(pos.unrealized_pl)
        pnl_pct = float(pos.unrealized_plpc) * 100
        print(f"{pos.symbol}: {pos.qty} acciones | P&L: ${pnl:.2f} ({pnl_pct:.1f}%)")

def safe_market_order(symbol: str, qty: float, side: str, 
                       max_position_pct: float = 0.05):
    """
    Orden de mercado segura que revisa el tamaño de la posición.
    max_position_pct = máximo 5% del capital por posición.
    """
    account = api.get_account()
    equity = float(account.equity)
    
    # Obtenemos el precio
    last_trade = api.get_latest_trade(symbol)
    price = float(last_trade.price)
    
    # Revisamos el tamaño de la posición
    position_value = qty * price
    position_pct = position_value / equity
    
    if position_pct > max_position_pct:
        max_qty = int((equity * max_position_pct) / price)
        print(f"⚠️ Reduzco el tamaño: {qty} → {max_qty} (límite de 5% del portafolio)")
        qty = max_qty
    
    if qty <= 0:
        print("❌ La posición es demasiado pequeña")
        return None
    
    # Colocamos la orden
    order = api.submit_order(
        symbol=symbol,
        qty=qty,
        side=side,         # 'buy' o 'sell'
        type='market',
        time_in_force='gtc'
    )
    
    print(f"✅ Orden colocada: {side.upper()} {qty}x {symbol} (~${position_value:.2f})")
    return order

def set_stop_loss(symbol: str, stop_loss_pct: float = 0.08):
    """
    Pone un stop-loss a una posición existente.
    stop_loss_pct = 0.08 → cerrar si la pérdida llega a 8%
    """
    try:
        position = api.get_position(symbol)
        current_price = float(position.current_price)
        stop_price = current_price * (1 - stop_loss_pct)
        qty = abs(int(float(position.qty)))
        
        # Orden stop-loss
        order = api.submit_order(
            symbol=symbol,
            qty=qty,
            side='sell',
            type='stop',
            stop_price=round(stop_price, 2),
            time_in_force='gtc'
        )
        
        print(f"🛡️ Stop-loss colocado: {symbol} @ ${stop_price:.2f} ({stop_loss_pct*100}%)")
        return order
    except Exception as e:
        print(f"❌ No hay posición en {symbol}: {e}")

# Ejemplo de uso
if __name__ == "__main__":
    check_account()
    print("\nPosiciones actuales:")
    get_positions()
    
    # Compramos AAPL (no más del 5% del portafolio)
    safe_market_order("AAPL", 5, "buy")
    
    # Ponemos un stop-loss de -8%
    set_stop_loss("AAPL", 0.08)

Una estrategia simple: medias móviles

🎨 Imagínalo así: una media móvil es como la temperatura promedio de los últimos 30 días. No brinca de un día a otro. Muestra la tendencia. Cuando la media corta (7 días) cruza la larga (21 días) de abajo hacia arriba, puede ser el inicio de una subida. De arriba hacia abajo, puede ser el inicio de una caída.

def simple_ma_strategy(symbol: str, short_window: int = 7, long_window: int = 21):
    """
    Estrategia de cruce de medias móviles.
    SOLO para aprender: ¡no es asesoría financiera!
    """
    import datetime
    
    # Obtenemos los datos históricos
    end = datetime.datetime.now()
    start = end - datetime.timedelta(days=60)
    
    bars = api.get_bars(
        symbol,
        tradeapi.TimeFrame.Day,
        start.strftime('%Y-%m-%d'),
        end.strftime('%Y-%m-%d')
    ).df
    
    # Calculamos las medias móviles
    bars['SMA_short'] = bars['close'].rolling(window=short_window).mean()
    bars['SMA_long'] = bars['close'].rolling(window=long_window).mean()
    
    # Señales
    bars['signal'] = 0
    bars.loc[bars['SMA_short'] > bars['SMA_long'], 'signal'] = 1   # Long
    bars.loc[bars['SMA_short'] < bars['SMA_long'], 'signal'] = -1  # Short/Flat
    
    # Última señal
    last_signal = bars['signal'].iloc[-1]
    last_price = bars['close'].iloc[-1]
    
    print(f"\n{symbol} @ ${last_price:.2f}")
    print(f"SMA{short_window}: ${bars['SMA_short'].iloc[-1]:.2f}")
    print(f"SMA{long_window}: ${bars['SMA_long'].iloc[-1]:.2f}")
    
    if last_signal == 1:
        print("📈 Señal: COMPRA (SMA_short > SMA_long)")
    elif last_signal == -1:
        print("📉 Señal: VENTA (SMA_short < SMA_long)")
    else:
        print("⏸️ Señal: NEUTRAL")
    
    return last_signal, last_price

# Analizamos varios símbolos
watchlist = ["AAPL", "MSFT", "NVDA", "AMZN"]
for ticker in watchlist:
    signal, price = simple_ma_strategy(ticker)

Administración del riesgo: reglas obligatorias

🎨 Imagínalo así: las reglas de manejo de riesgo son como las normas de seguridad en una obra. Puedes trabajar sin casco hasta que te cae un ladrillo en la cabeza. Después del primer ladrillo, todos usan casco. En el trading, el ladrillo es el margin call. Después de ese, ya no hay casco que valga.

5 reglas básicas (ejemplo de estudio; ajusta los números a tu caso):

RISK_RULES = {
    # Regla 1: no más del 5% del capital en una posición
    "max_position_pct": 0.05,
    
    # Regla 2: stop-loss en cada posición
    "stop_loss_pct": 0.08,
    
    # Regla 3: no más del 20% en un solo sector
    "max_sector_pct": 0.20,
    
    # Regla 4: límite diario de pérdidas
    "max_daily_loss_pct": 0.03,  # Se detiene el trading con -3% en el día
    
    # Regla 5: revisión antes de cada operación
    "pre_trade_checks": True,
}

def check_daily_loss_limit():
    """Detenemos el trading si la pérdida del día es > 3%"""
    account = api.get_account()
    
    # Comparamos con la apertura del día
    daily_pnl_pct = float(account.equity) / float(account.last_equity) - 1
    
    if daily_pnl_pct < -RISK_RULES["max_daily_loss_pct"]:
        print(f"🚨 LÍMITE DIARIO: pérdida de {daily_pnl_pct*100:.1f}%. Detengo el trading.")
        return False
    return True

Binance Futures por MCP (avanzado)

Para trading de cripto existen servidores MCP para futuros de Binance en los catálogos de MCP. Los escriben autores externos, así que antes de conectarlos revisa al autor, el código y el historial del repositorio. Se conectan igual que cualquier servidor MCP (claude mcp add o el archivo .mcp.json).

{
  "mcpServers": {
    "binance-futures": {
      "command": "uvx",
      "args": ["binance-futures-mcp"],
      "env": {
        "BINANCE_API_KEY": "tu_key",
        "BINANCE_SECRET_KEY": "tu_secret",
        "TESTNET": "true"  // ¡EMPIEZA SIEMPRE con testnet!
      }
    }
  }
}

Importante: Binance Futures son derivados con apalancamiento. Los riesgos son muchísimo mayores que al comprar acciones sin apalancamiento. Empieza solo con Testnet y solo si entiendes por completo cómo funcionan los futuros. La disponibilidad del exchange depende del país: revisa si opera con residentes de tu país.

Qué enseña el paper trading y qué no

Hay desarrolladores que publican seguido experimentos con una cuenta virtual usando Claude Code y la API de Alpaca. Las cifras de esas publicaciones no se pueden verificar y no sirven como referencia: dependen del periodo, de las acciones elegidas y de lo que el autor contó y lo que calló. El valor educativo del experimento está en otro lado: compruebas que el código coloca órdenes, respeta los límites y lleva un registro.

Lo que hay que entender: el paper trading no toma en cuenta el slippage (la diferencia entre el precio en el momento de la señal y la ejecución real), el impacto de las órdenes grandes en el mercado ni la psicología del dinero real. Los resultados reales suelen ser peores que los virtuales, y los resultados pasados no garantizan nada a futuro.

Práctica

1. Regístrate en alpaca.markets → obtén las claves de API de paper trading
2. Configura Alpaca MCP en Claude Code (¡con la URL de paper trading!)
3. Pídele a Claude: "muéstrame el saldo y las posiciones abiertas"
4. Corre el script de Python → compra 1 acción de AAPL (paper trading)
5. Ponle un stop-loss a la posición que compraste
6. Mira el P&L 24 horas después y anota qué hay que corregir en el código

Herramientas y recursos

• Alpaca Markets: registro + documentación
• Alpaca MCP: el servidor MCP oficial
• alpaca-py: el SDK oficial de Python vigente (la biblioteca vieja alpaca-trade-api está archivada)
• Backtrader: framework de Python para backtesting
• MCPMarket: catálogo de servidores MCP (los servidores para exchanges los escriben autores externos; revisa su código)

Ideas clave

Alpaca MCP es la forma oficial de manejar una cuenta de trading desde Claude Code. Empieza siempre con paper trading. Dinero real, solo después de una larga prueba en cuenta virtual; y ni así hay resultado garantizado.

Reglas de riesgo de estudio: máximo 5% por posición, stop-loss de 8% en cada una, límite diario de pérdidas de -3%. Sin reglas de riesgo no es trading, es apuesta. Los números concretos elígelos tú, junto con un profesional con licencia.

Claude Code no "predice" el mercado: nadie puede. Automatiza la ejecución de la estrategia, el monitoreo del riesgo y el registro. La estrategia es tu responsabilidad. Esto no es una recomendación de inversión.

Siguiente lección

→ Automatización de redes sociales: Instagram, Telegram, contenido en piloto automático