Tutorial GLM-5.3-Flash: Bangun Analis Saham Multi-Agent

Mengapa Menggunakan GLM-5.3-Flash untuk Aplikasi Multi-Agent

GLM-5.3-Flash menawarkan keseimbangan yang mengesankan antara performa, efisiensi, dan harga. Untuk ulasan lengkap, baca panduan GLM-5.3-Flash kami dan perbandingan kami dengan Qwen3.8-Flash-Next.

Performa dan efisiensi yang kompetitif

Pada Artificial Analysis Intelligence Index, model ini meraih skor 57, menempatkannya di antara model terdepan dan membuatnya kompetitif dengan beberapa model frontier yang jauh lebih mahal. Sebagai contoh:

• GPT-5.6 Sol juga meraih skor 57 (dengan upaya penalaran high) tetapi biayanya lebih dari 25x untuk token input dan 40x untuk token output.

• Claude Sonnet 5 bahkan sedikit lebih rendah, dengan 55 pada upaya penalaran max. Harganya 20x/30x lebih mahal untuk token input/output dibanding GLM-5.3-Flash.

Model ini memiliki total 320B parameter, namun hanya sekitar 18B parameter yang aktif per token, memungkinkannya memberikan performa kuat sekaligus tetap relatif efisien komputasi. 

Sumber: AI Model & API Providers Analysis | Artificial Analysis 

Harga yang menarik

Seperti sudah disebutkan, performa ini hadir dengan harga API yang relatif rendah. Saat penulisan, OpenRouter menawarkan GLM-5.3-Flash dengan diskon 50%, yaitu $0,075 per satu juta token input dan $0,25 per satu juta token output. 

Bahkan pada harga normal $0,15/$0,50, model ini tetap lebih murah daripada model seperti GPT-5.6 Luna milik OpenAI, yang berharga $0,20/$1,20 (skor 52 pada AA Intelligence Index dengan penalaran max). Ini membuatnya menarik tidak hanya untuk eksperimen, tetapi juga untuk aplikasi agen berskala produksi yang lebih besar. 

Sumber: GLM 5.3 Flash - API Pricing & Benchmarks | OpenRouter 

Hal ini makin penting saat Anda membangun sistem multi-agent, karena satu permintaan pengguna dapat memicu banyak panggilan LLM di belakang layar. Satu agen LLM dapat memanggil model beberapa kali untuk penalaran, pemilihan alat, memproses output alat, dan menghasilkan respons akhir. Jika satu agen melakukan sekitar tujuh panggilan LLM dan alur kerja Anda menggunakan lima agen, satu permintaan bisa dengan mudah menghasilkan 35 panggilan LLM atau lebih. 

Jumlah pastinya bergantung pada desain sistem Anda, tetapi intinya sederhana: alur kerja agenik dapat menjadi mahal dengan cepat. Menggunakan model andal dengan harga token rendah, seperti GLM-5.3-Flash, dapat membuat perbedaan signifikan saat beralih dari demo kecil ke aplikasi produksi nyata. 

1. Menyiapkan Lingkungan untuk GLM-5.3-Flash

Sebelum membangun alur kerja multi-agent, buat kunci API untuk Z.ai, Finnhub, dan Tavily.

Buat kunci API

Untuk Z.ai, pastikan Anda menggunakan API reguler, bukan GLM Coding Plan. Coding Plan ditujukan untuk alat coding AI yang didukung dan tidak boleh digunakan sebagai API tujuan umum untuk aplikasi multi-agent Anda sendiri.

Buat kunci API Z.ai reguler dan tambahkan sejumlah kecil kredit ke akun Anda. Karena GLM-5.3-Flash murah, Anda hanya memerlukan saldo kecil untuk mulai menguji.

Sumber: Z.ai API Platform — Mulai membangun dengan GLM-5.3 

Anda juga dapat membuat akun gratis di Finnhub dan Tavily serta menghasilkan kunci API. Paket gratis mereka cukup untuk menguji proyek ini.

Siapkan berkas proyek

Selanjutnya, buat berkas .env di folder proyek Anda dan tambahkan kunci API:

ZAI_API_KEY="your_zai_api_key"
FINNHUB_API_KEY="your_finnhub_api_key"
TAVILY_API_KEY="your_tavily_api_key"

Sekarang, buat Jupyter Notebook baru. Kita akan terlebih dahulu membangun dan menguji alur kerja multi-agent lengkap di sini, meninjau output tiap agen, dan memperbaiki masalah sebelum mengubahnya menjadi aplikasi yang semestinya.

Instal pustaka yang diperlukan

Kita akan menggunakan CrewAI untuk membuat dan mengoordinasikan agen, Finnhub untuk data pasar saham, dan Tavily untuk penelusuran web real-time. Instal paket Python yang diperlukan:

!pip install -q crewai crewai-tools finnhub-python tavily-python pandas numpy requests python-dotenv openai

Impor pustaka dan kunci API

Selanjutnya, impor pustaka yang dibutuhkan dan muat kunci API:

import os
import re
import time

import finnhub
import numpy as np
import pandas as pd
import requests

from dotenv import load_dotenv
from openai import OpenAI
from tavily import TavilyClient

from crewai import Agent, Crew, LLM, Process, Task
from crewai.tools import tool
from crewai_tools import TavilySearchTool

# Load environment variables
load_dotenv()

# Disable CrewAI tracing
os.environ.setdefault("CREWAI_TRACING_ENABLED", "false")
os.environ.setdefault("OTEL_SDK_DISABLED", "true")

Terakhir, pilih saham yang ingin dianalisis para agen:

TICKER = "NVDA"

Saya akan menggunakan NVIDIA (NVDA) di seluruh notebook, namun Anda bebas menggantinya dengan ticker lain yang Anda minati, seperti AAPL, MSFT, atau TSLA.

2. Konfigurasikan GLM-5.3-Flash dan API Data

Sekarang kunci API sudah siap, kita dapat menghubungkan layanan yang akan digunakan agen sepanjang proyek.

Mulailah dengan menginisialisasi Finnhub untuk data pasar saham dan Tavily untuk penelusuran web:

finnhub_client = finnhub.Client(
    api_key=os.environ["FINNHUB_API_KEY"]
)

tavily_client = TavilyClient(
    api_key=os.environ["TAVILY_API_KEY"]
)

Jika Anda ingin membangun agen finansial dan bingung sumber data mana yang digunakan, saya sarankan membaca panduan kami tentang memilih API data pasar saham yang tepat.

Selanjutnya, konfigurasikan GLM-5.3-Flash sebagai LLM utama untuk agen CrewAI kita. Z.ai menyediakan API yang kompatibel dengan OpenAI, jadi kita dapat menghubungkannya langsung melalui kelas LLM milik CrewAI:

llm = LLM(
    model="openai/glm-5.3-flash",
    api_key=os.environ["ZAI_API_KEY"],
    base_url="https://api.z.ai/api/paas/v4/",
    temperature=0.1,
)

Kami menjaga temperature tetap rendah karena aplikasi ini berfokus pada riset dan analisis finansial, di mana kita ingin para agen menghasilkan respons yang lebih konsisten dan terarah.

Dengan model, data pasar, dan API penelusuran web yang sudah terhubung, kini kita dapat mulai membangun alat yang akan digunakan para agen.

3. Kumpulkan Data Pasar Historis

Selanjutnya, kita memerlukan data harga historis agar agen dapat memahami bagaimana kinerja saham dari waktu ke waktu.

Untuk ini, kita akan menggunakan endpoint chart publik Yahoo Finance untuk mengumpulkan data harian open, high, low, close, dan volume.

Unduh riwayat harga

HTTP = requests.Session()
HTTP.headers.update({"User-Agent": "glm-stock-swarm/1.0"})


def _yahoo_history(ticker: str, days: int) -> pd.DataFrame:
    end = int(time.time())
    start = end - days * 24 * 60 * 60

    response = HTTP.get(
        f"https://query1.finance.yahoo.com/v8/finance/chart/{ticker}",
        params={
            "period1": start,
            "period2": end,
            "interval": "1d",
            "events": "history",
        },
        timeout=30,
    )
    response.raise_for_status()

    result = response.json()["chart"]["result"][0]
    values = result["indicators"]["quote"][0]

    frame = pd.DataFrame({
        "date": pd.to_datetime(
            result["timestamp"], unit="s", utc=True
        ).tz_localize(None),
        "open": values["open"],
        "high": values["high"],
        "low": values["low"],
        "close": values["close"],
        "volume": values["volume"],
    })

    frame = (
        frame.dropna(subset=["close"])
        .sort_values("date")
        .reset_index(drop=True)
    )

    frame.attrs["source"] = "Yahoo public chart"
    return frame


def get_price_history(ticker: str, days: int = 450) -> pd.DataFrame:
    return _yahoo_history(ticker.strip().upper(), days)

Kita akan mengumpulkan sekitar 450 hari data historis, yang memberi cukup data untuk menghitung indikator jangka panjang seperti moving average 200 hari.

Hitung indikator teknikal

Selanjutnya, mari hitung beberapa indikator yang umum digunakan: 

• Moving averages: rata-rata sepanjang 20, 50, dan 200 hari terakhir
• Relative Strength Index (RSI): Skala antara 0 hingga 100 yang digunakan untuk menunjukkan apakah suatu saham overbought (>70) atau oversold (<30)
• Moving Average Convergence/Divergence (MACD): Selisih antara Exponential Moving Averages (EMA) jangka panjang dan jangka pendek

def add_indicators(frame: pd.DataFrame) -> pd.DataFrame:
    if frame.empty:
        return frame.copy()

    result = frame.copy()
    result.attrs.update(frame.attrs)

    # Moving averages
    result["SMA20"] = result["close"].rolling(20).mean()
    result["SMA50"] = result["close"].rolling(50).mean()
    result["SMA200"] = result["close"].rolling(200).mean()

    # RSI
    delta = result["close"].diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)

    avg_gain = gain.ewm(
        alpha=1 / 14, min_periods=14, adjust=False
    ).mean()

    avg_loss = loss.ewm(
        alpha=1 / 14, min_periods=14, adjust=False
    ).mean()

    result["RSI14"] = 100 - (
        100 / (1 + avg_gain / avg_loss.replace(0, np.nan))
    )

    # MACD
    result["EMA12"] = result["close"].ewm(
        span=12, adjust=False
    ).mean()

    result["EMA26"] = result["close"].ewm(
        span=26, adjust=False
    ).mean()

    result["MACD"] = result["EMA12"] - result["EMA26"]

    return result

Indikator ini akan berguna karena memberikan agen analisis teknikal pandangan cepat tentang tren dan momentum tanpa harus meminta LLM menghitung semuanya sendiri.

Tinjau nilai terbaru

Sekarang kumpulkan data, hitung indikator, dan tampilkan baris terbaru:

history = add_indicators(
    get_price_history(TICKER)
)

if len(history) < 200:
    raise RuntimeError(
        f"Need at least 200 daily observations; received {len(history)}."
    )

print(
    f"Loaded {len(history)} rows "
    f"from {history.attrs['source']} ."
)

history.tail(3)[
    [
        "date",
        "close",
        "SMA20",
        "SMA50",
        "SMA200",
        "RSI14",
        "MACD",
    ]
]

Anda akan melihat harga saham terbaru beserta moving average, RSI, dan MACD, mirip seperti output di atas.

Nantinya kita akan meneruskan data ini ke agen analisis teknikal agar ia dapat mengidentifikasi tren harga, momentum, serta sinyal bullish atau bearish.

4. Ubah Sumber Data Menjadi Alat CrewAI

Sekarang sumber data kita sudah berfungsi, kita perlu mengubahnya menjadi alat CrewAI. Ini memungkinkan agen memanggilnya langsung kapan pun mereka membutuhkan informasi finansial, teknikal, atau berita.

Buat alat data saham

Pertama, buat fungsi pembantu kecil untuk menjaga nilai numerik tetap rapi dan konsisten:

def _number(value, decimals: int = 2) -> str:
    if value is None or pd.isna(value):
        return "N/A"

    return f"{float(value):,.{decimals}f}"

Selanjutnya, buat alat fundamental. Ini menggunakan Finnhub untuk mengambil harga saham terbaru, metrik valuasi, pertumbuhan, profitabilitas, dan fundamental perusahaan lainnya.

@tool("Get Stock Fundamentals")
def get_fundamentals(ticker: str) -> str:
    """Get current price and company fundamentals from Finnhub for one ticker."""

    ticker = ticker.strip().upper()

    quote = finnhub_client.quote(ticker)
    metrics = finnhub_client.company_basic_financials(ticker, "all")
    m = metrics.get("metric", {})

    return f"""Ticker: {ticker}
Source: Finnhub
Current price: {_number(quote.get('c'))}
Previous close: {_number(quote.get('pc'))}
Daily change %: {_number(quote.get('dp'))}
Day high / low: {_number(quote.get('h'))} / {_number(quote.get('l'))}
Market cap (USD millions): {_number(m.get('marketCapitalization'))}
52-week high / low: {_number(m.get('52WeekHigh'))} / {_number(m.get('52WeekLow'))}
Normalized annual P/E: {_number(m.get('peNormalizedAnnual'))}
Annual P/B: {_number(m.get('pbAnnual'))}
Annual P/S: {_number(m.get('psAnnual'))}
ROE TTM: {_number(m.get('roeTTM'))}
Net margin TTM: {_number(m.get('netProfitMarginTTM'))}
Revenue growth TTM YoY: {_number(m.get('revenueGrowthTTMYoy'))}
EPS growth TTM YoY: {_number(m.get('epsGrowthTTMYoy'))}
Annual debt/equity: {_number(m.get('totalDebt/totalEquityAnnual'))}"""

Kita juga akan membuat alat analisis teknikal menggunakan data historis dan indikator dari bagian sebelumnya.

@tool("Analyze Stock Technicals")
def get_technicals(ticker: str) -> str:
    """Calculate price trends, returns, moving averages, RSI, and MACD."""

    ticker = ticker.strip().upper()
    frame = add_indicators(get_price_history(ticker))

    if len(frame) < 200:
        return (
            f"Technical data unavailable for {ticker}: "
            "fewer than 200 observations."
        )

    latest = frame.iloc[-1]

    return f"""Ticker: {ticker}
Source: {frame.attrs.get('source', 'unknown')}
Last market date: {latest['date'].date()}
Close: {_number(latest['close'])}
SMA20 / SMA50 / SMA200: {_number(latest['SMA20'])} / {_number(latest['SMA50'])} / {_number(latest['SMA200'])}
RSI14: {_number(latest['RSI14'])}
MACD: {_number(latest['MACD'])}
20-day return: {_number((latest['close'] / frame['close'].iloc[-21] - 1) * 100)}%
50-day return: {_number((latest['close'] / frame['close'].iloc[-51] - 1) * 100)}%
Price vs SMA20: {_number((latest['close'] / latest['SMA20'] - 1) * 100)}%
Price vs SMA50: {_number((latest['close'] / latest['SMA50'] - 1) * 100)}%
Price vs SMA200: {_number((latest['close'] / latest['SMA200'] - 1) * 100)}%"""

Bagian pentingnya adalah dekorator @tool. Ini mengubah fungsi Python biasa menjadi alat yang dapat diputuskan untuk dipanggil oleh agen CrewAI selama menjalankan tugas.

Tambahkan alat penelusuran web

Untuk berita perusahaan dan perkembangan terbaru, kita akan menggunakan alat penelusuran Tavily milik CrewAI:

web_search = TavilySearchTool(
    api_key=os.environ["TAVILY_API_KEY"],
    topic="news",
    search_depth="advanced",
    days=30,
    max_results=5,
)

Kita batasi penelusuran pada 30 hari terakhir dan mengembalikan maksimal lima hasil, yang seharusnya memberi agen riset kita cukup informasi terbaru tanpa membebani mereka dengan konten yang tidak perlu.

Uji alat saham

Sebelum membuat agen, jalankan dua alat kustom tersebut secara langsung:

print(get_fundamentals.run(ticker=TICKER))
print()
print(get_technicals.run(ticker=TICKER))

Sekarang Anda akan melihat metrik fundamental terbaru diikuti indikator teknikal untuk saham yang dipilih.

5. Bangun Tim Riset Multi-Agent

Sekarang alat sudah siap, kita dapat membuat tim riset multi-agent.

Kita akan menggunakan tiga agen spesialis, masing-masing untuk analisis fundamental, analisis teknikal, dan berita terbaru, plus seorang manajer portofolio yang menggabungkan temuannya menjadi penilaian akhir.

Buat agen spesialis

Pertama, buat analis fundamental:

fundamental_agent = Agent(
    role="Fundamental Analyst",
    goal=(
        "Evaluate financial health, growth, profitability, "
        "valuation, and balance-sheet risk."
    ),
    backstory=(
        "You are a careful long-term equity analyst. "
        "Use the fundamentals tool and never invent a figure. "
        "Treat N/A as missing, not as zero."
    ),
    tools=[get_fundamentals],
    llm=llm,
    allow_delegation=False,
    max_iter=4,
    verbose=False,
)

Selanjutnya, buat analis teknikal:

technical_agent = Agent(
    role="Technical Analyst",
    goal=(
        "Determine whether the current price setup is "
        "bullish, bearish, or neutral."
    ),
    backstory=(
        "You interpret indicators calculated by Python. "
        "Never guess market prices or indicator values."
    ),
    tools=[get_technicals],
    llm=llm,
    allow_delegation=False,
    max_iter=4,
    verbose=False,
)

Lalu buat analis berita finansial:

news_agent = Agent(
    role="Financial News Analyst",
    goal=(
        "Find material recent developments and distinguish "
        "confirmed reporting from speculation."
    ),
    backstory=(
        "You are a skeptical financial-news researcher. "
        "Prioritize primary and reputable sources, dates, and links."
    ),
    tools=[web_search],
    llm=llm,
    allow_delegation=False,
    max_iter=5,
    verbose=False,
)

Setiap spesialis hanya menerima alat yang benar-benar dibutuhkan. Ini menjaga alur kerja tetap fokus dan mencegah agen memanggil alat yang tidak terkait.

Buat manajer portofolio

Terakhir, buat agen manajer yang akan meninjau ketiga laporan spesialis:

manager_agent = Agent(
    role="Portfolio Manager",
    goal=(
        "Combine the specialist reports into a balanced, "
        "evidence-based research signal."
    ),
    backstory=(
        "You lead an equity research team. "
        "Weigh bullish and bearish evidence, use HOLD when evidence "
        "is mixed, and never add unsupported facts."
    ),
    llm=llm,
    allow_delegation=False,
    max_iter=4,
    verbose=False,
)

Manajer portofolio tidak memerlukan akses langsung ke alat data kita. Sebaliknya, ia akan bekerja dengan laporan yang dihasilkan tiga agen spesialis.

Mengatur allow_delegation=False juga membuat alur kerja dapat diprediksi, sementara max_iter membatasi berapa banyak siklus penalaran dan penggunaan alat yang dapat dilakukan setiap agen.

6. Tetapkan Tugas Riset Spesialis

Membuat agen mendefinisikan siapa mereka. Sekarang kita perlu memberi tahu masing-masing dengan jelas apa yang harus dilakukan dan apa yang harus ada dalam output akhirnya.

Definisikan tugas riset

Mulailah dengan tugas analisis fundamental:

fundamental_task = Task(
    description=(
        f"Analyze {TICKER}'s growth, profitability, valuation, "
        "balance sheet, and business quality. "
        "Use Get Stock Fundamentals. "
        "Return a Fundamental Score from 0-100, strongest positive, "
        "biggest risk, and note all material missing data."
    ),
    expected_output=(
        "A concise fundamental assessment with a 0-100 score, "
        "evidence, strongest positive, biggest risk, "
        "and missing-data note."
    ),
    agent=fundamental_agent,
)

Selanjutnya, definisikan tugas analisis teknikal:

technical_task = Task(
    description=(
        f"Analyze {TICKER}'s technical setup. "
        "Use Analyze Stock Technicals. "
        "Consider SMA20/50/200, RSI14, MACD, recent returns, and trend. "
        "Return Technical Score 0-100, Bullish/Neutral/Bearish signal, "
        "trend, momentum, and main technical risk."
    ),
    expected_output=(
        "A concise technical assessment with score, signal, trend, "
        "momentum, data source, and main risk."
    ),
    agent=technical_agent,
)

Untuk perkembangan terbaru, buat tugas riset berita:

news_task = Task(
    description=(
        f"Research the most important recent news for {TICKER}, "
        "focusing on the last 30 days: earnings, guidance, analyst "
        "revisions, products, partnerships, M&A, regulation, lawsuits, "
        "management, and industry developments. "
        "Use Tavily Search. "
        "Return News Score 0-100, sentiment, positive and negative "
        "catalysts, publication dates, and source URLs. "
        "Ignore low-quality speculation."
    ),
    expected_output=(
        "A sourced recent-news assessment with score, sentiment, "
        "catalysts, dates, and clickable URLs."
    ),
    agent=news_agent,
)

Memberi tiap agen tugas dan format output yang jelas itu penting. Ini membuat laporan mereka lebih mudah dibandingkan oleh manajer portofolio, alih-alih menerima respons yang sama sekali berbeda dari setiap agen.

Buat tugas keputusan akhir

Tugas terakhir menyatukan ketiga laporan:

decision_task = Task(
    description=(
        f"Review all three specialist reports and make the final "
        f"educational research assessment for {TICKER}. "
        "Return exactly one signal: BUY, HOLD, or SELL. "
        "Use HOLD when evidence is mixed or confidence is insufficient. "
        "Base every claim only on the supplied reports."
    ),
    expected_output=(
        "Ticker; Signal; Overall Score /100; Confidence %; "
        "Fundamental, Technical, and News scores; Bull Case; "
        "Bear Case; Main Catalyst; Main Risk; Final Explanation; "
        "Sources; and an educational-not-financial-advice disclaimer."
    ),
    agent=manager_agent,
    context=[
        fundamental_task,
        technical_task,
        news_task,
    ],
)

Bagian kuncinya adalah context. Ini memberi manajer portofolio akses ke output dari ketiga tugas spesialis, memungkinkannya membandingkan sinyal fundamental, teknikal, dan berita sebelum menghasilkan penilaian akhir BELI, TAHAN, atau JUAL.

Pada titik ini, agen, alat, dan tugas kita sudah siap. Selanjutnya, kita bisa menyambungkan semuanya ke dalam alur kerja CrewAI dan menjalankan tim riset lengkap.

7. Jalankan Kru Riset Multi-Agent

Sekarang kita bisa menyatukan semuanya dan menjalankan alur kerja riset saham yang lengkap.

Buat kru

Buat kru CrewAI yang berisi tiga agen spesialis kita dan manajer portofolio:

crew = Crew(
    agents=[
        fundamental_agent,
        technical_agent,
        news_agent,
        manager_agent,
    ],
    tasks=[
        fundamental_task,
        technical_task,
        news_task,
        decision_task,
    ],
    process=Process.sequential,
    verbose=False,
    tracing=False,
)

Kita menggunakan Process.sequential, sehingga tugas riset berjalan berurutan. Agen fundamental, teknikal, dan berita menyelesaikan analisis mereka terlebih dahulu, dan kemudian manajer portofolio menerima laporan tersebut untuk menghasilkan penilaian akhir.

Jalankan tim riset

Mulai alur kerja secara asinkron:

result = await crew.kickoff_async()

Langkah ini dapat memakan waktu karena para agen melakukan banyak panggilan LLM dan alat. Dalam pengujian saya, alur kerja riset lengkap memakan waktu sekitar 4 hingga 5 menit untuk selesai.

Setelah selesai, tampilkan laporan akhir manajer portofolio:

print(result.raw)

Anda akan mendapatkan laporan terperinci yang mirip dengan output di atas, termasuk:

• Sinyal BELI, TAHAN, atau JUAL
• Skor keseluruhan
• Tingkat keyakinan
• Skor spesialis
• Skenario bullish
• Skenario bearish
• Katalis
• Risiko
• Sumber pendukung

Dalam contoh ini, para agen menganalisis NVIDIA secara independen lalu menggabungkan temuannya menjadi satu laporan riset berbasis bukti. Di sinilah kita akhirnya melihat manfaat pendekatan multi-agent: alih-alih meminta satu model melakukan semuanya sekaligus, setiap agen fokus pada bidangnya sendiri sebelum manajer portofolio menyatukan seluruh riset.

Jika Anda mengalami masalah saat menjalankan kode di atas, saya juga menyertakan Jupyter Notebook lengkap dengan seluruh kode dan output, yang dapat Anda tinjau atau jalankan sendiri: glm-stock-swarm/stock_analyst_crew.ipynb

8. Bangun dan Jalankan UI Terminal

Setelah menguji semuanya di dalam Jupyter Notebook, saya mengonversi alur kerja lengkap menjadi antarmuka pengguna terminal (TUI). Alih-alih menjalankan setiap sel notebook secara manual, kini Anda dapat meluncurkan analis saham multi-agent lengkap dengan satu perintah.

Proyek lengkap, termasuk kode dan petunjuk penyiapan, tersedia di GitHub: repositori GitHub glm-stock-swarm.

Instal dan jalankan aplikasi

Mulailah dengan mengkloning repositori:

git clone https://github.com/kingabzpro/glm-stock-swarm.git
cd glm-stock-swarm

Tambahkan kunci API Z.ai, Finnhub, dan Tavily Anda ke berkas .env, lalu instal semua dependensi dengan uv:

uv sync

Terakhir, luncurkan TUI:

uv run glm-stock-swarm

Analisis sebuah saham

Antarmuka menyediakan kotak input sederhana tempat Anda dapat memasukkan ticker saham yang didukung untuk memulai analisis.

Setelah Anda mengirimkan tiket, Anda dapat menyaksikan para agen bekerja satu per satu. Analis fundamental mulai lebih dulu, diikuti analis teknikal, analis berita, dan akhirnya manajer portofolio, yang menggabungkan semuanya menjadi keputusan akhir.

Pada akhirnya, TUI menghasilkan laporan lengkap langsung di dalam terminal, termasuk skor fundamental, skor teknikal, skor berita, skor keseluruhan, keyakinan, skenario bullish, skenario bearish, risiko, katalis, dan sinyal akhir BELI, TAHAN, atau JUAL.

Ajukan pertanyaan lanjutan

Saya juga menambahkan obrolan lanjutan sehingga Anda tidak perlu menjalankan ulang seluruh pipeline multi-agent setiap kali Anda memiliki pertanyaan lain.

Sebagai contoh, setelah menerima rekomendasi JUAL, saya bertanya apakah saya harus menjual seluruh posisi atau hanya sebagian.

Alih-alih meluncurkan keempat agen lagi, aplikasi menggunakan konteks dari laporan riset yang dihasilkan dan mengirim respons lanjutan yang jauh lebih cepat.

Ini membuat aplikasi lebih praktis karena riset multi-agent yang mahal dijalankan sekali, sementara pertanyaan lanjutan dapat menggunakan kembali analisis yang sudah ada.

Pemikiran Akhir

Hal yang patut dicatat dari pengujian saya adalah keandalan pemanggilan alat. Ketiga spesialis memilih alat yang tepat, mematuhi konvensi N/A alih-alih menganggap data hilang sebagai nol, dan mengembalikan format skor-dan-bukti yang dibutuhkan manajer portofolio. Biasanya di situlah model murah kewalahan.

Kecepatan adalah konsekuensinya. Artificial Analysis mencatat GLM-5.3-Flash sekitar 45 token output per detik pada API Z.ai, yang berada di sisi bawah untuk model open-weight seukurannya, dan Anda akan merasakannya pada 4 hingga 5 menit yang dibutuhkan satu kali run kru penuh. Ia juga meraih skor 57 pada indeks kecerdasan mereka dibanding 60 untuk GLM-5.3, jadi Anda mengorbankan sedikit kualitas penalaran, namun itu pertukaran yang baik mengingat Anda membayar hanya sekitar sepersepuluh harganya.

Tak ada yang mengunci Anda. Beralih ke OpenRouter, Hugging Face Inference, atau model lokal melalui Ollama biasanya berarti mengubah tiga hal: kunci API, nama model, dan base URL. Sama halnya untuk alat, di mana yfinance dapat melakukan pekerjaan yang di sini dibagi oleh Finnhub dan Yahoo.

Langkah berikutnya yang akan saya ambil adalah menyambungkannya ke API paper-trading dan menjadwalkan run pagi. Tetap gunakan akun demo, tentu saja. Ini dibuat untuk mengajarkan desain agen, bukan untuk berdagang.

Jika Anda ingin mempelajari segala hal tentang agentic AI dari dasar, saya rekomendasikan AI Agent Fundamentals skill track kami sebagai titik awal yang bagus.