GLM-5.3-Flash ट्यूटोरियल: एक मल्टी-एजेंट स्टॉक एनालिस्ट बनाएं

मल्टी-एजेंट एप्लिकेशन के लिए GLM-5.3-Flash क्यों उपयोग करें

GLM-5.3-Flash प्रदर्शन, दक्षता और कीमत के बीच प्रभावशाली संतुलन प्रदान करता है। पूरी जानकारी के लिए, हमारा GLM-5.3-Flash गाइड और Qwen3.8-Flash-Next के साथ तुलना लेख पढ़ें।

प्रतिस्पर्धी प्रदर्शन और दक्षता

Artificial Analysis Intelligence Index पर इसका स्कोर 57 है, जो इसे अग्रणी मॉडलों में रखता है और कई अधिक महंगे फ्रंटियर मॉडलों के साथ प्रतिस्पर्धी बनाता है। उदाहरण के लिए:

• GPT-5.6 Sol का स्कोर भी 57 है (जिसमें high reasoning effort है) लेकिन इनपुट टोकन के लिए 25x से अधिक और आउटपुट टोकन के लिए 40x से अधिक कीमत पड़ती है।

• Claude Sonnet 5 का स्कोर थोड़ा कम है, max reasoning effort पर 55। यह GLM-5.3-Flash की तुलना में इनपुट/आउटपुट टोकन के लिए 20x/30x अधिक महंगा है।

इसके कुल 320B पैरामीटर्स हैं, पर प्रति टोकन केवल लगभग 18B पैरामीटर्स सक्रिय रहते हैं, जिससे यह अपेक्षाकृत कंप्यूट-कारगर रहते हुए मजबूत प्रदर्शन देता है। 

स्रोत: AI Model & API Providers Analysis | Artificial Analysis 

आकर्षक कीमत

जैसा कि मैंने पहले बताया, यह प्रदर्शन अपेक्षाकृत कम API कीमत पर आता है। लेखन के समय, OpenRouter GLM-5.3-Flash को 50% छूट पर दे रहा है, $0.075 प्रति मिलियन इनपुट टोकन और $0.25 प्रति मिलियन आउटपुट टोकन की दर से। 

इसके नियमित $0.15/$0.50 मूल्य पर भी, यह OpenAI के GPT-5.6 Luna जैसे मॉडलों से सस्ता रहता है, जिसकी कीमत $0.20/$1.20 है (AA Intelligence Index पर max reasoning के साथ 52)। यह इसे केवल प्रयोगों के लिए नहीं, बल्कि बड़े, प्रोडक्शन-स्तरीय एजेंट एप्लिकेशनों के लिए भी आकर्षक बनाता है। 

स्रोत: GLM 5.3 Flash - API Pricing & Benchmarks | OpenRouter 

जब आप मल्टी-एजेंट सिस्टम बना रहे होते हैं, तब यह और भी मायने रखता है, क्योंकि एक यूज़र रिक्वेस्ट पर्दे के पीछे कई LLM कॉल्स ट्रिगर कर सकता है। एक अकेला LLM एजेंट तर्क-वितर्क, टूल चयन, टूल आउटपुट प्रोसेसिंग और अपना अंतिम उत्तर जनरेट करने के लिए मॉडल को कई बार कॉल कर सकता है। अगर एक एजेंट लगभग सात LLM कॉल करता है और आपका वर्कफ़्लो पाँच एजेंट का उपयोग करता है, तो एक ही रिक्वेस्ट आसानी से 35 या अधिक LLM कॉल्स में बदल सकती है। 

सटीक संख्या आपके सिस्टम के डिज़ाइन पर निर्भर करती है, लेकिन बात सरल है: एजेंटिक वर्कफ़्लो बहुत तेजी से महंगे हो सकते हैं। GLM-5.3-Flash जैसे कम टोकन कीमत वाले सक्षम मॉडल का उपयोग छोटे डेमो से वास्तविक प्रोडक्शन एप्लिकेशन तक जाते समय बड़ा अंतर ला सकता है। 

1. GLM-5.3-Flash के लिए एन्वायरनमेंट सेट करें

मल्टी-एजेंट वर्कफ़्लो बनाने से पहले, Z.ai, Finnhub और Tavily के लिए API कीज़ बनाएँ।

API कीज़ बनाएं

Z.ai के लिए, सुनिश्चित करें कि आप रेगुलर API का उपयोग कर रहे हैं, GLM Coding Plan का नहीं। Coding Plan समर्थित AI कोडिंग टूल्स के लिए है और इसे आपके अपने मल्टी-एजेंट एप्लिकेशन के लिए एक जनरल-पर्पज़ API के रूप में उपयोग नहीं करना चाहिए।

एक रेगुलर Z.ai API की जनरेट करें और अपने अकाउंट में थोड़ी राशि का क्रेडिट जोड़ें। क्योंकि GLM-5.3-Flash सस्ता है, परीक्षण शुरू करने के लिए आपको केवल थोड़ी बैलेंस की आवश्यकता होगी।

स्रोत: Z.ai API Platform — GLM-5.3 के साथ निर्माण शुरू करें 

आप Finnhub और Tavily पर निःशुल्क खाते भी बना सकते हैं और API कीज़ जनरेट कर सकते हैं। उनके फ्री टियर इस प्रोजेक्ट के परीक्षण के लिए पर्याप्त हैं।

प्रोजेक्ट फ़ाइलें सेट करें

इसके बाद, अपने प्रोजेक्ट फ़ोल्डर में एक .env फ़ाइल बनाएं और API कीज़ जोड़ें:

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

अब एक नया Jupyter Notebook बनाएं। हम पहले यहां पूरा मल्टी-एजेंट वर्कफ़्लो बनाएंगे और टेस्ट करेंगे, प्रत्येक एजेंट के आउटपुट की जाँच करेंगे और इसे एक सही एप्लिकेशन में बदलने से पहले किसी भी समस्या को ठीक करेंगे।

आवश्यक लाइब्रेरियाँ इंस्टॉल करें

हम एजेंट बनाने और समन्वय करने के लिए CrewAI, स्टॉक मार्केट डेटा के लिए Finnhub, और रियल-टाइम वेब सर्च के लिए Tavily का उपयोग करेंगे। आवश्यक Python पैकेज इंस्टॉल करें:

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

लाइब्रेरियाँ और API कीज़ इम्पोर्ट करें

अगला, आवश्यक लाइब्रेरियाँ इम्पोर्ट करें और 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")

अंत में, वह स्टॉक चुनें जिसे आप एजेंट्स से विश्लेषित कराना चाहते हैं:

TICKER = "NVDA"

मैं पूरे नोटबुक में NVIDIA (NVDA) का उपयोग करूंगा, लेकिन आप अपनी रुचि के किसी अन्य टिकर, जैसे AAPL, MSFT, या TSLA से भी बदल सकते हैं।

2. GLM-5.3-Flash और डेटा APIs कॉन्फ़िगर करें

अब जब API कीज़ तैयार हैं, हम उन सेवाओं को कनेक्ट कर सकते हैं जिन्हें हमारे एजेंट पूरे प्रोजेक्ट में उपयोग करेंगे।

शुरू करें Finnhub (स्टॉक मार्केट डेटा) और Tavily (वेब सर्च) को इनिशियलाइज़ करके:

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

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

यदि आप वित्तीय एजेंट बनाना चाहते हैं और यह सुनिश्चित नहीं है कि किस डेटा स्रोत का उपयोग करें, तो हमारे सही स्टॉक मार्केट डेटा API चुनने के गाइड को पढ़ने की सलाह देता हूँ।

अगला, हमारे CrewAI एजेंट्स के लिए GLM-5.3-Flash को मुख्य LLM के रूप में कॉन्फ़िगर करें। Z.ai एक OpenAI-कम्पैटिबल API प्रदान करता है, इसलिए हम इसे सीधे CrewAI की LLM क्लास के माध्यम से कनेक्ट कर सकते हैं:

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

हम टेम्परेचर को कम रख रहे हैं क्योंकि यह एप्लिकेशन वित्तीय रिसर्च और विश्लेषण पर केंद्रित है, जहाँ हम एजेंट्स से अधिक सुसंगत और केंद्रित उत्तर चाहते हैं।

मॉडल, मार्केट डेटा और वेब सर्च APIs जुड़े होने के साथ, अब हम वे टूल बनाना शुरू कर सकते हैं जिन्हें हमारे एजेंट्स उपयोग करेंगे।

3. ऐतिहासिक मार्केट डेटा एकत्र करें

अगला, हमें ऐतिहासिक प्राइस डेटा चाहिए ताकि हमारे एजेंट समझ सकें कि समय के साथ स्टॉक का प्रदर्शन कैसा रहा है।

इसके लिए, हम Yahoo Finance के पब्लिक चार्ट एंडपॉइंट का उपयोग करके दैनिक ओपन, हाई, लो, क्लोज़ और वॉल्यूम डेटा एकत्र करेंगे।

प्राइस हिस्ट्री डाउनलोड करें

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)

हम लगभग 450 दिनों का इतिहास एकत्र करेंगे, जो हमें 200-दिन की मूविंग एवरेज जैसे दीर्घकालिक इंडिकेटर्स की गणना के लिए पर्याप्त डेटा देता है।

टेक्निकल इंडिकेटर्स की गणना करें

अब कुछ आमतौर पर उपयोग किए जाने वाले इंडिकेटर्स की गणना करें: 

• मूविंग एवरेज: पिछले 20-दिन, 50-दिन और 200-दिन की समयावधि पर औसत
• Relative Strength Index (RSI): 0 से 100 के बीच का स्केल जो दर्शाता है कि स्टॉक ओवरबॉट (>70) या ओवरसोल्ड (<30) है
• Moving Average Convergence/Divergence (MACD): दीर्घकालिक और अल्पकालिक Exponential Moving Averages (EMAs) के अंतर

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

ये इंडिकेटर्स उपयोगी होंगे क्योंकि ये टेक्निकल विश्लेषण एजेंट को ट्रेंड्स और मोमेंटम का त्वरित दृश्य देते हैं, बिना LLM से सब कुछ खुद गणना करवाए।

नवीनतम मानों की समीक्षा करें

अब डेटा एकत्र करें, इंडिकेटर्स की गणना करें, और नवीनतम पंक्तियाँ दिखाएँ:

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",
    ]
]

आपको मूविंग एवरेज, RSI और MACD के साथ नवीनतम स्टॉक कीमत दिखाई देनी चाहिए, जैसा कि ऊपर के आउटपुट में है।

हम बाद में यह डेटा टेक्निकल विश्लेषण एजेंट को देंगे ताकि वह प्राइस ट्रेंड्स, मोमेंटम, और बुलिश या बियरिश सिग्नल की पहचान कर सके।

4. डेटा स्रोतों को CrewAI टूल्स में बदलें

अब जब हमारे डेटा स्रोत काम कर रहे हैं, हमें उन्हें CrewAI टूल्स में बदलने की आवश्यकता है। इससे एजेंट्स को जब भी वित्तीय, टेक्निकल या समाचार जानकारी चाहिए, वे सीधे इन्हें कॉल कर सकेंगे।

स्टॉक डेटा टूल्स बनाएं

पहले, न्यूमेरिकल मानों को साफ और सुसंगत रखने के लिए एक छोटा हेल्पर फ़ंक्शन बनाएं:

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

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

अगला, फंडामेंटल्स टूल बनाएं। यह Finnhub का उपयोग करके नवीनतम स्टॉक कीमत, वैल्यूएशन मेट्रिक्स, ग्रोथ, प्रॉफिटेबिलिटी और अन्य कंपनी फंडामेंटल्स प्राप्त करता है।

@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'))}"""

हम पिछले सेक्शन के ऐतिहासिक डेटा और इंडिकेटर्स का उपयोग करके एक टेक्निकल विश्लेषण टूल भी बनाएंगे।

@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)}%"""

यहाँ महत्वपूर्ण हिस्सा @tool डेकोरेटर है। यह एक सामान्य Python फ़ंक्शन को ऐसे टूल में बदल देता है जिसे CrewAI एजेंट किसी टास्क के दौरान कॉल करने का निर्णय ले सकता है।

वेब सर्च टूल जोड़ें

कंपनी की खबरों और हाल के विकास के लिए, हम CrewAI का Tavily सर्च टूल उपयोग करेंगे:

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

हम सर्च को पिछले 30 दिनों तक सीमित रखते हैं और अधिकतम पाँच परिणाम लौटाते हैं, जो हमारे रिसर्च एजेंट्स को पर्याप्त हालिया जानकारी देगा, बिना उन्हें अनावश्यक सामग्री से बोझिल किए।

स्टॉक टूल्स टेस्ट करें

एजेंट्स बनाने से पहले, दोनों कस्टम टूल्स को सीधे चलाएँ:

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

अब आपको चयनित स्टॉक के लिए नवीनतम फंडामेंटल मेट्रिक्स के बाद टेक्निकल इंडिकेटर्स दिखाई देने चाहिए।

5. मल्टी-एजेंट रिसर्च टीम बनाएं

अब जब टूल्स तैयार हैं, हम अपनी मल्टी-एजेंट रिसर्च टीम बना सकते हैं।

हम तीन विशेषज्ञ एजेंट्स का उपयोग करेंगे—एक-एक फंडामेंटल विश्लेषण, टेक्निकल विश्लेषण और हाल की खबरों के लिए—साथ ही एक पोर्टफोलियो मैनेजर जो उनके निष्कर्षों को अंतिम आकलन में मिलाएगा।

विशेषज्ञ एजेंट्स बनाएं

पहले, फंडामेंटल एनालिस्ट बनाएं:

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

अगला, टेक्निकल एनालिस्ट बनाएं:

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

फिर, फाइनेंशियल न्यूज़ एनालिस्ट बनाएं:

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

प्रत्येक विशेषज्ञ को केवल वही टूल मिलता है जिसकी उसे वास्तव में आवश्यकता है। यह वर्कफ़्लो को केंद्रित रखता है और एजेंट्स को असंबंधित टूल्स कॉल करने से रोकता है।

पोर्टफोलियो मैनेजर बनाएं

अंत में, वह मैनेजर एजेंट बनाएं जो सभी तीन विशेषज्ञ रिपोर्टों की समीक्षा करेगा:

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

पोर्टफोलियो मैनेजर को हमारे डेटा टूल्स तक सीधी पहुंच की आवश्यकता नहीं है। इसके बजाय, वह तीनों विशेषज्ञ एजेंट्स की रिपोर्ट के साथ काम करेगा।

allow_delegation=False वर्कफ़्लो को पूर्वानुमेय भी रखता है, जबकि max_iter यह सीमित करता है कि प्रत्येक एजेंट कितने reasoning और टूल-उपयोग चक्र कर सकता है।

6. विशिष्ट रिसर्च टास्क असाइन करें

एजेंट्स बनाना परिभाषित करता है कि वे कौन हैं। अब हमें प्रत्येक को ठीक-ठीक बताना है कि उसे क्या करना चाहिए और उसके अंतिम आउटपुट में क्या होना चाहिए।

रिसर्च टास्क परिभाषित करें

फंडामेंटल विश्लेषण टास्क से शुरू करें:

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

अगला, टेक्निकल विश्लेषण टास्क परिभाषित करें:

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

हाल के विकास के लिए, न्यूज़ रिसर्च टास्क बनाएं:

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

प्रत्येक एजेंट को स्पष्ट टास्क और आउटपुट फ़ॉर्मेट देना महत्वपूर्ण है। इससे पोर्टफोलियो मैनेजर के लिए उनकी रिपोर्ट्स की तुलना करना आसान हो जाता है, बजाय इसके कि हर एजेंट से पूरी तरह अलग तरह की प्रतिक्रियाएँ मिलें।

अंतिम निर्णय टास्क बनाएं

अंतिम टास्क तीनों रिपोर्टों को एक साथ लाता है:

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,
    ],
)

मुख्य हिस्सा context है। यह पोर्टफोलियो मैनेजर को तीनों विशेषज्ञ टास्क के आउटपुट तक पहुंच देता है, जिससे वह अंतिम BUY, HOLD, या SELL आकलन बनाने से पहले फंडामेंटल, टेक्निकल और न्यूज़ सिग्नल की तुलना कर सके।

इस बिंदु पर, हमारे एजेंट्स, टूल्स और टास्क सब तैयार हैं। अब हम सब कुछ एक CrewAI वर्कफ़्लो में कनेक्ट कर सकते हैं और पूरी रिसर्च टीम को चला सकते हैं।

7. मल्टी-एजेंट रिसर्च क्रू चलाएं

अब हम सब कुछ एक साथ ला सकते हैं और पूरा स्टॉक रिसर्च वर्कफ़्लो चला सकते हैं।

क्रू बनाएं

हमारे तीन विशेषज्ञ एजेंट्स और पोर्टफोलियो मैनेजर वाला CrewAI क्रू बनाएं:

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

हम Process.sequential का उपयोग कर रहे हैं, इसलिए रिसर्च टास्क क्रम में चलते हैं। फंडामेंटल, टेक्निकल और न्यूज़ एजेंट पहले अपना विश्लेषण पूरा करते हैं, और फिर पोर्टफोलियो मैनेजर उन रिपोर्ट्स को प्राप्त करके अंतिम आकलन तैयार करता है।

रिसर्च टीम चलाएं

वर्कफ़्लो को असिंक्रोनस रूप से शुरू करें:

result = await crew.kickoff_async()

यह चरण समय ले सकता है क्योंकि एजेंट्स कई LLM और टूल कॉल्स कर रहे होते हैं। मेरे परीक्षण में, पूरा रिसर्च वर्कफ़्लो लगभग 4 से 5 मिनट में पूरा हुआ।

पूरा होने के बाद, अंतिम पोर्टफोलियो मैनेजर रिपोर्ट दिखाएँ:

print(result.raw)

आपको ऊपर के आउटपुट जैसा एक विस्तृत रिपोर्ट मिलनी चाहिए, जिसमें शामिल हैं:

• BUY, HOLD, या SELL सिग्नल
• कुल स्कोर
• कॉन्फिडेंस स्तर
• विशेषज्ञों के स्कोर
• बुल केस
• बियर केस
• कैटालिस्ट्स
• जोखिम
• समर्थन स्रोत

इस उदाहरण में, एजेंट्स ने NVIDIA का स्वतंत्र रूप से विश्लेषण किया और फिर अपने निष्कर्षों को एक एकल, सबूत-आधारित रिसर्च रिपोर्ट में संयोजित किया। यहीं मल्टी-एजेंट अप्रोच का लाभ स्पष्ट होता है: एक मॉडल से एक साथ सब कुछ करने को कहने के बजाय, हर एजेंट अपनी विशेषज्ञता पर ध्यान देता है और फिर पोर्टफोलियो मैनेजर सारी रिसर्च को एक साथ लाता है।

अगर आपको ऊपर का कोड चलाने में कोई समस्या आती है, तो मैंने पूरा Jupyter Notebook, जिसमें सारा कोड और आउटपुट शामिल है, भी जोड़ दिया है, जिसे आप देख या खुद चला सकते हैं: glm-stock-swarm/stock_analyst_crew.ipynb

8. टर्मिनल UI बनाएं और चलाएं

Jupyter Notebook के अंदर सब कुछ टेस्ट करने के बाद, मैंने पूरे वर्कफ़्लो को एक टर्मिनल यूज़र इंटरफेस (TUI) में बदल दिया। हर नोटबुक सेल को मैन्युअल रूप से चलाने के बजाय, अब आप एक ही कमांड से पूरे मल्टी-एजेंट स्टॉक विश्लेषक को लॉन्च कर सकते हैं।

पूरा प्रोजेक्ट, जिसमें कोड और सेटअप निर्देश शामिल हैं, GitHub पर उपलब्ध है: glm-stock-swarm GitHub रिपॉज़िटरी।

ऐप इंस्टॉल करें और चलाएं

रिपॉज़िटरी क्लोन करके शुरू करें:

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

अपनी Z.ai, Finnhub, और Tavily API कीज़ को .env फ़ाइल में जोड़ें, फिर सभी डिपेंडेंसीज़ को uv के साथ इंस्टॉल करें:

uv sync

अंत में, TUI लॉन्च करें:

uv run glm-stock-swarm

किसी स्टॉक का विश्लेषण करें

इंटरफेस एक सरल इनपुट बॉक्स प्रदान करता है जहाँ आप विश्लेषण शुरू करने के लिए कोई भी समर्थित स्टॉक टिकर दर्ज कर सकते हैं।

टिकट सबमिट करने के बाद, आप एजेंट्स को एक-एक करके काम करते देख सकते हैं। फंडामेंटल एनालिस्ट पहले शुरू करता है, उसके बाद टेक्निकल एनालिस्ट, न्यूज़ एनालिस्ट, और अंत में पोर्टफोलियो मैनेजर जो सब कुछ मिलाकर अंतिम निर्णय देता है।

अंत में, TUI सीधे टर्मिनल के अंदर एक पूरा रिपोर्ट जनरेट करता है, जिसमें फंडामेंटल स्कोर, टेक्निकल स्कोर, न्यूज़ स्कोर, ओवरऑल स्कोर, कॉन्फिडेंस, बुल केस, बियर केस, जोखिम, कैटालिस्ट्स और अंतिम BUY, HOLD, या SELL सिग्नल शामिल होते हैं।

फॉलो-अप प्रश्न पूछें

मैंने एक फॉलो-अप चैट भी जोड़ी है ताकि हर बार नया सवाल होने पर आपको पूरा मल्टी-एजेंट पाइपलाइन फिर से न चलानी पड़े।

उदाहरण के लिए, SELL सिफारिश प्राप्त करने के बाद, मैंने पूछा कि क्या मुझे पूरी पोज़िशन बेचनी चाहिए या केवल उसका एक हिस्सा।

चारों एजेंट्स को फिर से लॉन्च करने के बजाय, एप्लिकेशन जनरेटेड रिसर्च रिपोर्ट के संदर्भ का उपयोग करता है और बहुत तेज़ी से फॉलो-अप उत्तर भेजता है।

यह एप्लिकेशन को अधिक व्यावहारिक बनाता है क्योंकि महंगा मल्टी-एजेंट रिसर्च एक बार चलता है, जबकि फॉलो-अप प्रश्न मौजूदा विश्लेषण का पुन: उपयोग कर सकते हैं।

अंतिम विचार

मेरे टेस्ट रन से रिपोर्ट करने लायक बात है टूल-कॉलिंग की विश्वसनीयता। तीनों विशेषज्ञों ने सही टूल चुना, N/A कन्वेंशन का सम्मान किया—यानी मिसिंग डेटा को शून्य नहीं माना—और वह स्कोर-और-सबूत फ़ॉर्मेट लौटाया जिसकी पोर्टफोलियो मैनेजर को ज़रूरत थी। आम तौर पर यहीं सस्ते मॉडल लड़खड़ा जाते हैं।

स्पीड इसका ट्रेड-ऑफ है। Artificial Analysis Z.ai के API पर GLM-5.3-Flash को लगभग 45 आउटपुट टोकन प्रति सेकंड पर क्लॉक करता है, जो इसके आकार के ओपन-वेट मॉडलों के लिए निचले सिरे पर है, और आप इसे एक पूर्ण क्रू रन में 4 से 5 मिनट लगने में महसूस करते हैं। यह उनके इंटेलिजेंस इंडेक्स पर 57 स्कोर करता है जबकि GLM-5.3 के लिए 60 है, तो आप थोड़ी reasoning क्वालिटी छोड़ रहे हैं, लेकिन जिस कीमत पर आप लगभग दसवां हिस्सा दे रहे हैं, वह एक अच्छा सौदा है।

इनमें से कोई भी आपको लॉक-इन नहीं करता। OpenRouter, Hugging Face Inference, या Ollama के जरिए लोकल मॉडल पर स्विच करना आमतौर पर तीन चीजें बदलने जैसा है: API की, मॉडल नाम और बेस URL। टूल्स के लिए भी यही, जहाँ yfinance यहाँ Finnhub और Yahoo का काम कर सकता है।

अगला कदम मैं यह उठाऊँगा कि इसे पेपर-ट्रेडिंग API से वायर कर दूँ और एक मॉर्निंग रन शेड्यूल करूँ। हालांकि इसे डेमो अकाउंट पर ही रखें। इसे एजेंट डिज़ाइन सिखाने के लिए बनाया गया है, ट्रेड करने के लिए नहीं।

अगर आप एजेंटिक AI को बुनियाद से सीखना चाहते हैं, तो हमारा AI Agent Fundamentals स्किल ट्रैक एक बेहतरीन शुरुआती बिंदु है।