Cara Mengubah TradingAgent Menjadi Alur Kerja API Trading Nyata

TL;DR / Jawaban Cepat

Cara praktis tercepat untuk menggunakan TradingAgents adalah menjalankannya sebagai paket Python, membungkusnya dalam layanan FastAPI kecil, lalu menguji layanan tersebut di Apidog. Ini memberi Anda alur kerja yang dapat diulang untuk memicu analisis, melakukan polling untuk hasil, mendokumentasikan kontrak permintaan, dan berbagi pengaturan dengan tim Anda.

Pendahuluan

TradingAgents mudah dikagumi dari luar. Repositori GitHub menunjukkan alur kerja perdagangan multi-agen, CLI yang rapi, dukungan untuk beberapa penyedia model, dan makalah penelitian yang menjelaskan desain kerangka kerja. Bagian yang lebih sulit dimulai ketika Anda mencoba menggunakannya dalam alur kerja rekayasa nyata.

Sebagian besar tim tidak menginginkan repositori yang hanya dapat dijalankan oleh satu pengembang secara lokal. Mereka menginginkan cara yang dapat diulang untuk memicu analisis, memasukkan ticker dan tanggal, mengembalikan ID pekerjaan, memeriksa hasilnya nanti, dan menyerahkan alur kerja itu kepada rekan tim frontend, QA, atau platform tanpa mengubah setiap pertanyaan menjadi sesi debug Python. Dan karena sistem penelitian perdagangan apa pun pada akhirnya akan digunakan untuk menginformasikan keputusan uang riil, bahkan lebih penting untuk membungkus TradingAgents dalam API yang terkontrol dan terdokumentasi daripada membiarkannya sebagai skrip sekali pakai di laptop seseorang.

💡

Apidog sangat cocok dengan alur kerja ini. Anda dapat mengimpor skema OpenAPI dari FastAPI, menyimpan lingkungan untuk deployment lokal dan jarak jauh, mengekstrak variabel dari respons, merangkai permintaan polling ke dalam skenario, dan menerbitkan dokumen untuk sisa tim Anda. Unduh Apidog gratis untuk mengikuti.

tombol

Apa Itu dan Bukan TradingAgents

Sebelum Anda mulai coding, ada baiknya untuk mendefinisikan alat ini secara akurat.

TradingAgents adalah kerangka perdagangan multi-agen sumber terbuka. Repositori ini menjelaskan serangkaian peran khusus yang mencerminkan struktur sebuah perusahaan perdagangan:

analis untuk fundamental, sentimen, berita, dan sinyal teknis
peneliti bullish dan bearish untuk debat
agen pedagang
peran manajemen risiko
manajer portofolio untuk keputusan akhir

Repositori tersebut juga menyatakan bahwa kerangka kerja ini dibangun dengan LangGraph dan mendukung beberapa penyedia model, termasuk OpenAI, Google, Anthropic, xAI, OpenRouter, dan Ollama. Dalam konfigurasi default publik, proyek saat ini menggunakan nilai-nilai seperti:

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

Hal ini penting karena memberitahu Anda apa yang sebenarnya Anda gunakan: kerangka kerja Python yang dapat dikonfigurasi, bukan API SaaS siap pakai.

Repositori ini juga berhati-hati mengenai cakupannya. TradingAgents disajikan sebagai kerangka kerja penelitian, bukan nasihat keuangan. Jika Anda menggunakannya secara internal atau membangun perangkat lunak di sekitarnya, jaga agar pembingkaian tersebut terlihat dalam dokumen dan pengalaman pengguna Anda.

Langkah 1: Instal TradingAgents

Mulai dengan pengaturan dari repositori itu sendiri:

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

Jika Anda juga ingin membangun wrapper API dari tutorial ini, tambahkan FastAPI dan Uvicorn:

pip install fastapi uvicorn

Repositori TradingAgents juga menyertakan file .env.example dengan variabel penyedia seperti:

OPENAI_API_KEY=
GOOGLE_API_KEY=
ANTHROPIC_API_KEY=
XAI_API_KEY=
OPENROUTER_API_KEY=

Tergantung pada pilihan model dan data Anda, Anda mungkin juga memerlukan kredensial vendor lain, seperti Alpha Vantage.

Dua aturan praktis penting di sini:

Simpan kredensial dalam variabel lingkungan atau pengelola rahasia.
Jangan meneruskan rahasia penyedia melalui body permintaan API publik Anda nanti.

Pemisahan itu akan membuat lingkungan Apidog Anda lebih bersih dan model keamanan Anda jauh lebih aman.

Langkah 2: Jalankan TradingAgents di Python Terlebih Dahulu

Sebelum Anda membangun wrapper API apa pun, buktikan bahwa kerangka kerja inti berjalan di lingkungan Anda.

README menunjukkan pola penggunaan Python minimal:

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)

Ini adalah titik pemeriksaan pertama yang tepat karena menjawab satu-satunya pertanyaan yang penting di awal: bisakah mesin Anda, pengaturan model, dan dependensi benar-benar menjalankan TradingAgents?

Jika itu berhasil, maka Anda dapat melanjutkan ke konfigurasi yang terkontrol. Repositori ini juga menunjukkan bahwa Anda dapat menimpa konfigurasi default:

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)

Contoh kedua itu lebih penting dari kelihatannya. Ini memberi tahu Anda parameter mana yang layak diekspos di API nanti:

ticker
analysis_date
llm_provider
deep_think_llm
quick_think_llm
kedalaman penelitian atau putaran debat

Jika Anda melewati fase Python lokal ini dan langsung melompat ke HTTP, Anda membuat debugging lebih sulit dari yang seharusnya.

Langkah 3: Putuskan Cara Anda Ingin Menggunakan TradingAgents

Pada titik ini, Anda memiliki tiga cara umum untuk menggunakan kerangka kerja tersebut.

Pilihan 1: Hanya CLI

Repositori ini menyertakan CLI interaktif di mana Anda dapat memilih ticker, tanggal, penyedia, dan kedalaman penelitian. Ini adalah cara yang baik untuk menjelajahi proyek dengan cepat.

Gunakan ini ketika:

Anda sedang mempelajari alat ini
Anda menjalankan eksperimen solo
Anda tidak memerlukan kontrak yang stabil untuk aplikasi lain

Jangan berhenti di sini jika langkah selanjutnya adalah frontend, alat admin, layanan bersama, atau alur kerja QA.

Pilihan 2: Hanya Python

Memanggil TradingAgentsGraph langsung dari Python lebih baik daripada CLI ketika Anda memerlukan orkestrasi kustom atau skrip lokal.

Gunakan ini ketika:

Anda menginginkan notebook atau otomatisasi lokal
Anda memerlukan kontrol terprogram
satu pengembang memiliki alur kerja dari awal hingga akhir

Ini masih kurang efektif ketika beberapa tim perlu menggunakan alur kerja.

Pilihan 3: Wrapper API plus Apidog

Ini adalah pengaturan tim yang paling berguna. Anda menjaga TradingAgents sebagai mesin eksekusi, mengeksposnya melalui layanan FastAPI kecil, dan menggunakan Apidog untuk menguji dan mendokumentasikan kontraknya.

Gunakan ini ketika:

frontend perlu memicu analisis
QA memerlukan alur permintaan yang dapat diulang
Anda menginginkan lingkungan, penegasan, dan dokumen di satu tempat
alur kerja mungkin berjalan cukup lama sehingga polling lebih masuk akal daripada satu permintaan sinkron

Bagi sebagian besar tim, inilah titik di mana "cara menggunakan TradingAgents" menjadi jawaban implementasi yang nyata daripada hanya demo lokal.

Langkah 4: Bungkus TradingAgents dalam Layanan FastAPI

Pola paling bersih untuk wrapper pertama adalah API berbasis pekerjaan.

Mengapa berbasis pekerjaan? Karena analisis multi-agen bisa memakan waktu cukup lama sehingga menahan satu permintaan tetap terbuka menjadi canggung bagi klien. Pola yang lebih baik adalah:

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

Struktur itu lebih mudah untuk browser, lebih mudah untuk QA, dan lebih mudah didokumentasikan di Apidog.

Buat kontrak API

Kontrak minimal terlihat seperti ini:

Endpoint	Tujuan
`GET /health`	pemeriksaan kesehatan dasar
`POST /analyses`	memicu jalannya TradingAgents
`GET /analyses/{analysis_id}`	mengambil status pekerjaan dan hasil akhir

Bangun wrapper

Berikut adalah contoh FastAPI yang ringkas:

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

Mulai layanan:

uvicorn app:app --reload

Setelah server aktif, FastAPI akan mengekspos:

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

URL kedua itu sangat berguna karena Apidog dapat mengimpornya secara langsung.

Langkah 5: Gunakan TradingAgents Melalui API

Sekarang Anda siap untuk menggunakan TradingAgents dengan cara yang terasa stabil dan dapat diulang.

Memicu analisis

Kirim permintaan POST /analyses dengan body seperti ini:

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

Responsnya harus cepat dan kecil:

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

Itulah yang persis Anda inginkan. Klien Anda tidak memerlukan laporan akhir segera. Klien memerlukan pegangan yang stabil untuk jalannya proses.

Lakukan polling untuk hasilnya

Gunakan GET /analyses/{analysis_id} untuk memeriksa kemajuan:

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

Ketika alur kerja selesai, respons dapat mencakup keputusan akhir:

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

Jika terjadi masalah, kembalikan status failed yang jelas dan pesan kesalahan alih-alih membiarkan klien menebak-nebak.

Langkah 6: Impor API ke Apidog

Di sinilah alur kerja menjadi jauh lebih mudah untuk dipelihara.

Di Apidog, impor skema OpenAPI dari:

http://localhost:8000/openapi.json

Setelah diimpor, Anda akan melihat endpoint Anda dengan struktur permintaan dan responsnya sudah tersedia.

Itu memberi Anda beberapa keuntungan langsung:

dokumen sesuai dengan implementasi
parameter path dihasilkan dengan benar
body permintaan tetap selaras dengan kode Anda
rekan tim tidak perlu membangun ulang koleksi secara manual

Jika Anda beralih dari pengujian cURL ad hoc, ini adalah peningkatan yang berarti. Jika Anda beralih dari alat khusus permintaan, di sinilah Apidog mulai lebih penting karena Anda dapat menyimpan desain, pengujian, lingkungan, dan dokumentasi di satu tempat.

Langkah 7: Buat Lingkungan Apidog

Setelah API diimpor, buat lingkungan untuk layanan lokal Anda.

Contoh variabel:

base_url = http://localhost:8000
analysis_id =

Jika API Anda menggunakan autentikasi, sertakan juga:

internal_api_key = your-local-dev-key

Langkah ini terlihat kecil, tetapi mencegah banyak friksi:

Anda dapat beralih antara lokal, staging, dan produksi lebih cepat
permintaan Anda tetap dapat digunakan kembali
rekan tim Anda tidak perlu menulis ulang URL dan header setiap saat

Ini adalah salah satu alasan paling sederhana mengapa Apidog adalah pendamping yang kuat untuk TradingAgents. Kerangka kerja itu sendiri menangani logika analisis. Apidog menangani alur kerja bersama di sekitarnya.

Langkah 8: Uji Alur Kerja Lengkap di Apidog

Sekarang Anda dapat menggunakan Apidog untuk menguji TradingAgents seperti yang akan dilakukan klien sungguhan.

Permintaan 1: Buat analisis

Konfigurasi:

metode: 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
}

Tambahkan skrip pengujian yang memvalidasi status dan menyimpan 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);

Permintaan 2: Polling analisis

Konfigurasi:

metode: GET
URL: {{base_url}}/analyses/{{analysis_id}}

Kemudian tambahkan penegasan seperti:

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

Jika Anda juga menginginkan pemeriksaan jalur sukses:

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

Rangkai kedua permintaan ke dalam skenario

Di sinilah Apidog menjadi lebih dari sekadar klien API. Bangun skenario yang:

mengirim POST /analyses
menyimpan analysis_id
menunggu beberapa detik
menjalankan GET /analyses/{{analysis_id}}

Itu memberi tim QA dan rekayasa Anda cara yang dapat direproduksi untuk memvalidasi siklus hidup alih-alih hanya memeriksa apakah satu endpoint mengembalikan 200.

Langkah 9: Publikasikan Dokumen Internal untuk Tim Anda

Setelah permintaan berhasil, jangan berhenti pada pengujian saja.

Gunakan Apidog untuk menerbitkan dokumentasi internal yang menjelaskan:

penyedia mana yang diizinkan
apa arti research_depth dalam deployment Anda
nilai status apa yang harus diharapkan klien
berapa lama waktu yang dibutuhkan untuk prosesnya
kesalahan mana yang dapat dicoba ulang
di mana berlaku penafian khusus penelitian

Ini adalah salah satu bagian terpenting dalam menggunakan TradingAgents dengan baik. Kerangka kerja inti memang cerdas, tetapi kerangka kerja yang cerdas menjadi hambatan tim ketika kontrak hanya ada di kepala satu pengembang.

Unduh Apidog gratis untuk mengubah TradingAgents menjadi alur kerja API yang terdokumentasi dengan lingkungan, penegasan, dan skenario yang siap digunakan tim.

Kesalahan Umum Saat Menggunakan TradingAgents dengan Cara Ini

Memperlakukan kerangka kerja seperti API yang dihosting

TradingAgents bukanlah layanan publik yang siap pakai. Ini adalah kerangka kerja Python. Bangun kontrak yang ingin Anda gunakan tim Anda alih-alih mengharapkan repositori menyediakannya untuk Anda.

Meneruskan rahasia melalui body permintaan

Simpan kunci penyedia dalam manajemen lingkungan. Jangan membocorkannya ke dalam contoh, panggilan frontend, atau tangkapan layar bersama.

Mengembalikan satu respons sinkron yang panjang

Untuk alur kerja agen multi-langkah, API berbasis pekerjaan biasanya lebih mudah dikelola daripada permintaan pemblokiran yang panjang.

Mengekspos terlalu banyak pilihan konfigurasi

Repositori memiliki opsi konfigurasi yang berguna, tetapi API Anda tidak perlu mengekspos setiap pengaturan internal pada hari pertama. Mulailah dengan kontrak yang kecil dan stabil.

Menyimpan hasil hanya di memori

Kode tutorial menggunakan kamus dalam memori karena mudah dipahami. Dalam produksi, simpan status pekerjaan di Redis, Postgres, atau backend yang tahan lama lainnya.

Menyembunyikan penafian penelitian

Jika layanan Anda membungkus TradingAgents, pertahankan peringatan yang sama yang digunakan proyek. Kerangka kerja ini adalah untuk penelitian dan eksperimen, bukan nasihat keuangan.

Kesimpulan

Cara terbaik untuk menggunakan TradingAgents tergantung pada apa yang ingin Anda lakukan. Jika Anda menjelajahi kerangka kerja sendirian, CLI dan paket Python sudah cukup. Jika Anda menginginkan alur kerja tim yang stabil dan dapat diulang, bungkus TradingAgents dalam API kecil dan gunakan Apidog untuk menguji dan mendokumentasikannya.

Jika Anda ingin beralih dari repositori GitHub ke alur kerja tim yang dapat digunakan dengan cepat, instal TradingAgents, konfirmasi TradingAgentsGraph berfungsi secara lokal, tambahkan POST /analyses dan GET /analyses/{id}, lalu impor skema ke Apidog dan bangun satu skenario end-to-end. Jalur itu jauh lebih mudah dipelihara daripada kumpulan perintah terminal dan pengetahuan lisan.

tombol

FAQ

Bagaimana cara pertama kali menggunakan TradingAgents?

Mulailah dengan menginstal repositori, mengatur variabel lingkungan penyedia model, dan menjalankan contoh Python dengan TradingAgentsGraph. Setelah itu berfungsi, putuskan apakah Anda hanya memerlukan CLI atau apakah Anda harus membungkusnya dalam API.

Apakah TradingAgents dilengkapi dengan REST API resmi?

Tidak dari materi repositori publik yang ditinjau pada 26 Maret 2026. Proyek ini disajikan sebagai CLI dan paket Python, itulah sebabnya banyak tim akan ingin menambahkan lapisan FastAPI tipis.

Apa cara termudah untuk menggunakan TradingAgents dalam aplikasi frontend?

Jangan memanggil kerangka kerja Python langsung dari frontend. Ekspos itu melalui API backend yang mengembalikan analysis_id, lalu biarkan frontend melakukan polling untuk hasilnya.

Mengapa menggunakan Apidog dengan TradingAgents?

Apidog memberi Anda tempat yang bersih untuk mengimpor skema OpenAPI, menyimpan nilai lingkungan, menyimpan contoh permintaan, menambahkan penegasan, dan berbagi alur kerja dengan rekan tim yang seharusnya tidak perlu merekayasa balik kode Python.

Pengaturan TradingAgents mana yang layak diekspos di API?

Set awal yang paling aman adalah ticker, tanggal analisis, penyedia, pilihan model, dan kedalaman penelitian. Anda selalu dapat memperluasnya nanti jika kasus penggunaan nyata.

Bisakah saya menyimpan status pekerjaan contoh di memori?

Hanya untuk pembelajaran atau prototipe. Dalam produksi, simpan status pekerjaan dan hasilnya di backend yang tahan lama sehingga restart layanan tidak menghapus analisis aktif.

Apakah TradingAgents cocok untuk keputusan keuangan langsung?

Materi proyek publik menggambarkannya sebagai kerangka kerja penelitian dan secara eksplisit mengatakan itu bukan nasihat keuangan atau investasi. Perlakukan itu sebagai sistem penelitian dan eksperimen kecuali Anda menambahkan kontrol, validasi, dan tata kelola Anda sendiri.