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

TL;DR / Respuesta Rápida

La forma práctica más rápida de usar TradingAgents es ejecutarlo como un paquete de Python, envolverlo en un pequeño servicio FastAPI y luego probar ese servicio en Apidog. Esto le brinda un flujo de trabajo repetible para activar análisis, consultar resultados, documentar el contrato de solicitud y compartir la configuración con su equipo.

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. La parte más difícil comienza cuando intentas usarlo en un flujo de trabajo de ingeniería real.

La mayoría de los equipos no quieren un repositorio que solo un desarrollador pueda ejecutar localmente. Quieren una forma repetible de activar análisis, pasar un símbolo bursátil y una fecha, devolver un ID de trabajo, inspeccionar el resultado más tarde y entregar ese flujo de trabajo a compañeros de equipo de frontend, QA o plataforma sin convertir cada pregunta en una sesión de depuración de Python. Y debido a que cualquier sistema de investigación de trading eventualmente se utilizará para informar decisiones de dinero real, es aún más importante envolver TradingAgents en una API controlada y documentada en lugar de dejarlo como un script único en la computadora portátil de alguien.

💡

Apidog encaja naturalmente en este flujo de trabajo. Puede importar el esquema OpenAPI de FastAPI, guardar entornos para implementaciones locales y remotas, extraer variables de las respuestas, encadenar solicitudes de sondeo en un escenario y publicar documentos para el resto de su equipo. Descargue Apidog gratis para seguir el ejemplo.

botón

Qué es y qué no es TradingAgents

Antes de empezar a programar, es útil definir la herramienta con precisión.

TradingAgents es un framework de trading multiagente de código abierto. El repositorio describe un conjunto de roles especializados que reflejan la estructura de una firma de trading:

analistas de fundamentos, sentimiento, noticias y señales técnicas
investigadores alcistas y bajistas para el debate
un agente trader
roles de gestión de riesgos
un gestor de cartera para la decisión final

El repositorio también indica que el framework está construido con LangGraph y soporta múltiples proveedores de modelos, incluyendo OpenAI, Google, Anthropic, xAI, OpenRouter y Ollama. En la configuración predeterminada pública, el proyecto actualmente utiliza valores como:

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

Eso importa porque te dice con qué estás trabajando realmente: un framework de Python configurable, no una API SaaS lista para usar.

El repositorio también es cuidadoso con el alcance. TradingAgents se presenta como un framework de investigación, no como asesoramiento financiero. Si lo usa internamente o construye software a su alrededor, mantenga ese encuadre visible en su documentación y experiencia de usuario.

Paso 1: Instalar TradingAgents

Comience con la configuración del propio repositorio:

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

Si también desea construir el wrapper de la API de este tutorial, agregue FastAPI y Uvicorn:

pip install fastapi uvicorn

El repositorio de TradingAgents también incluye un archivo .env.example con variables de proveedor como:

OPENAI_API_KEY=
GOOGLE_API_KEY=
ANTHROPIC_API_KEY=
XAI_API_KEY=
OPENROUTER_API_KEY=

Dependiendo de sus elecciones de modelo y datos, también puede necesitar otras credenciales de proveedor, como las de Alpha Vantage.

Aquí importan dos reglas prácticas:

Mantenga las credenciales en variables de entorno o en un gestor de secretos.
No pase secretos de proveedor a través del cuerpo de su solicitud de API pública más tarde.

Esa separación hará que sus entornos de Apidog sean más limpios y su modelo de seguridad mucho más seguro.

Paso 2: Ejecutar TradingAgents primero en Python

Antes de construir cualquier wrapper de API, demuestre que el framework principal se ejecuta en su entorno.

El README muestra un patrón de uso mínimo de Python:

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)

Este es el primer punto de control correcto porque responde a la única pregunta que importa al principio: ¿pueden su máquina, configuración del modelo y dependencias realmente ejecutar una operación de TradingAgents?

Si eso funciona, entonces puede pasar a la configuración controlada. El repositorio también muestra que puede anular la configuración predeterminada:

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)

Ese segundo ejemplo es más importante de lo que parece. Le dice qué parámetros vale la pena exponer en una API más adelante:

ticker
analysis_date
llm_provider
deep_think_llm
quick_think_llm
profundidad de investigación o rondas de debate

Si omite esta fase de Python local y salta directamente a HTTP, la depuración se vuelve más difícil de lo necesario.

Paso 3: Decidir cómo desea usar TradingAgents

En este punto, tiene tres formas comunes de usar el framework.

Opción 1: Solo CLI

El repositorio incluye una CLI interactiva donde puede elegir el símbolo, la fecha, el proveedor y la profundidad de la investigación. Esta es una buena manera de explorar el proyecto rápidamente.

Use esto cuando:

esté aprendiendo la herramienta
esté ejecutando experimentos en solitario
no necesite un contrato estable para otra aplicación

No se detenga aquí si su siguiente paso es un frontend, una herramienta de administración, un servicio compartido o un flujo de trabajo de QA.

Opción 2: Solo Python

Llamar a TradingAgentsGraph directamente desde Python es mejor que la CLI cuando necesita orquestación personalizada o scripts locales.

Use esto cuando:

desee notebooks o automatización local
necesite control programático
un solo desarrollador es dueño del flujo de trabajo de principio a fin

Esto aún se queda corto cuando múltiples equipos necesitan consumir el flujo de trabajo.

Opción 3: Wrapper de API más Apidog

Esta es la configuración de equipo más útil. Mantiene TradingAgents como el motor de ejecución, lo expone a través de un pequeño servicio FastAPI y usa Apidog para probar y documentar el contrato.

Use esto cuando:

un frontend necesite activar un análisis
QA necesite un flujo de solicitud repetible
desee entornos, aserciones y documentos en un solo lugar
el flujo de trabajo puede ejecutarse el tiempo suficiente como para que el sondeo tenga más sentido que una solicitud síncrona

Para la mayoría de los equipos, este es el punto en el que "cómo usar TradingAgents" se convierte en una respuesta de implementación real en lugar de solo una demostración local.

Paso 4: Envolver TradingAgents en un servicio FastAPI

El patrón más limpio para un primer wrapper es una API basada en trabajos.

¿Por qué basada en trabajos? Porque un análisis multiagente puede tardar lo suficiente como para que mantener una solicitud abierta sea incómodo para los clientes. Un patrón mejor es:

POST /analyses -> returns analysis_id
GET /analyses/{id} -> returns queued, running, completed, or failed

Esa estructura es más fácil para los navegadores, más fácil para QA y más fácil de documentar en Apidog.

Crear el contrato de la API

Un contrato mínimo se ve así:

Endpoint	Propósito
`GET /health`	comprobación básica de estado
`POST /analyses`	activar una ejecución de TradingAgents
`GET /analyses/{analysis_id}`	obtener el estado del trabajo y el resultado final

Construir el wrapper

Aquí hay un ejemplo compacto de FastAPI:

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

Iniciar el servicio:

uvicorn app:app --reload

Una vez que el servidor esté activo, FastAPI expondrá:

http://localhost:8000/docs
http://localhost:8000/openapi.json

Esa segunda URL es especialmente útil porque Apidog puede importarla directamente.

Paso 5: Usar TradingAgents a través de la API

Ahora está listo para usar TradingAgents de una manera que se sienta estable y repetible.

Activar un análisis

Envíe una solicitud POST /analyses con un cuerpo como este:

{
 "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
}

La respuesta debería ser rápida y pequeña:

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

Eso es exactamente lo que quiere. Su cliente no necesita el informe final de inmediato. Necesita un identificador estable para la ejecución.

Consultar el resultado

Use GET /analyses/{analysis_id} para verificar el 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"
}

Cuando el flujo de trabajo finaliza, la respuesta puede incluir la decisión final:

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

Si algo falla, devuelva un estado failed claro y un mensaje de error en lugar de dejar a los clientes adivinando.

Paso 6: Importar la API en Apidog

Aquí es donde el flujo de trabajo se vuelve mucho más fácil de mantener.

En Apidog, importe el esquema OpenAPI desde:

http://localhost:8000/openapi.json

Después de la importación, debería ver sus endpoints con su estructura de solicitud y respuesta ya configurada.

Eso le brinda algunas ventajas inmediatas:

la documentación coincide con la implementación
los parámetros de ruta se generan correctamente
los cuerpos de las solicitudes se mantienen alineados con su código
los compañeros de equipo no necesitan reconstruir la colección manualmente

Si está pasando de pruebas cURL ad hoc, esta es una mejora significativa. Si está pasando de una herramienta solo de solicitud, aquí es donde Apidog comienza a importar más porque puede mantener el diseño, las pruebas, los entornos y la documentación en un solo lugar.

Paso 7: Crear un entorno Apidog

Una vez importada la API, cree un entorno para su servicio local.

Variables de ejemplo:

base_url = http://localhost:8000
analysis_id =

Si su API usa autenticación, inclúyala también:

internal_api_key = your-local-dev-key

Este paso parece pequeño, pero evita mucha fricción:

puede alternar entre entornos local, de prueba y de producción más rápido
sus solicitudes siguen siendo reutilizables
sus compañeros de equipo no tienen que reescribir URLs y encabezados cada vez

Esta es una de las razones más simples por las que Apidog es un compañero sólido para TradingAgents. El framework en sí maneja la lógica de análisis. Apidog maneja el flujo de trabajo compartido a su alrededor.

Paso 8: Probar el flujo de trabajo completo en Apidog

Ahora puede usar Apidog para probar TradingAgents como lo haría un cliente real.

Solicitud 1: Crear el análisis

Configure:

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
}

Agregue un script de prueba que valide el estado y almacene 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);

Solicitud 2: Consultar el análisis

Configure:

método: GET
URL: {{base_url}}/analyses/{{analysis_id}}

Luego agregue una aserción como:

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

Si también desea una comprobación de ruta exitosa:

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

Encadenar ambas solicitudes en un escenario

Aquí es donde Apidog se convierte en algo más que un cliente de API. Construya un escenario que:

envía POST /analyses
almacena analysis_id
espera unos segundos
ejecuta GET /analyses/{{analysis_id}}

Eso les da a sus equipos de QA e ingeniería una forma reproducible de validar el ciclo de vida en lugar de solo verificar si un endpoint devuelve un 200.

Paso 9: Publicar documentos internos para su equipo

Una vez que las solicitudes funcionen, no se detenga en las pruebas.

Use Apidog para publicar documentación interna que explique:

qué proveedores están permitidos
qué significa research_depth en su implementación
qué valores de estado deben esperar los clientes
cuánto tiempo suelen tardar las ejecuciones
qué errores son reintentables
dónde se aplica la exención de responsabilidad solo para investigación

Esta es una de las partes más importantes para usar TradingAgents correctamente. El framework central es inteligente, pero los frameworks inteligentes se convierten en cuellos de botella para el equipo cuando el contrato reside solo en la cabeza de un desarrollador.

Descargue Apidog gratis para convertir TradingAgents en un flujo de trabajo de API documentado con entornos, aserciones y escenarios reutilizables listos para el equipo.

Errores comunes al usar TradingAgents de esta manera

Tratar el framework como una API alojada

TradingAgents no es un servicio público listo para usar. Es un framework de Python. Construya el contrato que desea que use su equipo en lugar de esperar que el repositorio se lo proporcione.

Pasar secretos a través de los cuerpos de las solicitudes

Mantenga las claves del proveedor en la gestión de entornos. No las filtre en ejemplos, llamadas de frontend o capturas de pantalla compartidas.

Devolver una respuesta síncrona larga

Para un flujo de trabajo de agente de varios pasos, una API basada en trabajos suele ser más fácil de gestionar que una solicitud de bloqueo larga.

Exponer demasiados parámetros de configuración

El repositorio tiene opciones de configuración útiles, pero su API no necesita exponer cada ajuste interno desde el primer día. Comience con un contrato pequeño y estable.

Mantener los resultados solo en memoria

El código del tutorial utiliza un diccionario en memoria porque es fácil de entender. En producción, almacene el estado del trabajo en Redis, Postgres u otro backend duradero para que un reinicio del servicio no borre los análisis activos.

Ocultar el descargo de responsabilidad de la investigación

Si su servicio envuelve TradingAgents, mantenga la misma advertencia que usa el proyecto. El framework es para investigación y experimentación, no para asesoramiento financiero.

Conclusión

La mejor manera de usar TradingAgents depende de lo que intente hacer. Si está explorando el framework solo, la CLI y el paquete de Python son suficientes. Si desea un flujo de trabajo de equipo estable y repetible, envuelva TradingAgents en una pequeña API y use Apidog para probarlo y documentarlo.

Si desea pasar rápidamente de un repositorio de GitHub a un flujo de trabajo de equipo utilizable, instale TradingAgents, confirme que TradingAgentsGraph funciona localmente, agregue POST /analyses y GET /analyses/{id}, luego importe el esquema en Apidog y construya un escenario de principio a fin. Ese camino es mucho más fácil de mantener que una colección de comandos de terminal y conocimiento tribal.

botón

Preguntas Frecuentes

¿Cómo se usa TradingAgents por primera vez?

Comience instalando el repositorio, configurando las variables de entorno del proveedor del modelo y ejecutando el ejemplo de Python con TradingAgentsGraph. Una vez que funcione, decida si solo necesita la CLI o si debe envolverlo en una API.

¿TradingAgents viene con una API REST oficial?

No según los materiales del repositorio público revisados el 26 de marzo de 2026. El proyecto se presenta como una CLI y un paquete de Python, por lo que muchos equipos querrán agregar una fina capa de FastAPI.

¿Cuál es la forma más fácil de usar TradingAgents en una aplicación frontend?

No llame al framework de Python directamente desde el frontend. Expóngalo a través de una API de backend que devuelva un analysis_id, y luego permita que el frontend consulte los resultados.

¿Por qué usar Apidog con TradingAgents?

Apidog le ofrece un lugar limpio para importar el esquema OpenAPI, guardar valores de entorno, almacenar solicitudes de ejemplo, agregar aserciones y compartir el flujo de trabajo con compañeros de equipo que no deberían tener que realizar ingeniería inversa del código Python.

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

El conjunto inicial más seguro es el símbolo bursátil, la fecha de análisis, el proveedor, las opciones de modelo y la profundidad de la investigación. Siempre puede expandirlo más tarde si el caso de uso es real.

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

Solo para aprendizaje o creación de prototipos. En producción, almacene el estado del trabajo en Redis, Postgres u otro backend duradero para que un reinicio del servicio no borre los análisis activos.

¿Es TradingAgents adecuado para decisiones financieras en vivo?

Los materiales del proyecto público lo describen como un framework de investigación y dicen explícitamente que no es asesoramiento financiero o de inversión. Trátelo como un sistema de investigación y experimentación a menos que agregue sus propios controles, validación y gobernanza.