GLM-5-Turbo ट्यूटोरियल: रियल-टाइम ब्राउज़र एजेंट बनाएं

GLM-5-Turbo क्या है?

GLM-5-Turbo वास्तविक-विश्व एजेंट वर्कफ़्लो को सपोर्ट करने के लिए डिज़ाइन किया गया है। यह कई सोचने के मोड प्रदान करता है, जिससे उपयोगकर्ता कार्य के आधार पर तेज़ प्रतिक्रियाओं और गहरी तर्कशीलता के बीच संतुलन बना सकते हैं। 

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

इसकी मुख्य ताकतों में से एक है फंक्शन कॉलिंग, जो मॉडल को बाहरी टूल्स को भरोसेमंद तरीके से इनवोक करने देती है। मॉडल JSON जैसे संरचित आउटपुट भी सपोर्ट करता है, जिससे डाउनस्ट्रीम सिस्टम और UI लेयर्स के साथ एकीकरण आसान हो जाता है।

लंबे वर्कफ़्लो के लिए, GLM-5-Turbo में कॉन्टेक्स्ट कैशिंग शामिल है, जो समान जानकारी को बार-बार प्रोसेस किए बिना विस्तृत इंटरेक्शन के दौरान प्रदर्शन बनाए रखने में मदद करती है। यह MCP (Model Context Protocol) के माध्यम से बाहरी सिस्टम के साथ एकीकरण भी सपोर्ट करता है, जिससे मॉडल अतिरिक्त टूल्स और डेटा स्रोतों से जुड़ सकता है।

एजेंट वर्कफ़्लो के लिए बनाया गया

GLM-5-Turbo एजेंट-शैली के परिवेशों के लिए गहराई से अनुकूलित है, खासकर OpenClaw जैसे परिदृश्यों में, जहाँ कार्य कई चरणों, टूल्स और लंबी निष्पादन श्रृंखलाओं से जुड़े होते हैं।

यह ऑप्टिमाइज़ेशन कई अहम क्षेत्रों में सुधार लाता है:

• टूल इनवोकेशन की विश्वसनीयता: यह सुनिश्चित करता है कि मॉडल लगातार सही फंक्शंस को कॉल कर सके।
• इंस्ट्रक्शन डीकंपोज़िशन: डीकंपोज़िशन मॉडल को जटिल कार्यों को छोटे चरणों में तोड़ने देती है।
• लंबी श्रृंखला निष्पादन स्थिरता: यह बहु-चरणीय एजेंट्स के लिए आवश्यक है।

व्यवहार में, GLM-5-Turbo इंटरैक्टिव सिस्टम्स के लिए पर्याप्त तेज़ है, फिर भी बहु-चरणीय, टूल-कॉलिंग परिदृश्यों में विश्वसनीय रहता है—यही हमें ब्राउज़र एजेंट बनाने के लिए चाहिए।

GLM-5-Turbo उदाहरण प्रोजेक्ट: रियल-टाइम ब्राउज़र एजेंट बनाएं

इस ट्यूटोरियल में, हम एक Streamlit एप्लिकेशन बनाएंगे जो एक हल्के ट्रैवल असिस्टेंट की तरह काम करता है। उपयोगकर्ता ऐसा क्वेरी देता है: “अगले शुक्रवार से सोमवार तक SFO से JFK के लिए सबसे सस्ती फ्लाइट्स खोजें।” सिस्टम तब यह करेगा:

• प्रासंगिक फ्लाइट पेजों के लिए वेब पर खोज
• उन पेजों को खोलना और जाँचना
• कीमत, अवधि, और स्टॉप्स जैसी उपयोगी जानकारी निकालना
• सर्वोत्तम विकल्पों का उपयोगकर्ता-अनुकूल प्रारूप में सारांश

उच्च स्तर पर, सिस्टम चार घटकों के साथ मिलकर काम करता है।

• पहला है LLM लेयर (llm_client.py), जो Z.AI या OpenRouter को चैट-कम्प्लीशन अनुरोध भेजता है। 
• दूसरा है ब्राउज़र टूल लेयर (browser_tools.py), जो सर्च करने, पेज खोलने और सामग्री निकालने जैसी क्रियाएँ उपलब्ध कराता है। 
• तीसरा है एजेंट लूप (agent.py), जो मॉडल और टूल्स को बहु-चरणीय वर्कफ़्लो में जोड़ता है। 
• अंत में, Streamlit UI (app.py) इंटरेक्शन और विज़ुअलाइज़ेशन के लिए इंटरफ़ेस देता है।

पूरा सोर्स कोड: https://github.com/AashiDutt/GLM5_TURBO

चरण 1: आवश्यकताएँ

एप्लिकेशन बनाने से पहले, सुनिश्चित करें कि आपके पास ये हैं:

• Python 3.9+
• GLM-5-Turbo API कुंजी (Z.AI या OpenRouter)
• ब्राउज़र ऑटोमेशन के लिए Playwright इंस्टॉल

आवश्यक लाइब्रेरीज़ इंस्टॉल करें:

pip install streamlit pandas python-dotenv requests playwright
playwright install chromium

फ़ाइल app.py में Streamlit, pandas, dotenv, और कस्टम मॉड्यूल्स का उपयोग होता है। जबकि browser_tools.py में requests और Playwright का उपयोग होता है। API कॉल्स llm_client.py के भीतर requests से की जाती हैं।

अब, निम्न कमांड चलाएँ ताकि एक .env फ़ाइल बन जाए, जहाँ हमारी API कुंजी(याँ) रखी जाएँगी:

cp .env.example .env

अपना पसंदीदा API एन्डपॉइंट चुनें और API कुंजी पास करें:

.env
PROVIDER=zai
# Direct Z.AI API
ZAI_API_KEY=Your Z.AI API key
ZAI_BASE_URL=https://api.z.ai/api/paas/v4/chat/completions
ZAI_MODEL=glm-5-turbo
# OpenRouter
OPENROUTER_API_KEY=Your OpenRouter API key
OPENROUTER_BASE_URL=https://openrouter.ai/api/v1/chat/completions
OPENROUTER_MODEL=z-ai/glm-5-turbo
# Browser
HEADLESS=true
MAX_STEPS=10

इसी तरह, Playwright ब्राउज़र को browser_tools.py में इस कंस्ट्रक्टर से लॉन्च किया जाता है:

class BrowserTools:
    def __init__(self, headless: bool = True) -> None:
        self.playwright = sync_playwright().start()
        self.browser = self.playwright.chromium.launch(headless=headless)
        self.context = self.browser.new_context(viewport={"width": 1440, "height": 1100})
        self.page = self.context.new_page()

यह ब्लॉक Playwright का उपयोग करके एक पूरी तरह नियंत्रित ब्राउज़र वातावरण तैयार करता है, जिसका उपयोग एजेंट वेब के साथ इंटरैक्ट करने में करता है। 

यह Playwright इंजन शुरू करता है, Chromium ब्राउज़र लॉन्च करता है, एक पृथक ब्राउज़र सत्र बनाता है और एक नया पेज खोलता है जहाँ सभी क्रियाएँ होती हैं। 

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

चरण 2: LLM क्लाइंट सेटअप करना

अगला, हम अपना LLMClient सेट करेंगे जो समान इंटरफ़ेस के साथ सीधे Z.AI और OpenRouter दोनों को सपोर्ट करता है। प्रोवाइडर-विशिष्ट एन्डपॉइंट कंस्ट्रक्टर में चुना जाता है। चूँकि कीमतें तुलनीय हैं, आप इस डेमो के लिए अपनी पसंद के आधार पर कोई भी API उपयोग कर सकते हैं।

मुख्य सेटअप इस प्रकार है:

class LLMClient:
    def __init__(
        self,
        provider: str,
        api_key: str,
        model: str,
        app_name: str = "GLM-5 Browser Agent Demo",
        app_url: str = "http://localhost:8501",
    ) -> None:
        self.provider = provider.lower().strip()
        self.api_key = api_key
        self.model = model
        if self.provider == "zai":
            self.url = os.getenv("ZAI_BASE_URL", "https://api.z.ai/api/paas/v4/chat/completions")
        elif self.provider == "openrouter":
            self.url = os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1/chat/completions")

यह इनिशियलाइज़र उपयुक्त API एन्डपॉइंट (Z.AI या OpenRouter) चुनकर LLM क्लाइंट को कॉन्फ़िगर करता है, जबकि इंटरफ़ेस एक समान रखता है। 

यह API कुंजी, मॉडल और एन्डपॉइंट URL संग्रहीत करता है, जिससे सिस्टम का बाकी हिस्सा प्रोवाइडर-विशिष्ट विभिन्नताओं की चिंता किए बिना मॉडल को कॉल कर सके।

इसके बाद create_chat_completion() पेलोड बनाता है, आवश्यकता होने पर टूल्स संलग्न करता है और लौटाए गए टूल कॉल्स को पार्स करता है। 

payload: Dict[str, Any] = {
    "model": self.model,
    "messages": messages,
    "temperature": temperature,
    "max_tokens": max_tokens,
    "stream": False,
}
if tools:
    payload["tools"] = tools
    payload["tool_choice"] = "auto"

ऊपर दिया गया पेलोड मॉडल को भेजे गए अनुरोध को परिभाषित करता है, जिसमें वार्तालाप का संदर्भ और जनरेशन पैरामीटर्स शामिल हैं। tools संलग्न करके और tool_choice="auto" सक्षम करके, मॉडल यह तय कर सकता है कि बाहरी फंक्शंस कब इनवोक करने हैं।

चरण 3: ब्राउज़र टूल्स परिभाषित करना

agent.py में, हम एक टूल स्कीमा परिभाषित करते हैं जिसे मॉडल कॉल कर सकता है। इनमें search_web, open_url, open_search_result, extract_page, extract_flight_cards, click, type_text, और wait_for_text शामिल हैं।

यहाँ एक उदाहरण टूल परिभाषा है:

{
    "type": "function",
    "function": {
        "name": "search_web",
        "description": "Search the public web for flight result pages or travel aggregators.",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "max_results": {"type": "integer", "default": 8},
            },
            "required": ["query"],
        },
    },
}

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

एक्जीक्यूशन साइड पर, ये टूल्स browser_tools.py में इम्प्लीमेंट किए गए हैं। इस डेमो के लिए, हमने DuckDuckGo के HTML एन्डपॉइंट का उपयोग किया ताकि वर्तमान परिणाम लिंक संग्रहीत किए जा सकें और आगे की नेविगेशन हो सके।

def search_web(self, query: str, max_results: int = 8) -> Dict[str, Any]:
    url = f"https://html.duckduckgo.com/html/?q={quote_plus(query)}"
    headers = {"User-Agent": "Mozilla/5.0"}
    resp = requests.get(url, headers=headers, timeout=30)
    resp.raise_for_status()
    html = resp.text

ऊपर दिया गया search_web() फंक्शन कच्चे HTML परिणामों को फ़ेच और पार्स करके हल्की-फुल्की वेब सर्च करता है, जिससे किसी पेड सर्च API की ज़रूरत नहीं रहती। यह परिणामों को आंतरिक रूप से भी संग्रहीत करता है ताकि एजेंट अगले चरणों में उन पर नेविगेट कर सके।

अब जब हमने परिभाषित कर लिया है कि एजेंट वेब के साथ कैसे इंटरैक्ट कर सकता है, अगला चरण है यह देखना कि वह वेब सर्च के माध्यम से फ्लाइट जानकारी वास्तव में कैसे निकालता है।

चरण 4: फ्लाइट जानकारी निकालना

एक संभावित स्रोत मिलने पर, मॉडल को उसे जाँचना होता है। हम ब्राउज़र टूल्स (चरण 3 से) का उपयोग करके कच्चे पेज स्नैपशॉट निकाल सकते हैं।

चरण 4.1: पेज खोलना और निकालना

हम open_url() टूल का उपयोग वेब पेज लोड करने और शीर्षक, URL और दृश्य टेक्स्ट सहित एक स्नैपशॉट लौटाने के लिए करेंगे।

def open_url(self, url: str) -> Dict[str, Any]:
    self.page.goto(url, wait_until="domcontentloaded", timeout=45000)
    self.page.wait_for_timeout(1200)
    return self._page_snapshot()

व्यापक निष्कर्षण के लिए, हम निम्न extract_page() टूल का उपयोग करेंगे जो पेज स्नैपशॉट और वर्तमान पेज से एकत्र किए गए लिंक का सेट लौटाता है।

def extract_page(self, max_chars: int = 7000, link_limit: int = 20) -> Dict[str, Any]:
    snapshot = self._page_snapshot(max_chars=max_chars)
    snapshot["links"] = self._collect_links(limit=link_limit)
    self.current_links = snapshot["links"]
    return snapshot

यह उपयोगी है क्योंकि मॉडल को हमेशा बिना सोचे-समझे क्लिक करने की आवश्यकता नहीं होती। कभी-कभी वह पहले वर्तमान पेज के टेक्स्ट और उपलब्ध लिंक्स की जाँच कर सकता है, फिर अगला कदम तय कर सकता है।

चरण 4.2: ह्यूरिस्टिक फ्लाइट एक्सट्रैक्शन

डेमो का एक अहम भाग है extract_flight_cards() फंक्शन जो दृश्य पेज टेक्स्ट लेता है और कीमत, समय, अवधि और स्टॉप्स का पता लगाने के लिए regex पैटर्न्स का उपयोग करता है।

उस लॉजिक का कोर यह है:

money_pattern = re.compile(r"(?:\$|USD\s?)(\d{2,5})")
time_pattern = re.compile(r"\b\d{1,2}:\d{2}\s?(?:AM|PM|am|pm)?\b")
duration_pattern = re.compile(r"\b\d{1,2}\s?h\s?\d{0,2}\s?m?\b|\b\d{1,2}\s?hr\s?\d{0,2}\s?min?\b", re.I)
stop_pattern = re.compile(r"nonstop|1 stop|2 stops|3 stops", re.I)

ये regex पैटर्न्स सामान्य फ्लाइट-संबंधी संकेतों के डिटेक्टर की तरह काम करते हैं। money_pattern $299 या USD 299 जैसे फ़ॉर्मैट में कीमतों को पकड़ता है, जबकि time_pattern प्रस्थान और आगमन समय पहचानता है। 

इसी तरह, duration_pattern यात्रा अवधि निकालता है, और stop_pattern बताता है कि फ्लाइट नॉनस्टॉप है या उसमें लेओवर्स हैं। आप किसी भी उपयोग-केस के लिए ऐसे ही पैटर्न बना सकते हैं।

इन संकेतों को परिभाषित करने के बाद, फंक्शन छोटे-छोटे टेक्स्ट हिस्सों को स्कैन करता है और सार्थक संयोजनों की तलाश करता है। मिलान मिलने पर, यह एक संरचित फ्लाइट कार्ड बनाता है:

card = {
    "snippet": joined[:350],
    "price_usd": int(price_match.group(1)),
    "times": times[:2],
    "duration": duration.group(0) if duration else None,
    "stops": stops.group(0) if stops else None,
}

ऊपर दिया ब्लॉक कच्चे टेक्स्ट को फ्लाइट विकल्प के एक संरचित प्रतिनिधित्व में बदलता है। यह कीमत निकालता है, समय प्रविष्टियों को सबसे प्रासंगिक दो तक सीमित करता है, और मिसिंग फ़ील्ड्स को संभालता है। यह मूल संदर्भ बनाए रखता है, जो डिबगिंग में उपयोगी है।

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

चरण 5: एजेंट लूप

वास्तविक एजेंट व्यवहार BrowserAgent क्लास (agent.py के अंदर) में है। यह क्लास प्रॉम्प्ट और टूल स्कीमा मॉडल को भेजती है, जाँचती है कि मॉडल कोई टूल कॉल करना चाहता है या नहीं, उस टूल को एक्जीक्यूट करती है, टूल परिणाम को बातचीत में वापस जोड़ती है, और तब तक जारी रहती है जब तक अंतिम उत्तर उत्पन्न न हो जाए।

मुख्य लूप इस प्रकार है:

for step in range(1, self.max_steps + 1):
    assistant = self.llm.create_chat_completion(
        messages=messages,
        tools=TOOLS,
        temperature=0.2,
        max_tokens=2200,
        enable_thinking=False,
    )
    if assistant.tool_calls:
        ...
        result = self.tool_runner(tc.name, tc.arguments)
        ...
        continue
    final_content = assistant.content.strip()
    if final_content:
        yield {"type": "final", "step": step, "content": final_content}
        return

यह लूप डेमो का हृदय है। 

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

यह प्रक्रिया तब तक जारी रहती है जब तक मॉडल टूल कॉल करने के बजाय अंतिम प्रतिक्रिया नहीं दे देता।

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

चरण 6: टूल्स को ऐप से जोड़ना

app.py में, हम मॉडल द्वारा अनुरोधित टूल नामों को वास्तविक ब्राउज़र मेथड्स से मैप करते हैं। यह मैपिंग make_tool_runner() फंक्शन से लागू होती है:

def make_tool_runner(browser: BrowserTools):
    def run(name: str, args: Dict[str, Any]):
        if name == "search_web":
            return browser.search_web(**args)
        if name == "open_url":
            return browser.open_url(**args)
        if name == "open_search_result":
            return browser.open_search_result(**args)
        if name == "extract_page":
            return browser.extract_page(**args)
        if name == "extract_flight_cards":
            return browser.extract_flight_cards(**args)

यह फंक्शन मॉडल और ब्राउज़र के बीच डिस्पैचर की तरह काम करता है। मॉडल केवल टूल का नाम और आर्ग्युमेंट्स देता है, और run() उसे BrowserTools इंस्टैंस पर फंक्शन कॉल में बदल देता है। 

अब जब एजेंट सफलतापूर्वक टूल्स को कॉल और एक्जीक्यूट कर सकता है, अगला चरण है वह यूज़र इंटरफ़ेस बनाना जो सब कुछ एक साथ जोड़े।

चरण 7: Streamlit UI बनाना

Streamlit UI ब्राउज़र एजेंट को एक इंटरैक्टिव एप्लिकेशन में बदल देता है। यह उपयोगकर्ता से यात्रा विवरण एकत्र करता है, एजेंट लॉन्च करता है, मध्यवर्ती चरणों को स्ट्रीम करता है और अंत में शीर्ष फ्लाइट विकल्पों के संरचित टेबल के साथ एक सारांश रेंडर करता है। यह पूरा UI फ्लो app.py में लागू है।

st.set_page_config(page_title="GLM-5 Browser Agent", page_icon="", layout="wide")
st.title("GLM-5-Turbo Real-Time Browser Agent")
st.subheader("Trip Request")
origin = st.text_input("Origin", value="SFO")
destination = st.text_input("Destination", value="JFK")
depart_date = st.date_input("Depart date")
return_date = st.date_input("Return date")
adults = st.number_input("Adults", min_value=1, max_value=9, value=1)
natural_request = st.text_area(
    "Optional natural language request",
    value="Find the cheapest reasonable flight options and summarize the best ones.",
    height=120,
)
user_query = (
    f"Find flight options from {origin} to {destination} for {adults} adult(s). "
    f"Departure date: {depart_date}. Return date: {return_date}. "
    f"User preference: {natural_request}"
)
run = st.button("Run browser agent", type="primary", use_container_width=True)
if run:
    if not api_key:
        st.error("Please enter an API key in the sidebar.")
        st.stop()
    llm = LLMClient(provider=provider, api_key=api_key, model=model)
    event_box = st.container(border=True)
    result_box = st.container(border=True)
    all_events = []
    with managed_browser(headless=headless) as browser:
        agent = BrowserAgent(llm=llm, tool_runner=make_tool_runner(browser), max_steps=max_steps)
for event in agent.stream(user_query):
    all_events.append(event)
    with event_box:
        if event["type"] == "status":
            st.write(f"**Step {event['step']}** — {event['content']}")
        elif event["type"] == "tool_call":
            with st.expander(f"Step {event['step']} • Tool call: {event['tool']}", expanded=False):
                st.json(event["arguments"])
        elif event["type"] == "tool_result":
            with st.expander(f"Step {event['step']} • Tool result: {event['tool']}", expanded=False):
                st.json(event["result"])
        elif event["type"] == "final":
            st.success("Agent finished.")
final_event = next((e for e in reversed(all_events) if e["type"] == "final"), None)
final_text = final_event["content"] if final_event else ""
with result_box:
    st.subheader("Final Answer")
    parsed = parse_final_json(final_text)
    if parsed:
        st.markdown(render_final_markdown(parsed))
        options_df = build_options_dataframe(parsed)
        if not options_df.empty:
            st.subheader("Top options table")
            st.dataframe(
                options_df,
                use_container_width=True,
                column_config={
                    "Link": st.column_config.LinkColumn("Link", display_text="Open source"),
                },
            )
    else:
        st.markdown(final_text)

Streamlit UI सभी घटकों को इस प्रकार जोड़ता है:

• st.set_page_config() और st.title() कॉल्स ऐप का समग्र लेआउट और शीर्षक निर्धारित करते हैं, जबकि st.text_input(), st.date_input(), st.number_input() और st.text_area() जैसे इनपुट विड्जेट्स यात्रा विवरण एकत्र करते हैं। 
• जब उपयोगकर्ता Run browser agent बटन क्लिक करता/करती है, तो ऐप पहले जाँचता है कि API कुंजी उपलब्ध है या नहीं, फिर LLMClient इनिशियलाइज़ करता है। इसके बाद, यह मध्यवर्ती एजेंट लॉग्स और अंतिम परिणामों के लिए अलग कंटेनर बनाता है और एक मैनेज्ड Playwright ब्राउज़र सत्र खोलता है। उस सत्र के अंदर, BrowserAgent इवेंट्स की स्ट्रीमिंग शुरू करता है, और UI प्रत्येक स्टेटस अपडेट, टूल कॉल और टूल परिणाम दिखाता है।
• एजेंट के समाप्त होने पर, ऐप अंतिम इवेंट निकालता है, लौटाए गए JSON को पार्स करता है और उसे रेंडर करता है। सारांश render_final_markdown() के माध्यम से दिखाया जाता है, जबकि build_options_dataframe() संरचित फ्लाइट विकल्पों को क्लिक करने योग्य सोर्स लिंक्स के साथ एक टेबल में बदलता है।

यह चरण पूरा होने के साथ, आप सब कुछ app.py के रूप में सेव कर सकते हैं और ऐप को इस कमांड से लॉन्च कर सकते हैं:

streamlit run app.py

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

वर्तमान एक्सट्रैक्शन लॉजिक जानबूझकर ह्यूरिस्टिक है, जो सिस्टम को सरल और समझने में आसान रखता है।

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

निष्कर्ष

इस ट्यूटोरियल में, हमने GLM-5-Turbo, Playwright, और Streamlit के साथ एक रियल-टाइम ब्राउज़र एजेंट बनाया। मॉडल योजनाकार की तरह काम करता है, ब्राउज़र टूल्स एक्जीक्यूशन लेयर की तरह, और UI संरचित परिणामों को उपयोगकर्ता-अनुकूल प्रारूप में बदल देता है।

सबसे महत्वपूर्ण सीख यह है कि मूल्य केवल मॉडल से नहीं आता। यह मॉडल, नियंत्रित टूल लेयर और एजेंट लूप के संयोजन से आता है। 

फिर भी, इस प्रोजेक्ट के कई एक्सटेंशन्स हैं। आप साइट-विशिष्ट पार्सर्स जोड़कर एक्सट्रैक्शन में सुधार कर सकते हैं, सिस्टम को होटलों या यात्रा कार्यक्रमों तक बढ़ा सकते हैं, या नॉनस्टॉप फ्लाइट्स या पसंदीदा एयरलाइंस जैसी उपयोगकर्ता प्राथमिकताओं को एकीकृत कर सकते हैं। ये आपको इस डेमो को एक पूर्ण ब्राउज़र एक्सटेंशन में बदलने में मदद कर सकते हैं।