Hướng Dẫn Biến Trading Agents Thành Quy Trình API Giao Dịch Thực Tế

Để triển khai TradingAgents một cách hiệu quả trong môi trường phát triển, bạn nên đóng gói nó dưới dạng một gói Python, xây dựng một API FastAPI nhỏ, và kiểm thử các endpoint này bằng Apidog. Cách tiếp cận này giúp bạn dễ dàng lặp lại việc kích hoạt phân tích, kiểm tra kết quả, ghi tài liệu hợp đồng API, đồng thời chia sẻ quy trình với đội frontend, QA, nền tảng mà không phải chuyển mỗi câu hỏi thành một phiên debug Python.

Dùng thử Apidog ngay hôm nay

Tổng quan về TradingAgents

TradingAgents là framework giao dịch đa tác nhân mã nguồn mở, mô phỏng cấu trúc một công ty giao dịch thực tế với các vai trò:

• Nhà phân tích (fundamental, sentiment, news, technical)
• Nhà nghiên cứu bull/bear
• Tác nhân giao dịch
• Quản lý rủi ro
• Quản lý danh mục đầu tư

Framework này xây dựng trên nền LangGraph, hỗ trợ nhiều provider mô hình như OpenAI, Google, Anthropic, xAI, OpenRouter, Ollama.

Ví dụ cấu hình mặc định:

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

TradingAgents là framework nghiên cứu, không phải lời khuyên tài chính. Khi xây dựng sản phẩm hoặc tích hợp nội bộ, hãy giữ rõ ràng tuyên bố này trong tài liệu.

Bước 1: Cài đặt TradingAgents

Clone repository và thiết lập môi trường Python:

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

Để xây dựng API wrapper, cài thêm FastAPI và Uvicorn:

pip install fastapi uvicorn

Copy .env.example và điền các biến API key cần thiết:

OPENAI_API_KEY=
GOOGLE_API_KEY=
ANTHROPIC_API_KEY=
XAI_API_KEY=
OPENROUTER_API_KEY=

Lưu ý:

• Luôn giữ secret/API key trong biến môi trường hoặc secret manager.
• Không truyền secret vào payload API.

Bước 2: Kiểm thử TradingAgents trực tiếp bằng Python

Đầu tiên, xác thực framework hoạt động trên môi trường của bạn:

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)

Kiểm thử ghi đè cấu hình:

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)

Các tham số đáng cân nhắc cho API:

ticker, analysis_date, llm_provider, deep_think_llm, quick_think_llm, max_debate_rounds

Bước 3: Chọn cách tích hợp TradingAgents

• CLI: Thích hợp để khám phá nhanh hoặc thử nghiệm solo.
• Python trực tiếp: Linh hoạt cho automation cục bộ, notebook, hoặc kịch bản dev.
• API + Apidog: Dùng FastAPI làm wrapper, kiểm thử và ghi tài liệu với Apidog. Đây là cách phù hợp nhất cho teamwork, frontend, QA.

Bước 4: Đóng gói TradingAgents với FastAPI

Mô hình API tốt nhất là dựa trên job (asynchronous), gồm:

• POST /analyses → trả về analysis_id
• GET /analyses/{id} → trả về trạng thái và kết quả

Bản hợp đồng API tối thiểu:

Điểm cuối	Mục đích
GET /health	Kiểm tra sức khỏe
POST /analyses	Tạo một lần phân tích TradingAgents
GET /analyses/{analysis_id}	Lấy trạng thái và kết quả phân tích

Ví dụ FastAPI wrapper:

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

Chạy dịch vụ:

uvicorn app:app --reload

• Truy cập http://localhost:8000/docs để kiểm thử trực tiếp.
• Tải schema OpenAPI tại http://localhost:8000/openapi.json để import vào Apidog.

Bước 5: Sử dụng TradingAgents qua API

Tạo phân tích:

POST /analyses
Content-Type: application/json

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

Phản hồi:

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

Kiểm tra trạng thái/kết quả:

GET /analyses/{analysis_id}

Phản hồi:

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

Khi hoàn thành:

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

Nếu lỗi:

{
  "status": "failed",
  "error": "Chi tiết lỗi..."
}

Bước 6: Import API vào Apidog

Trong Apidog, chọn import OpenAPI schema từ:

http://localhost:8000/openapi.json

Lợi ích:

• Tự động tạo endpoint, request/response schema.
• Dễ dàng chia sẻ cho team.
• Tài liệu luôn khớp triển khai thực tế.

Bước 7: Tạo môi trường Apidog

Tạo một môi trường (environment) ví dụ:

base_url = http://localhost:8000
analysis_id =
internal_api_key = (nếu có)

Giúp chuyển đổi giữa local/staging/production nhanh chóng, không cần sửa tay URL và headers.

Bước 8: Kiểm thử end-to-end trong Apidog

Yêu cầu 1: Tạo phân tích

• Method: POST
• URL: {{base_url}}/analyses
• Body:

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

• Test script:

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);

Yêu cầu 2: Thăm dò kết quả

• Method: GET
• URL: {{base_url}}/analyses/{{analysis_id}}
• Test script:

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

Xâu chuỗi request:

Kết hợp hai request thành một kịch bản, giúp QA hoặc dev xác thực toàn bộ vòng đời job, không chỉ kiểm thử HTTP code.

Bước 9: Xuất bản tài liệu nội bộ với Apidog

Sau khi automation hoạt động, sử dụng tính năng publish của Apidog để:

• Ghi chú các provider allowed
• Giải thích ý nghĩa research_depth
• Làm rõ các giá trị status
• Ước lượng thời gian phân tích
• Chỉ ra các lỗi có thể retry
• Thêm cảnh báo nghiên cứu, không dùng cho tư vấn tài chính

Các lỗi thường gặp khi triển khai TradingAgents dạng này

• Nhầm framework là SaaS: TradingAgents là Python package, không phải public API. Hãy tự định nghĩa contract API cho nhóm.
• Truyền API key qua request body: Chỉ nên giữ key ở config/môi trường, không truyền qua payload hoặc log.
• Phản hồi đồng bộ lâu: Đối với job nhiều bước, API async (job-based) dễ quản lý hơn.
• Lộ quá nhiều config: Chỉ expose các tham số cần thiết cho use-case ban đầu.
• Lưu job state vào memory: Prototype thì được, production nên dùng Redis/Postgres.
• Ẩn cảnh báo nghiên cứu: Luôn giữ cảnh báo “chỉ dùng thử nghiệm, không phải tư vấn đầu tư”.

Tổng kết

• Nếu bạn chỉ thử nghiệm cá nhân, dùng CLI hoặc Python module.
• Muốn teamwork, frontend, QA, hãy đóng gói thành API nhỏ, test và document bằng Apidog.
• Lộ trình đơn giản: cài đặt TradingAgents → test TradingAgentsGraph local → thêm endpoint POST /analyses, GET /analyses/{id} → import OpenAPI vào Apidog → xây dựng kịch bản kiểm thử.

Cách này giúp bạn chuyển từ repo GitHub sang workflow teamwork thực tế, dễ bảo trì hơn nhiều so với các script lẻ tẻ.

Câu hỏi thường gặp

Làm thế nào để bắt đầu với TradingAgents?

Cài repo, set biến môi trường API key, test example Python với TradingAgentsGraph. Nếu cần workflow teamwork, đóng gói thành API.

TradingAgents có API REST chính thức không?

Không. Bạn phải tự build FastAPI wrapper.

Dùng TradingAgents cho frontend/UI thế nào?

Luôn qua backend API trả về analysis_id. Giao diện chỉ thăm dò kết quả qua API, không gọi trực tiếp Python.

Tại sao nên dùng Apidog?

Apidog giúp import schema OpenAPI, lưu môi trường, sample requests, kiểm thử, xác thực, chia sẻ với đồng đội không cần biết sâu Python code.

Tham khảo Apidog tại đây

Nên expose tham số nào cho API?

Tối thiểu: mã chứng khoán, ngày phân tích, provider, model, độ sâu research. Có thể mở rộng theo use-case thực tế.

Lưu job state ở đâu?

Chỉ giữ trong RAM khi test/prototype. Production nên dùng Redis/Postgres để không mất job khi restart.

Dùng TradingAgents để quyết định tài chính thật có ổn không?

Không. Đây là công cụ nghiên cứu, không phải khuyến nghị đầu tư. Nếu dùng cho production, cần bổ sung kiểm soát, review, governance riêng.

---

Dùng thử Apidog ngay hôm nay: https://apidog.com/?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation

Chuyển TradingAgents thành workflow API chuyên nghiệp, tài liệu rõ ràng, dễ bảo trì cho cả team.