DEV Community

Cover image for Cara Mengubah TradingAgent Menjadi Alur Kerja API Trading Nyata
Walse
Walse

Posted on • Originally published at apidog.com

Cara Mengubah TradingAgent Menjadi Alur Kerja API Trading Nyata

TL;DR / Jawaban Cepat

Cara tercepat dan paling praktis untuk menggunakan TradingAgents adalah menjalankannya sebagai paket Python, membungkusnya dalam layanan kecil FastAPI, lalu menguji endpoint-nya di Apidog. Dengan cara ini, Anda punya alur kerja yang dapat diulang untuk memicu analisis, polling hasilnya, mendokumentasikan kontrak request, dan membagikan pengaturan ke tim Anda.

Coba Apidog hari ini

Pendahuluan

TradingAgents memang terlihat menarik di permukaan. Repositori GitHub-nya memperlihatkan alur kerja multi-agen, CLI yang simpel, dukungan banyak penyedia model, dan paper desain kerangka kerjanya. Tantangan sebenarnya adalah saat Anda ingin mengintegrasikannya ke dalam workflow engineering nyata.

Kebanyakan tim tidak mau sekadar menjalankan repo lokal oleh satu developer. Mereka butuh cara repeatable untuk trigger analisis dengan memasukkan ticker dan tanggal, mendapatkan job ID, polling hasilnya nanti, dan menyerahkan workflow tersebut ke frontend, QA, atau tim platform—tanpa harus debugging Python tiap kali ada request. Karena sistem riset trading akan dipakai untuk pengambilan keputusan penting, membungkus TradingAgents dalam API yang terdokumentasi jauh lebih aman daripada membiarkannya sebagai script lokal.

💡 Apidog sangat pas untuk workflow ini. Anda bisa impor skema OpenAPI dari FastAPI, membuat environment untuk deployment lokal/remote, ekstrak variabel dari response, merangkai polling ke dalam skenario, dan publish dokumentasi ke tim. Download Apidog gratis untuk mulai.

Apa Itu dan Bukan TradingAgents

Sebelum coding, pahami dulu scope alat ini.

TradingAgents Roles

TradingAgents adalah kerangka kerja multi-agen open source. Repo-nya membagi peran seperti:

  • analis fundamental, sentimen, berita, teknikal
  • peneliti bullish & bearish (untuk debat)
  • agen trader
  • manajemen risiko
  • manajer portofolio (keputusan akhir)

Workflow TradingAgents

TradingAgents dibangun dengan LangGraph, mendukung beberapa penyedia model (OpenAI, Google, Anthropic, xAI, OpenRouter, Ollama). Konfigurasi default umumnya:

  • 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

Artinya: ini framework Python yang bisa dikonfigurasi, bukan SaaS API siap pakai.

Repositori juga menegaskan bahwa ini framework riset, bukan saran finansial. Jika membangun software di atasnya, pastikan framing ini tetap jelas di dokumen dan UX Anda.

Langkah 1: Instal TradingAgents

Setup dasar dari 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

Jika ingin membangun wrapper API, tambahkan FastAPI & Uvicorn:

pip install fastapi uvicorn
Enter fullscreen mode Exit fullscreen mode

TradingAgents menyediakan file .env.example untuk API key:

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

Praktik penting:

  1. Simpan credential di environment variable/secret manager.
  2. Jangan pernah mengirim API key lewat body request publik.

Ini akan menjaga environment Apidog tetap bersih dan model security Anda lebih aman.

Langkah 2: Jalankan TradingAgents di Python Terlebih Dahulu

Sebelum membangun API wrapper, pastikan dulu core framework bisa jalan di environment Anda.

Contoh minimal dari README:

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

Kalau sudah berhasil, Anda bisa lanjut ke konfigurasi lebih lanjut. Misal override config:

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

Parameter yang perlu diekspose nanti di API:

  • ticker
  • analysis_date
  • llm_provider
  • deep_think_llm
  • quick_think_llm
  • max_debate_rounds

Jangan lompat ke HTTP sebelum Python lokal Anda benar-benar jalan.

Langkah 3: Tentukan Cara Menggunakan TradingAgents

Ada tiga pola utama:

Pilihan 1: CLI Saja

Cocok untuk eksplorasi cepat, eksperimen solo, atau learning. Tidak cocok untuk workflow tim.

Pilihan 2: Hanya Python

Panggil TradingAgentsGraph dari Python—bagus untuk notebook/otomasi lokal. Tidak cukup jika workflow dipakai banyak tim.

Pilihan 3: API Wrapper + Apidog

Ini paling scalable. Jadikan TradingAgents mesin eksekusi, expose via FastAPI, lalu tes & dokumentasikan di Apidog.

Gunakan pola ini jika:

  • frontend butuh trigger analisis
  • QA ingin workflow repeatable
  • butuh environment, assertion, dokumentasi terpusat
  • workflow lama, perlu polling job, bukan sync request

Di sini, TradingAgents benar-benar siap dipakai tim.

Langkah 4: Bungkus TradingAgents dengan FastAPI

Gunakan pola API berbasis job:

POST /analyses    -> return analysis_id
GET /analyses/{id} -> return status/result
Enter fullscreen mode Exit fullscreen mode

Struktur ini lebih mudah untuk browser, QA, dan dokumentasi di Apidog.

Kontrak API Minimal

Endpoint Tujuan
GET /health Pemeriksaan kesehatan
POST /analyses Memicu analisis TradingAgents
GET /analyses/{id} Mendapatkan status dan hasil analisis

Contoh Wrapper 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
Enter fullscreen mode Exit fullscreen mode

Jalankan server:

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

FastAPI akan expose:

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

OpenAPI JSON bisa langsung diimpor ke Apidog.

Langkah 5: Konsumsi TradingAgents via API

Trigger Analisis

Kirim request ke POST /analyses:

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

Respons (cepat dan minimal):

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

Polling Hasil

Cek dengan 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"
}
Enter fullscreen mode Exit fullscreen mode

Jika sudah selesai:

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

Jika error, status akan jadi failed lengkap dengan pesan error.

Langkah 6: Impor API ke Apidog

Di Apidog, impor skema OpenAPI dari:

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

Keuntungannya:

  • Dokumentasi selalu update sesuai implementasi
  • Parameter dan body sesuai dengan kode
  • Tidak perlu setup collection manual
  • Tim lain bisa langsung pakai

Apidog jadi satu titik untuk desain, testing, environment, dan dokumentasi.

Langkah 7: Buat Environment Apidog

Setelah API diimpor, buat environment, misal:

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

Jika pakai autentikasi:

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

Manfaat:

  • Mudah switch antara lokal, staging, production
  • Request reusable
  • Tim tidak perlu menulis ulang URL/header

Apidog membantu workflow bersama, sementara TradingAgents fokus di logic analisis.

Langkah 8: Uji Alur Kerja di Apidog

Permintaan 1: Buat Analisis

  • 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
}
Enter fullscreen mode Exit fullscreen mode

Script pengujian:

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

Permintaan 2: Polling Analisis

  • 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);
});
Enter fullscreen mode Exit fullscreen mode

Cek hasil sukses:

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

Rangkai Permintaan ke Skenario

Skenario:

  1. Kirim POST /analyses
  2. Store analysis_id
  3. Tunggu beberapa detik
  4. Jalankan GET /analyses/{{analysis_id}}

Memberi QA dan engineer cara repeatable untuk validasi lifecycle, bukan sekadar cek 200 OK.

Langkah 9: Publikasikan Dokumentasi Internal

Setelah request berhasil, lanjutkan dengan publish dokumentasi internal di Apidog:

  • Penyedia yang diizinkan
  • Arti research_depth
  • Status yang diharapkan
  • Estimasi waktu proses
  • Error yang bisa dicoba ulang
  • Disclaimer riset

Jangan biarkan kontrak hanya di kepala satu developer. Dokumentasi internal penting agar workflow bisa diadopsi tim.

Unduh Apidog gratis untuk ubah TradingAgents jadi workflow API terdokumentasi dengan environment, assertion, dan skenario siap pakai tim.

Kesalahan Umum Menggunakan TradingAgents Seperti Ini

Menganggap Framework Ini API Hosted

TradingAgents adalah framework Python, bukan public API. Bangun kontrak API sendiri sesuai kebutuhan tim.

Mengirim Credential via Body Request

Simpan credentials di environment, jangan dikirim di body permintaan, UI, atau screenshot.

Satu Respons Sinkron yang Panjang

Untuk workflow multi-langkah, gunakan pattern job-based (queue & polling), bukan blocking request panjang.

Mengekspos Terlalu Banyak Konfigurasi

Ekspos hanya konfigurasi penting di API (ticker, tanggal, model, depth). Tambahkan lain-lain jika diperlukan.

Menyimpan Hasil Hanya di Memori

Tutorial pakai in-memory dict untuk simplicity. Di produksi, simpan job status di Redis, Postgres, atau backend persistent lain.

Mengabaikan Disclaimer Riset

Framework ini untuk riset/eksperimen, bukan saran finansial. Selalu tampilkan disclaimer sesuai repo aslinya.

Kesimpulan

Cara terbaik menggunakan TradingAgents tergantung kebutuhan. Untuk eksplorasi, cukup CLI/Python. Untuk workflow tim yang repeatable, bungkus dalam API dan dokumentasikan di Apidog.

Jika ingin workflow tim yang siap pakai:

  1. Install TradingAgents
  2. Pastikan TradingAgentsGraph jalan lokal
  3. Tambah endpoint POST /analyses & GET /analyses/{id}
  4. Impor skema ke Apidog
  5. Bangun skenario end-to-end

Alur ini jauh lebih maintainable daripada kumpulan perintah terminal/manual.

FAQ

Bagaimana cara pertama kali menggunakan TradingAgents?

Install repo, atur environment variable API key, jalankan contoh Python dengan TradingAgentsGraph. Setelah itu, tentukan apakah cukup CLI atau perlu membungkus dalam API.

Apakah TradingAgents punya REST API resmi?

Tidak (per 26 Maret 2026). Proyeknya CLI & Python package. Kebanyakan tim bikin lapisan FastAPI sendiri.

Bagaimana cara termudah pakai TradingAgents di aplikasi frontend?

Jangan panggil Python langsung dari frontend. Expose ke backend API yang mengembalikan analysis_id, lalu frontend polling hasilnya.

Kenapa gunakan Apidog dengan TradingAgents?

Apidog menyediakan tempat untuk import OpenAPI, simpan environment, contoh request, assertion, dan share workflow ke tim tanpa perlu reverse engineering kode Python.

Setting TradingAgents apa yang layak diekspose di API?

Awali dengan: ticker, tanggal analisis, penyedia, pilihan model, dan depth riset. Tambahkan jika ada kebutuhan nyata.

Bolehkah status job disimpan di memori?

Hanya untuk prototipe. Di produksi, simpan status & hasil di backend yang persistent.

Apakah TradingAgents cocok untuk keputusan keuangan langsung?

Tidak. Ini framework riset, bukan saran keuangan/investasi. Perlakukan sebagai sistem eksperimen kecuali Anda sudah menambah kontrol, validasi, dan tata kelola sendiri.

Top comments (0)