วิธีเปลี่ยน TradingAgents เป็นเวิร์กโฟลว์ Trading API จริง

TL;DR / สรุปอย่างรวดเร็ว

วิธีที่รวดเร็วที่สุดในการใช้งาน TradingAgents คือการรันเป็นแพ็กเกจ Python ห่อด้วยบริการ FastAPI ขนาดเล็ก จากนั้นทดสอบบริการนั้นใน Apidog ซึ่งจะทำให้คุณมีขั้นตอนการทำงานที่ทำซ้ำได้สำหรับการเรียกใช้การวิเคราะห์ การตรวจสอบผลลัพธ์ การจัดทำเอกสารข้อตกลงการร้องขอ และการแบ่งปันการตั้งค่ากับทีมของคุณ

ทดลองใช้ Apidog วันนี้

บทนำ

TradingAgents เป็นสิ่งที่น่าชื่นชมจากภายนอก GitHub repository แสดงเวิร์กโฟลว์การซื้อขายแบบหลายเอเจนต์, CLI ที่สวยงาม, รองรับผู้ให้บริการโมเดลหลายราย และเอกสารงานวิจัยที่อธิบายการออกแบบเฟรมเวิร์ก ส่วนที่ยากขึ้นจะเริ่มต้นเมื่อคุณพยายามนำไปใช้งานจริงในเวิร์กโฟลว์ทางวิศวกรรม

ทีมส่วนใหญ่ไม่ต้องการ repo ที่มีนักพัฒนาเพียงคนเดียวที่สามารถรันได้ในเครื่อง พวกเขาต้องการวิธีที่ทำซ้ำได้ในการเรียกใช้การวิเคราะห์, ส่ง ticker และวันที่, ส่งคืน ID ของงาน, ตรวจสอบผลลัพธ์ในภายหลัง และส่งมอบเวิร์กโฟลว์นั้นให้กับทีมส่วนหน้า, QA หรือแพลตฟอร์ม โดยไม่ต้องเปลี่ยนทุกคำถามให้เป็นการแก้ไขข้อผิดพลาดใน Python และเนื่องจากระบบวิจัยการซื้อขายใด ๆ จะถูกนำไปใช้เพื่อประกอบการตัดสินใจเกี่ยวกับเงินจริงในที่สุด การห่อหุ้ม TradingAgents ใน API ที่ควบคุมได้และมีเอกสารกำกับจึงมีความสำคัญยิ่งกว่าการปล่อยให้เป็นสคริปต์แบบใช้แล้วทิ้งบนแล็ปท็อปของใครบางคน

💡 Apidog เข้ากันได้อย่างลงตัวกับเวิร์กโฟลว์นี้ คุณสามารถนำเข้าสคีมา OpenAPI จาก FastAPI, บันทึกสภาพแวดล้อมสำหรับการปรับใช้ทั้งในเครื่องและระยะไกล, แยกตัวแปรจากการตอบกลับ, เชื่อมโยงคำขอ polling เข้าเป็น scenario, และเผยแพร่เอกสารสำหรับทีมที่เหลือของคุณ

TradingAgents คืออะไร และไม่ใช่หรือไม่ใช่

ก่อนที่คุณจะเริ่มเขียนโค้ด การกำหนดเครื่องมือให้ถูกต้องจะช่วยได้

TradingAgents เป็นเฟรมเวิร์กการซื้อขายแบบหลายเอเจนต์โอเพนซอร์ส repository อธิบายชุดบทบาทพิเศษที่สะท้อนโครงสร้างของบริษัทซื้อขาย:

• นักวิเคราะห์สำหรับการวิเคราะห์พื้นฐาน, ความรู้สึก, ข่าวสาร, และสัญญาณทางเทคนิค
• นักวิจัยฝั่งบวกและฝั่งลบสำหรับการอภิปราย
• เอเจนต์ผู้ค้า
• บทบาทการบริหารความเสี่ยง
• ผู้จัดการพอร์ตโฟลิโอสำหรับการตัดสินใจขั้นสุดท้าย

Repo ยังระบุด้วยว่าเฟรมเวิร์กนี้สร้างขึ้นด้วย LangGraph และรองรับผู้ให้บริการโมเดลหลายราย เช่น OpenAI, Google, Anthropic, xAI, OpenRouter และ Ollama ตัวอย่างค่าคอนฟิกเริ่มต้น:

• 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

สำคัญ: นี่คือเฟรมเวิร์ก Python ที่ปรับแต่งได้ ไม่ใช่ API SaaS พร้อมใช้

Repo เน้นย้ำขอบเขต TradingAgents เป็นเฟรมเวิร์กการวิจัย ไม่ใช่คำแนะนำทางการเงิน หากนำไปใช้ในองค์กรหรือสร้างซอฟต์แวร์รอบ ๆ ให้ระบุจุดนี้ในเอกสารและ UX ของคุณด้วย

ขั้นตอนที่ 1: ติดตั้ง TradingAgents

ตั้งค่า environment ด้วยคำสั่งนี้:

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

เพิ่ม FastAPI และ Uvicorn หากจะสร้าง API wrapper:

pip install fastapi uvicorn

ตั้งค่าตัวแปร .env (ดูตัวอย่างใน .env.example):

OPENAI_API_KEY=
GOOGLE_API_KEY=
ANTHROPIC_API_KEY=
XAI_API_KEY=
OPENROUTER_API_KEY=

คำแนะนำด้านความปลอดภัย:

1. เก็บข้อมูลรับรองไว้ใน environment variable หรือ secret manager
2. อย่าส่ง secret เหล่านี้ผ่าน body ของ API สาธารณะ

ขั้นตอนที่ 2: รัน TradingAgents ใน 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)

สำหรับ config แบบ custom:

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)

พารามิเตอร์เหล่านี้ควรเปิดเผยใน API ต่อไป:

• ticker
• analysis_date
• llm_provider
• deep_think_llm
• quick_think_llm
• research_depth

แนะนำให้ทดสอบขั้นตอนนี้ก่อนสร้าง API wrapper เพื่อแก้ปัญหาได้ง่ายกว่า

ขั้นตอนที่ 3: ตัดสินใจว่าจะใช้ TradingAgents อย่างไร

มี 3 ตัวเลือกหลัก:

ตัวเลือกที่ 1: CLI เท่านั้น

ใช้ CLI ของ repo เพื่อสำรวจและทดลอง เหมาะสำหรับการลองส่วนตัว ไม่เหมาะกับงานร่วมทีม

ตัวเลือกที่ 2: Python เท่านั้น

เรียกใช้งานผ่าน Python script เหมาะกับ automation/local notebook ใช้ได้เมื่อ workflow เป็นของ dev คนเดียว

ตัวเลือกที่ 3: API wrapper + Apidog

ชั้น wrapper (FastAPI) + ทดสอบ/จัดเอกสารใน Apidog เหมาะสำหรับการใช้งานร่วมกับ frontend, QA, หรือทีมอื่น ๆ ที่ต้องการ workflow ซ้ำได้

ขั้นตอนที่ 4: ห่อหุ้ม TradingAgents ในบริการ FastAPI

ใช้รูปแบบ job-based API:

POST /analyses -> ส่งคืน analysis_id
GET /analyses/{id} -> สถานะ: queued, running, completed, failed

สัญญา API ขั้นต่ำ

Endpoint	วัตถุประสงค์
GET /health	ตรวจสอบสถานะ
POST /analyses	สร้างงานวิเคราะห์
GET /analyses/{analysis_id}	ตรวจสอบสถานะและผลลัพธ์

ตัวอย่าง 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

เริ่มเซิร์ฟเวอร์:

uvicorn app:app --reload

FastAPI จะเปิดเผย:

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

ขั้นตอนที่ 5: ใช้ TradingAgents ผ่าน API

สร้างการวิเคราะห์

ส่ง POST /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
}

การตอบกลับ:

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

ตรวจสอบผลลัพธ์

GET /analyses/{analysis_id}

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

เมื่อเสร็จสิ้น:

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

ขั้นตอนที่ 6: นำเข้า API เข้าสู่ Apidog

นำเข้าสคีมา OpenAPI จาก:

http://localhost:8000/openapi.json

ประโยชน์:

• เอกสารถูกต้อง
• โครงสร้าง request/response ตรงกับ implementation
• ไม่ต้องสร้าง collection ใหม่เอง

ขั้นตอนที่ 7: สร้างสภาพแวดล้อม Apidog

ตัวอย่าง environment:

base_url = http://localhost:8000
analysis_id =

ถ้ามี API key:

internal_api_key = your-local-dev-key

ข้อดี:

• สลับ environment (dev/staging/prod) ได้สะดวก
• คำขอซ้ำได้
• ทีมไม่ต้องแก้ header/URL ใหม่ทุกครั้ง

ขั้นตอนที่ 8: ทดสอบเวิร์กโฟลว์ทั้งหมดใน Apidog

คำขอที่ 1: สร้างการวิเคราะห์

• 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
}

สคริปต์ทดสอบ:

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

คำขอที่ 2: ตรวจสอบสถานะการวิเคราะห์

• method: GET
• URL: {{base_url}}/analyses/{{analysis_id}}

Assertion:

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

เชื่อมโยงคำขอทั้งสองเข้าด้วยกันเป็น scenario

สร้าง scenario บน Apidog ที่รวม:

1. POST /analyses
2. เก็บ analysis_id
3. wait 2-5 วินาที
4. GET /analyses/{{analysis_id}}

สิ่งนี้ทำให้การทดสอบแบบ end-to-end ง่ายขึ้น

ขั้นตอนที่ 9: เผยแพร่เอกสารภายในสำหรับทีมของคุณ

ใช้ Apidog เพื่อสร้างเอกสาร API สำหรับทีม:

• ผู้ให้บริการที่รองรับ
• ความหมายของ research_depth
• สถานะงานที่ client ควรคาดหวัง
• ระยะเวลารอโดยทั่วไป
• กรณี error/retry
• ข้อควรระวังสำหรับงานวิจัย

---

ข้อผิดพลาดทั่วไปเมื่อใช้ TradingAgents ด้วยวิธีนี้

ปฏิบัติต่อเฟรมเวิร์กเหมือน API ที่โฮสต์อยู่

TradingAgents ไม่ใช่บริการสาธารณะ คุณต้องสร้าง API contract เอง

การส่งผ่านความลับผ่านเนื้อหาคำขอ

เก็บ secret ใน environment, อย่า hardcode หรือโชว์ในตัวอย่าง/frontend

ส่งคืนการตอบกลับแบบซิงโครนัสที่ยาวนานเพียงครั้งเดียว

สำหรับงานหลายขั้นตอน ใช้ job/polling ดีกว่ารอ sync response

เปิดเผยการตั้งค่าการกำหนดค่ามากเกินไป

API ไม่จำเป็นต้อง expose ทุก config เริ่มจากสัญญาเล็ก ๆ ก่อน

เก็บผลลัพธ์ไว้ในหน่วยความจำเท่านั้น

ตัวอย่าง code ใช้ dict ใน memory — production ควรใช้ Redis, Postgres ฯลฯ

ซ่อนคำเตือนการวิจัย

แจ้ง user ทุกครั้งว่าระบบนี้ใช้เพื่อวิจัย ไม่ใช่คำแนะนำการลงทุน

บทสรุป

วิธีที่ดีที่สุดในการใช้ TradingAgents ขึ้นอยู่กับเป้าหมายของคุณ ถ้าเน้นทดลอง CLI/Python ก็พอแล้ว ถ้าต้องการ workflow ที่มั่นคงสำหรับทีม ห่อเป็น API ด้วย FastAPI แล้วนำเข้า Apidog เพื่อจัดการทดสอบและเอกสาร

เปลี่ยนจาก repo บน GitHub สู่ workflow ที่ทีมใช้งานได้จริงภายในไม่กี่ขั้นตอน:

• ติดตั้ง TradingAgents
• ยืนยัน Python ตัวอย่างทำงาน
• เพิ่ม FastAPI wrapper
• นำเข้าสคีมาเข้า Apidog
• สร้าง scenario ทดสอบ end-to-end

คำถามที่พบบ่อย

คุณจะใช้ TradingAgents ครั้งแรกได้อย่างไร?

ติดตั้ง repo, ตั้งค่าตัวแปรผู้ให้บริการ, รัน Python ตัวอย่าง, แล้วเลือกว่าจะใช้ CLI หรือห่อ API

TradingAgents มาพร้อมกับ REST API อย่างเป็นทางการหรือไม่?

ไม่มี API อย่างเป็นทางการ ณ วันที่ 26 มีนาคม 2026 ต้องสร้างเองด้วย FastAPI หรือคล้ายกัน

วิธีที่ง่ายที่สุดในการใช้ TradingAgents ในแอปพลิเคชันส่วนหน้าคืออะไร?

อย่าเรียก Python ตรง ๆ จาก frontend แต่ให้ backend เปิด API ส่งคืน analysis_id แล้ว polling หาผลลัพธ์

ทำไมต้องใช้ Apidog กับ TradingAgents?

Apidog ช่วยนำเข้าสคีมา OpenAPI, เก็บ environment, สร้างตัวอย่าง, assertion, และแชร์ workflow กับทีมโดยไม่ต้องอ่าน/แก้ Python โดยตรง

การตั้งค่า TradingAgents ใดบ้างที่ควรเปิดเผยใน API?

เบื้องต้น: ticker, analysis_date, llm_provider, ตัวเลือกโมเดล, research_depth ขยายเพิ่มได้ตาม use-case

ฉันสามารถเก็บสถานะงานตัวอย่างไว้ในหน่วยความจำได้หรือไม่?

สำหรับ dev/prototype ได้ แต่ production ต้องใช้ store ที่ทนทาน (เช่น Redis/Postgres)

TradingAgents เหมาะสำหรับการตัดสินใจทางการเงินแบบเรียลไทม์หรือไม่?

เอกสารโครงการระบุชัดว่า "สำหรับวิจัย" เท่านั้น ไม่ใช่คำแนะนำการลงทุน ใช้สำหรับทดลอง/วิจัยเท่านั้น

---

เริ่มต้นสร้าง API สำหรับเวิร์กโฟลว์ TradingAgents ของคุณ และจัดการทดสอบ–เอกสารอย่างง่ายด้วย Apidog