Despliegue y Práctica de TradingAgents: Construye tu propio equipo de trading cuantitativo con IA

March 21, 2026

WARNING

El marco TradingAgents está diseñado únicamente para fines de investigación. El rendimiento del trading se ve afectado por múltiples factores, incluidos los modelos de lenguaje seleccionados, la temperatura del modelo, los ciclos de trading, la calidad de los datos, entre otros. Este marco no constituye asesoramiento financiero, de inversión o de trading.

¿Alguna vez te has preguntado qué se sentiría si tuvieras un equipo de IA tomando decisiones de inversión por ti?

Hoy vamos a hablar de TradingAgents, un marco de código abierto que te permite construir un "equipo de trading cuantitativo de IA". Simula el flujo de trabajo de una institución financiera real: los investigadores investigan, los analistas redactan informes, el equipo de control de riesgos evalúa los peligros y, finalmente, el trader ejecuta la orden.

¿Suena genial? Empecemos directamente.

Público objetivo

Este artículo está dirigido a perfiles técnicos con 1 a 5 años de experiencia en desarrollo. Necesitas:

  • Conocimientos básicos de Python para entender el código.
  • Curiosidad por los Agentes de IA y los sistemas multi-agente.
  • Ganas de experimentar con IA para asistir en la toma de decisiones de inversión (pero no lo tomes como consejos financieros reales).

Dependencias clave y entorno

Primero, veamos qué necesitas para ponerlo en marcha:

  • Python: 3.10 o superior.
  • Gestión de entorno: Se recomienda Anaconda o venv.
  • Proveedores de LLM: OpenAI (GPT), Google (Gemini), Anthropic (Claude), xAI (Grok), OpenRouter, Ollama (modelos locales).
  • Fuentes de datos: Alpha Vantage (datos bursátiles, noticias, indicadores).
  • Marco principal: LangGraph (orquestación multi-agente).

TIP

Si solo quieres ver los resultados iniciales, el modo CLI no requiere escribir código y tiene una barrera de entrada muy baja.

Estructura del proyecto

TradingAgents/
├── cli/                           # Interfaz de línea de comandos
│   └── main.py                    # Punto de entrada
├── tradingagents/
│   ├── agents/
│   │   ├── analysts/              # Equipo de analistas
│   │   │   ├── fundamentals_analyst.py   # Análisis fundamental
│   │   │   ├── market_analyst.py         # Análisis de mercado
│   │   │   ├── news_analyst.py           # Análisis de noticias
│   │   │   └── social_media_analyst.py   # Sentimiento en redes sociales
│   │   ├── researchers/            # Equipo de investigadores
│   │   │   ├── bull_researcher.py        # Investigador alcista
│   │   │   └── bear_researcher.py        # Investigador bajista
│   │   ├── trader/                 # Trader
│   │   │   └── trader.py
│   │   ├── risk_mgmt/              # Equipo de control de riesgos
│   │   │   ├── aggressive_debator.py
│   │   │   ├── conservative_debator.py
│   │   │   └── neutral_debator.py
│   │   └── managers/
│   │       ├── research_manager.py
│   │       └── risk_manager.py
│   ├── dataflows/                  # Flujos de datos
│   │   ├── alpha_vantage_*.py     # Datos de Alpha Vantage
│   │   └── y_finance.py           # Datos de Yahoo Finance
│   ├── graph/                      # Estructura de grafos LangGraph
│   │   └── trading_graph.py
│   └── llm_clients/                # Clientes de LLM
│       ├── anthropic_client.py
│       ├── google_client.py
│       └── factory.py
├── main.py                         # Punto de entrada para llamadas Python
└── test.py                         # Casos de prueba

Esta estructura es muy clara: el directorio agents alberga los diversos roles de IA, dataflows se encarga de la obtención de datos y graph conecta estos roles en un flujo de trabajo.

Pasos de despliegue paso a paso

1. Clonar el proyecto y crear el entorno

# Clonar el código
git clone https://github.com/TauricResearch/TradingAgents.git
cd TradingAgents

# Crear entorno Python (se recomienda conda)
conda create -n tradingagents python=3.13
conda activate tradingagents

# Instalar dependencias
pip install -r requirements.txt

TIP

Python 3.13 es la versión recomendada oficialmente, pero 3.10+ también debería funcionar. Si encuentras problemas de compatibilidad, intenta con la 3.11.

2. Configurar las API Keys

TradingAgents soporta múltiples proveedores de LLM, necesitas configurar al menos uno:

# Opción 1: Variables de entorno
export OPENAI_API_KEY=sk-tu-openai-key
export ANTHROPIC_API_KEY=sk-ant-tu-anthropic-key
export GOOGLE_API_KEY=tu-google-key
export ALPHA_VANTAGE_API_KEY=tu-alpha-vantage-key

# Opción 2: Copiar archivo de configuración
cp .env.example .env
# Luego edita el archivo .env e introduce tus llaves

TIP

Alpha Vantage es esencial para obtener datos bursátiles. La versión gratuita tiene límites de llamadas, pero es suficiente para pruebas.

3. Experiencia rápida con CLI

¿No quieres escribir código? Ejecuta directamente el CLI:

python -m cli.main

Verás una interfaz interactiva donde podrás elegir:

  • El ticker de la acción (ej. NVDA, AAPL)
  • La fecha de análisis
  • El LLM a utilizar (soporta GPT, Gemini, Claude, etc.)
  • La profundidad de la investigación
  • El número de rondas de debate

Tras la selección, el marco iniciará una serie de agentes de IA colaborando, y verás los informes de análisis que generan en tiempo real en la terminal.

Interfaz CLI

A medida que avanza el análisis, verás cómo se presentan las salidas de los diferentes agentes:

Análisis de noticias

Finalmente, el trader proporcionará una recomendación de trading:

Decisión de trading

4. Llamada mediante código Python

¿Quieres integrarlo en tu propio proyecto? Es tan simple como unas pocas líneas de código:

from tradingagents.graph.trading_graph import TradingAgentsGraph
from tradingagents.default_config import DEFAULT_CONFIG

# Inicialización (debug=True para ver logs detallados)
ta = TradingAgentsGraph(debug=True, config=DEFAULT_CONFIG.copy())

# Ingresa el ticker y la fecha; devuelve la decisión
# El primer valor devuelto es el proceso intermedio, el segundo es la decisión final
_, decision = ta.propagate("NVDA", "2026-01-15")

print(decision)

Al ejecutar este script, verás una salida similar a esta:

{
  "ticker": "NVDA",
  "date": "2026-01-15",
  "decision": "BUY",
  "confidence": 0.75,
  "reasoning": "El investigador alcista considera que...",
  "risk_assessment": "Riesgo medio"
}

5. Cambiar entre proveedores de LLM

Uno de los puntos fuertes de TradingAgents es su soporte para múltiples LLM. Puedes cambiar en cualquier momento:

from tradingagents.graph.trading_graph import TradingAgentsGraph
from tradingagents.default_config import DEFAULT_CONFIG

# Copiar la configuración predeterminada y modificarla
config = DEFAULT_CONFIG.copy()
config["llm_provider"] = "anthropic"        # Opciones: openai, google, anthropic, xai, openrouter, ollama
config["deep_think_llm"] = "claude-sonnet-4.5"   # Modelo potente para razonamiento complejo
config["quick_think_llm"] = "claude-haiku-4.5"  # Modelo ligero para tareas sencillas
config["max_debate_rounds"] = 2               # Rondas de debate alcista/bajista

ta = TradingAgentsGraph(debug=True, config=config)
_, decision = ta.propagate("AAPL", "2026-01-20")
print(decision)

6. Opciones de configuración personalizadas

En DEFAULT_CONFIG hay muchos parámetros ajustables:

config = DEFAULT_CONFIG.copy()

# Parámetros principales
config["llm_provider"] = "openai"
config["deep_think_llm"] = "gpt-5.2"      # Modelo de pensamiento profundo
config["quick_think_llm"] = "gpt-5-mini"  # Modelo de respuesta rápida

# Ajustes de debate
config["max_debate_rounds"] = 3           # Rondas de debate
config["enable_researchers"] = True       # Habilitar equipo de investigación
config["enable_risk_management"] = True  # Habilitar equipo de gestión de riesgos

# Ajustes de datos
config["data_provider"] = "alpha_vantage"  # Proveedor de datos
config["news_provider"] = "yfinance"      # Fuente de noticias

Integración con Defapi: Una solución de bajo costo

Hablando de agentes de IA, aquí va un consejo práctico:

Si quieres ejecutar TradingAgents con Claude o GPT pero te frena el precio de las API oficiales, puedes probar Defapi. Soporta el protocolo v1/chat/completions y el precio es solo la mitad que el oficial.

La configuración es totalmente compatible con la API oficial; solo necesitas cambiar el base_url por la dirección de Defapi. Para un sistema multi-agente como TradingAgents, donde cada agente llama al LLM, usar Defapi puede ahorrar muchos costos.

El método de configuración específico consiste en cambiar el base_url en el cliente LLM de la dirección oficial a https://api.defapi.org, y usar la API Key asignada por Defapi. Actualmente, Defapi soporta modelos principales como Claude, GPT y Gemini, cubriendo básicamente las necesidades de TradingAgents.

Solución de problemas comunes

1. ¿La API Key no funciona?

Verifica si las variables de entorno están configuradas correctamente. En Linux/Mac usa echo $OPENAI_API_KEY, en Windows usa echo %OPENAI_API_KEY%. Si usas un archivo .env, asegúrate de haber hecho cp .env.example .env e introducido la llave real.

2. ¿Modelo no soportado?

Los nombres de los modelos varían según el proveedor. Por ejemplo, en OpenAI es gpt-5.2 y en Anthropic es claude-sonnet-4.5. Si no estás seguro del nombre del modelo, intenta con los que figuran en la documentación oficial.

3. ¿Fallo en la llamada a Alpha Vantage?

La versión gratuita de la API tiene límites de llamadas por minuto (generalmente 5 veces/min). Si haces peticiones frecuentes en poco tiempo, devolverá un error 429. Solución: actualiza a una versión de pago o añade retardos en el código.

4. ¿Tiempo de espera de red (Timeout)?

TradingAgents llama a múltiples LLM y APIs de datos; una red inestable puede causar timeouts fácilmente. Puedes intentar:

  • Cambiar a un modelo accesible localmente.
  • Incrementar la configuración de tiempo de espera.
  • Usar modelos locales (Ollama).

5. ¿Decisión con resultado vacío?

A veces, todos los agentes recomiendan "no operar", lo cual es normal. La decisión del marco es una síntesis de las opiniones alcistas, bajistas y de riesgo. Si el consenso es conservador, la salida será HOLD. Puedes ajustar max_debate_rounds para aumentar las rondas de debate y hacer la decisión más agresiva (o conservadora).

6. ¿Cómo interpretar los resultados de la decisión?

La salida suele ser un formato JSON que incluye:

  • decision: BUY / SELL / HOLD
  • confidence: Nivel de confianza entre 0 y 1
  • reasoning: Resumen del análisis de cada agente
  • risk_assessment: Nivel de riesgo

Recuerda: esto es solo un análisis y sugerencia de la IA, no lo tomes directamente como una orden de trading.

Lectura extendida y direcciones avanzadas

1. Trading-R1

Este es un proyecto posterior del mismo equipo, centrado en optimizar estrategias de trading mediante aprendizaje por refuerzo. El artículo ya ha sido publicado en arXiv y el código se abrirá pronto; vale la pena seguirlo.

2. Optimización del sistema multi-agente

La arquitectura de TradingAgents es esencialmente colaboración multi-agente. Puedes intentar:

  • Añadir nuevos roles de agentes (como un analista macroeconómico).
  • Ajustar la lógica de debate entre agentes.
  • Conectar interfaces de trading reales (en fase de trading simulado).

3. Soluciones con modelos locales

Si no quieres depender de APIs externas, puedes desplegar modelos locales con Ollama. Aunque el rendimiento puede no ser tan alto como el de GPT/Claude, el costo es cero, lo cual es ideal para aprendizaje y pruebas.

Updated March 21, 2026