DEV Community

Cover image for Cómo Convertir TradingAgents en un Flujo de Trabajo API de Trading Real
Roobia
Roobia

Posted on • Originally published at apidog.com

Cómo Convertir TradingAgents en un Flujo de Trabajo API de Trading Real

TL;DR / Respuesta Rápida

La manera más práctica y rápida de usar TradingAgents es ejecutarlo como paquete de Python, envolverlo en un pequeño servicio FastAPI y probarlo en Apidog. Así obtienes un flujo repetible para activar análisis, consultar resultados, documentar el contrato de solicitud y compartir la configuración con tu equipo.

Prueba Apidog hoy

Introducción

TradingAgents es fácil de admirar desde fuera. El repositorio de GitHub muestra un flujo de trabajo de trading multiagente, una CLI pulida, soporte para múltiples proveedores de modelos y un documento de investigación que explica el diseño del framework. El reto real aparece al integrarlo en un flujo de ingeniería concreto.

La mayoría de los equipos no quieren que el repositorio solo funcione en la máquina de un desarrollador. Buscan una forma repetible de lanzar análisis, pasar un símbolo y fecha, obtener un ID de trabajo, consultar el resultado después y entregar ese flujo a frontend, QA o plataforma, sin convertir cada consulta en una sesión de debugging de Python. Además, como cualquier sistema de research de trading puede terminar informando decisiones reales, es clave envolver TradingAgents en una API controlada y documentada, en vez de dejarlo como script local.

💡 Apidog encaja naturalmente en este flujo. Importa el esquema OpenAPI de FastAPI, guarda entornos locales/remotos, extrae variables de respuestas, encadena solicitudes en escenarios y publica documentación para tu equipo. Descárgalo gratis en Apidog.

Qué es y qué no es TradingAgents

Antes de programar, define bien la herramienta.

Estructura TradingAgents

TradingAgents es un framework de trading multiagente open-source. El repo modela roles similares a una firma de trading:

  • Analistas de fundamentales, sentimiento, noticias y señales técnicas
  • Investigadores alcistas y bajistas para debate
  • Un agente trader
  • Roles de gestión de riesgos
  • Gestor de cartera para decisión final

Roles TradingAgents

El framework se construye sobre LangGraph y soporta varios proveedores de modelos: OpenAI, Google, Anthropic, xAI, OpenRouter, Ollama. Algunos valores por defecto:

  • llm_provider = "openai"
  • deep_think_llm = "gpt-5.2"
  • quick_think_llm = "gpt-5-mini"
  • backend_url = "https://api.openai.com/v1"
  • max_debate_rounds = 1

Esto deja claro: es un framework Python configurable, no una API SaaS lista para consumo.

El repo también es explícito: TradingAgents es para investigación, no asesoría financiera. Si lo usas internamente o construyes software sobre él, mantén esa distinción en tu docs y UX.

Paso 1: Instalar TradingAgents

Configura el repo:

git clone https://github.com/TauricResearch/TradingAgents.git
cd TradingAgents
conda create -n tradingagents python=3.13
conda activate tradingagents
pip install .
Enter fullscreen mode Exit fullscreen mode

Para construir el wrapper API, instala FastAPI y Uvicorn:

pip install fastapi uvicorn
Enter fullscreen mode Exit fullscreen mode

El repo incluye un .env.example con variables de proveedor:

OPENAI_API_KEY=
GOOGLE_API_KEY=
ANTHROPIC_API_KEY=
XAI_API_KEY=
OPENROUTER_API_KEY=
Enter fullscreen mode Exit fullscreen mode

Según el proveedor/modelo, podrías necesitar otras credenciales (ej. Alpha Vantage).

Reglas prácticas:

  1. Mantén credenciales en variables de entorno o gestores de secretos.
  2. No pases secretos por el cuerpo de las solicitudes de API pública.

Esto facilita entornos Apidog limpios y mejora la seguridad.

Paso 2: Ejecutar TradingAgents primero en Python

Antes de hacer un wrapper API, confirma que el framework funciona localmente.

Ejemplo mínimo de uso:

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

ta = TradingAgentsGraph(debug=True, config=DEFAULT_CONFIG.copy())
_, decision = ta.propagate("NVDA", "2026-01-15")
print(decision)
Enter fullscreen mode Exit fullscreen mode

Si esto funciona, puedes pasar a configurar parámetros. Ejemplo de override:

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

config = DEFAULT_CONFIG.copy()
config["llm_provider"] = "openai"
config["deep_think_llm"] = "gpt-5.2"
config["quick_think_llm"] = "gpt-5-mini"
config["max_debate_rounds"] = 2

ta = TradingAgentsGraph(debug=True, config=config)
_, decision = ta.propagate("NVDA", "2026-01-15")
print(decision)
Enter fullscreen mode Exit fullscreen mode

Este patrón te muestra qué parámetros vale la pena exponer en la API:

  • ticker
  • analysis_date
  • llm_provider
  • deep_think_llm
  • quick_think_llm
  • Profundidad de investigación/rondas de debate

No saltes este paso local: te evitará depuración innecesaria vía HTTP.

Paso 3: Decidir cómo usar TradingAgents

Tienes tres opciones principales:

Opción 1: Solo CLI

La CLI interactiva te permite elegir símbolo, fecha, proveedor y profundidad. Útil para:

  • Explorar o aprender la herramienta
  • Experimentos personales
  • Sin contrato estable para otras apps

No es suficiente si tu siguiente paso es frontend, herramientas de gestión, servicios compartidos o workflows de QA.

Opción 2: Solo Python

Llamar a TradingAgentsGraph directamente es útil para scripts/notebooks locales y control programático completo por un solo desarrollador.

Limita cuando múltiples equipos deben consumir el workflow.

Opción 3: API Wrapper + Apidog

Lo más útil en equipo: TradingAgents como motor, expuesto por FastAPI, probado/documentado en Apidog.

Elige esto cuando:

  • Un frontend debe lanzar análisis
  • QA necesita flujos repetibles
  • Quieres entornos, aserciones y docs en un solo sitio
  • El workflow puede durar lo suficiente como para que tenga sentido el polling asíncrono

Para la mayoría, aquí es donde "cómo usar TradingAgents" se convierte en una implementación real.

Paso 4: Envolver TradingAgents en un servicio FastAPI

El patrón recomendado es una API basada en trabajos.

¿Por qué? El análisis multiagente puede demorar; es mejor:

POST /analyses -> devuelve analysis_id
GET /analyses/{id} -> estado: queued, running, completed, failed
Enter fullscreen mode Exit fullscreen mode

Más fácil para navegadores, QA y documentar en Apidog.

Contrato mínimo de la API

Endpoint Propósito
GET /health comprobación de estado
POST /analyses lanzar análisis TradingAgents
GET /analyses/{id} obtener estado y resultado final

Wrapper FastAPI de ejemplo 

from concurrent.futures import ThreadPoolExecutor
from datetime import date, datetime
from uuid import uuid4

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field

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

app = FastAPI(title="TradingAgents API", version="0.1.0")
executor = ThreadPoolExecutor(max_workers=2)
jobs: dict[str, dict] = {}

class AnalysisRequest(BaseModel):
    ticker: str = Field(..., min_length=1, examples=["NVDA"])
    analysis_date: date
    llm_provider: str = Field(default="openai")
    deep_think_llm: str = Field(default="gpt-5.2")
    quick_think_llm: str = Field(default="gpt-5-mini")
    research_depth: int = Field(default=1, ge=1, le=5)

def run_analysis(job_id: str, payload: AnalysisRequest) -> None:
    jobs[job_id]["status"] = "running"
    jobs[job_id]["started_at"] = datetime.utcnow().isoformat()

    config = DEFAULT_CONFIG.copy()
    config["llm_provider"] = payload.llm_provider
    config["deep_think_llm"] = payload.deep_think_llm
    config["quick_think_llm"] = payload.quick_think_llm
    config["max_debate_rounds"] = payload.research_depth
    config["max_risk_discuss_rounds"] = payload.research_depth

    try:
        graph = TradingAgentsGraph(debug=False, config=config)
        _, decision = graph.propagate(
            payload.ticker,
            payload.analysis_date.isoformat(),
        )
        jobs[job_id].update(
            {
                "status": "completed",
                "finished_at": datetime.utcnow().isoformat(),
                "result": decision,
            }
        )
    except Exception as exc:
        jobs[job_id].update(
            {
                "status": "failed",
                "finished_at": datetime.utcnow().isoformat(),
                "error": str(exc),
            }
        )

@app.get("/health")
def health() -> dict:
    return {"status": "ok"}

@app.post("/analyses", status_code=202)
def create_analysis(payload: AnalysisRequest) -> dict:
    analysis_id = str(uuid4())
    jobs[analysis_id] = {
        "status": "queued",
        "ticker": payload.ticker,
        "analysis_date": payload.analysis_date.isoformat(),
        "created_at": datetime.utcnow().isoformat(),
    }
    executor.submit(run_analysis, analysis_id, payload)
    return {"analysis_id": analysis_id, "status": "queued"}

@app.get("/analyses/{analysis_id}")
def get_analysis(analysis_id: str) -> dict:
    job = jobs.get(analysis_id)
    if not job:
        raise HTTPException(status_code=404, detail="Analysis not found")
    return job
Enter fullscreen mode Exit fullscreen mode

Arranca el servicio:

uvicorn app:app --reload
Enter fullscreen mode Exit fullscreen mode

FastAPI expone:

Paso 5: Usar TradingAgents mediante la API

Ya puedes operar TradingAgents de forma estable y repetible.

Activar un análisis

Haz un POST /analyses con cuerpo:

{
  "ticker": "NVDA",
  "analysis_date": "2026-03-26",
  "llm_provider": "openai",
  "deep_think_llm": "gpt-5.2",
  "quick_think_llm": "gpt-5-mini",
  "research_depth": 2
}
Enter fullscreen mode Exit fullscreen mode

Respuesta esperada:

{
  "analysis_id": "88f9f0f5-7315-4c73-8ed5-d0a71f613d31",
  "status": "queued"
}
Enter fullscreen mode Exit fullscreen mode

Necesitas el identificador para consultar después.

Consultar el resultado

GET /analyses/{analysis_id} para ver progreso:

{
  "status": "running",
  "ticker": "NVDA",
  "analysis_date": "2026-03-26",
  "created_at": "2026-03-26T06:00:00.000000",
  "started_at": "2026-03-26T06:00:01.000000"
}
Enter fullscreen mode Exit fullscreen mode

Cuando termina:

{
  "status": "completed",
  "ticker": "NVDA",
  "analysis_date": "2026-03-26",
  "result": {
    "decision": "hold"
  }
}
Enter fullscreen mode Exit fullscreen mode

Si falla, devuelve status: failed y mensaje de error.

Paso 6: Importar la API en Apidog

Aquí el flujo se vuelve mucho más mantenible.

En Apidog, importa el esquema OpenAPI desde:

http://localhost:8000/openapi.json
Enter fullscreen mode Exit fullscreen mode

Verás tus endpoints ya configurados, con estructuras de solicitudes y respuestas alineadas.

Ventajas inmediatas:

  • Documentación igual a la implementación
  • Parámetros de ruta generados
  • Cuerpos de solicitudes sincronizados con el código
  • El equipo no tiene que recrear la colección manualmente

Si vienes de pruebas cURL o herramientas de solo solicitud, Apidog suma valor agrupando diseño, tests, entornos y docs.

Paso 7: Crear un entorno Apidog

Crea un entorno para tu servicio local.

Variables de ejemplo:

base_url = http://localhost:8000
analysis_id =
Enter fullscreen mode Exit fullscreen mode

Si tu API requiere autenticación, agrégala:

internal_api_key = your-local-dev-key
Enter fullscreen mode Exit fullscreen mode

Ventajas:

  • Cambiar entre local, testing, producción es trivial
  • Las solicitudes son reutilizables
  • El equipo no reescribe URLs/headers cada vez

Apidog es el compañero ideal para TradingAgents: este maneja la lógica de análisis, Apidog orquesta el workflow compartido.

Paso 8: Probar el flujo completo en Apidog

Usa Apidog para probar TradingAgents como lo haría un cliente real.

Solicitud 1: Crear el análisis

Configura:

  • Método: POST
  • URL: {{base_url}}/analyses
  • Cuerpo: 
{
  "ticker": "NVDA",
  "analysis_date": "2026-03-26",
  "llm_provider": "openai",
  "deep_think_llm": "gpt-5.2",
  "quick_think_llm": "gpt-5-mini",
  "research_depth": 2
}
Enter fullscreen mode Exit fullscreen mode

Agrega un script de prueba para validar estado y guardar el ID:

pm.test("Status is 202", function () {
  pm.response.to.have.status(202);
});

const data = pm.response.json();
pm.expect(data.analysis_id).to.exist;
pm.environment.set("analysis_id", data.analysis_id);
Enter fullscreen mode Exit fullscreen mode

Solicitud 2: Consultar el análisis

Configura:

  • Método: GET
  • URL: {{base_url}}/analyses/{{analysis_id}}

Agrega una aserción:

pm.test("Analysis has a valid status", function () {
  const data = pm.response.json();
  pm.expect(["queued", "running", "completed", "failed"]).to.include(data.status);
});
Enter fullscreen mode Exit fullscreen mode

Para comprobar resultado en completados:

pm.test("Completed jobs include a result", function () {
  const data = pm.response.json();
  if (data.status === "completed") {
    pm.expect(data.result).to.exist;
  }
});
Enter fullscreen mode Exit fullscreen mode

Encadenar solicitudes en un escenario

En Apidog, crea un escenario que:

  1. Envía POST /analyses
  2. Guarda analysis_id
  3. Espera unos segundos
  4. Ejecuta GET /analyses/{{analysis_id}}

Así tu equipo QA/ingeniería puede validar todo el ciclo de vida, no solo un 200 OK.

Paso 9: Publicar documentación interna para el equipo

Una vez que las solicitudes funcionen, publica documentación interna en Apidog que explique:

  • Qué proveedores están permitidos
  • Qué significa research_depth en tu contexto
  • Qué valores de estado debe esperar el cliente
  • Tiempos habituales de ejecución
  • Qué errores son reintentables
  • Dónde aplica el disclaimer de solo investigación

Esto es clave: frameworks inteligentes como TradingAgents se vuelven cuellos de botella si el contrato vive solo en la cabeza de un dev.

Descarga gratis Apidog para convertir TradingAgents en un workflow de API documentado, con entornos, aserciones y escenarios listos para el equipo.

Errores comunes al usar TradingAgents así

Tratar el framework como una API alojada

TradingAgents no es un SaaS. Es un framework Python. Construye el contrato que tu equipo necesita.

Pasar secretos por cuerpos de solicitud

Mantén claves en variables de entorno, nunca en el request body ni en ejemplos/capturas.

Devolver respuestas síncronas largas

Usa una API basada en trabajos para flujos multiagente, no respuestas bloqueantes.

Exponer demasiados parámetros de configuración

No abras todos los ajustes internos en la API desde el inicio. Empieza pequeño y estable.

Mantener resultados solo en memoria

El ejemplo usa un diccionario in-memory por simplicidad. En producción, usa Redis, Postgres u otro backend duradero.

Ocultar el disclaimer de investigación

Si envuelves TradingAgents, muestra la advertencia: es para investigación y experimentación, no para asesoría financiera.

Conclusión

La mejor forma de usar TradingAgents depende del contexto. Si solo exploras, la CLI y el paquete Python son suficientes. Si buscas un workflow de equipo estable, envuélvelo en una API y usa Apidog para testear y documentar.

Para pasar rápido de GitHub a flujo de trabajo en equipo:

  1. Instala TradingAgents
  2. Prueba TradingAgentsGraph localmente
  3. Agrega endpoints POST /analyses y GET /analyses/{id}
  4. Importa el esquema en Apidog
  5. Construye un escenario de extremo a extremo

Este camino es mucho más sostenible que una colección de comandos sueltos y conocimiento tribal.

Preguntas Frecuentes

¿Cómo se usa TradingAgents por primera vez?

Instala el repo, configura las variables de entorno del proveedor de modelo y ejecuta el ejemplo en Python con TradingAgentsGraph. Si funciona, decide si solo necesitas la CLI o quieres envolverlo en una API.

¿TradingAgents viene con una API REST oficial?

No, según el repo público (marzo 2026). Es CLI y paquete Python. Muchos equipos añaden un wrapper FastAPI propio.

¿Cuál es la forma más fácil de usar TradingAgents en un frontend?

No llames al framework Python directo desde el frontend. Expón una API backend que devuelva analysis_id y permite al frontend consultar los resultados.

¿Por qué usar Apidog con TradingAgents?

Apidog te da un entorno limpio para importar OpenAPI, guardar entornos, almacenar ejemplos, agregar aserciones y compartir el workflow sin tener que hacer ingeniería inversa del código Python.

¿Qué configuraciones de TradingAgents vale la pena exponer en una API?

Las básicas: símbolo bursátil, fecha de análisis, proveedor, modelos y profundidad de investigación. Puedes expandirlo luego si el caso lo requiere.

¿Puedo mantener el estado del trabajo de ejemplo en memoria?

Solo para prototipos o pruebas. En producción, usa Redis, Postgres u otro backend duradero para no perder análisis en reinicios.

¿Es TradingAgents adecuado para decisiones financieras en vivo?

El proyecto lo describe como framework de investigación, no asesoría financiera. Trátalo como sistema experimental, salvo que añadas controles y gobernanza propios.

Top comments (0)