मुख्य सामग्री पर जाएँ

Qwen4-Max ट्यूटोरियल: एक लीगल नोटिस एनालाइज़र बनाएं

Qwen4-Max, Qwen-Agent और Olostep के साथ एक US लीगल नोटिस एनालाइज़र बनाएं। स्कैम फ़्लैग करें, फ़ोटो और PDF पढ़ें, और दावों को आधिकारिक स्रोतों से सत्यापित करें।
· 12 मि॰ पढ़ें

AI के साथ खोजें

क्या आपको कभी कोई सरकारी नोटिस मिला है और आपने सोचा है कि यह असली है या नहीं, क्या आपको जवाब देना चाहिए, या कोई आपको धोखा देने की कोशिश कर रहा है?

लीगल नोटिस पढ़ना मुश्किल होता है, खासकर जब जटिल भाषा के साथ भुगतान की मांगें और डेडलाइन मिल जाती हैं। स्कैमर इसी उलझन का फ़ायदा उठाकर सरकारी एजेंसियों का रूप धारण करते हैं और झूठी तत्परता पैदा करते हैं।

इस ट्यूटोरियल में, हम Qwen4-Max और Qwen-Agent फ़्रेमवर्क का उपयोग करके एक US लीगल नोटिस एनालाइज़र बनाएंगे। यह एप्लिकेशन टेक्स्ट, इमेज और PDF स्वीकार करता है, संदिग्ध भुगतान तरकीबों को फ़्लैग करता है, और जब किसी चीज़ की पुष्टि करनी हो तो आधिकारिक कानूनी संसाधनों को खोजता है।

पूरी तरह एक बड़े भाषा मॉडल (LLM) पर निर्भर होने के बजाय, हम इसे दो Python टूल्स के साथ जोड़ेंगे। पहला रेग्युलर एक्सप्रेशन का उपयोग करके आम स्कैम संकेतकों को पकड़ता है। दूसरा Olostep का उपयोग करके आधिकारिक सरकारी वेबसाइटों और Cornell Legal Information Institute (LII) पर खोज करता है।

संक्षेप में

  • हम Qwen4-Max, Qwen-Agent और Olostep के साथ एक लीगल नोटिस एनालाइज़र बनाते हैं जो टेक्स्ट, फ़ोटो और PDF स्वीकार करता है।
  • एक regex-आधारित जोखिम गेट मॉडल के रिसर्च शुरू करने से पहले स्कैम पैटर्न और मिलते-जुलते डोमेन फ़्लैग करता है।
  • रिसर्च टूल लुकअप को .gov साइटों और Cornell LII तक सीमित रखता है, और एजेंट स्पष्ट रूप से फर्जी नोटिस पर रिसर्च छोड़ देता है।
  • मेरी टेस्टिंग में, Qwen4-Max ने फ़ोटोग्राफ़ किए गए नोटिस अच्छी तरह पढ़े, लेकिन साधारण टास्क पर यह धीमा था और इसका नैटिव वेब सर्च अविश्वसनीय रहा।

Qwen4-Max क्या है?

Qwen4-Max Qwen4 परिवार में Alibaba का फ़्लैगशिप मॉडल है, जो 16 नवंबर, 2026 को लॉन्च हुआ। यह एक sparse mixture-of-experts (MoE) मॉडल है, जिसमें आर्किटेक्चरल सुधार, नैटिव विज़न और बड़ा संदर्भ विंडो है, जिसे जटिल रीजनिंग और एजेंटिक एप्लिकेशंस के लिए डिज़ाइन किया गया है।

हमारे प्रोजेक्ट से सबसे संबंधित फ़ीचर्स ये हैं:

  • Sparse MoE आर्किटेक्चर: Qwen4-Max में 2.4T बैकबोन पैरामीटर, प्रति टोकन 71B एक्टिव, और अतिरिक्त 328B N-gram एम्बेडिंग पैरामीटर हैं। Gated DeltaNet लेयर्स और Qwen Sparse Attention लंबे संदर्भ की लागत कम रखते हैं।
  • नैटिव विज़न: मॉडल सीधे इमेज पढ़ता है, इसलिए हमें अलग ऑप्टिकल कैरेक्टर रिकग्निशन (OCR) पाइपलाइन बनाने की ज़रूरत नहीं—हम लीगल नोटिस की फ़ोटो सीधे भेज सकते हैं।
  • 1M-टोकन संदर्भ विंडो: यह लंबे दस्तावेज़ों और बहुत सारी सहायक जानकारी के लिए पर्याप्त है।
  • बेहतर टोकन दक्षता: Alibaba के अनुसार, Qwen4-Max Work360 पर High reasoning effort में Qwen3.8-Max की तुलना में लगभग 35% कम टोकन इस्तेमाल करता है, और Terminal-Bench 4.0 पर लगभग 49% कम। Xhigh effort पर, कमी क्रमशः लगभग 24% और 48% है।
  • कम टास्क लागत: Work360 पर Qwen4-Max ने 52.69 स्कोर किया, जो Qwen3.8-Max के 47.74 से ज़्यादा है, जबकि प्रति टास्क औसत लागत $4.43 से घटकर $1.67 हो गई—62% की कमी।

यहाँ Alibaba की घोषणा के बेंचमार्क नतीजे हैं, जो दिखाते हैं कि Qwen4-Max ने लगभग हर क्षमता में Qwen3.8-Max पर सुधार किया:

कोडिंग, काम और लंबे-अवधि वाले टास्क्स में Qwen4-Max और अन्य मॉडलों की अलीबाबा की बेंचमार्क तुलना

चित्र 1: Qwen4-Max बेंचमार्क नतीजे। स्रोत: Qwen, Qwen4-Max: Your New Teammate Has Arrived।

लीगल नोटिस एनालाइज़र कैसे काम करता है?

एनालाइज़र एक सिंगल Qwen-Agent असिस्टेंट है जो दो Python टूल्स का समन्वय करता है, जबकि Qwen4-Max दस्तावेज़ को समझने और तर्क करने का काम संभालता है। कोड लिखने से पहले, वर्कफ़्लो देख लें।

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

चित्र 2: लीगल नोटिस एनालाइज़र का वर्कफ़्लो।

वर्कफ़्लो में 6 चरण हैं:

  1. उपयोगकर्ता नोटिस को टेक्स्ट, इमेज या PDF के रूप में सबमिट करता है।
  2. Qwen4-Max दस्तावेज़ पढ़ता है और उसके मुख्य विषयों की पहचान करता है।
  3. एजेंट risk_gate कॉल करके संदिग्ध भुगतान निर्देशों, धमकियों और लिंक की जाँच करता है।
  4. अगर दस्तावेज़ साफ़ तौर पर फर्जी है, तो एजेंट बाहरी रिसर्च छोड़ देता है।
  5. अन्यथा, एजेंट lookup_law कॉल करके आधिकारिक कानूनी संसाधनों में खोज करता है।
  6. Qwen4-Max एक संरचित प्रतिक्रिया देता है जिसमें निर्णय, सारांश, साक्ष्य और सुझाए गए अगले कदम शामिल होते हैं।

मुख्य डिज़ाइन चुनाव यह है कि LLM सब कुछ नहीं करता। Python निर्धारक जाँचें संभालता है, Olostep बाहरी रिसर्च संभालता है, और Qwen4-Max दस्तावेज़ समझ और तर्क।

इससे वर्कफ़्लो सरल रहता है और एजेंट के पास हर काम के लिए उचित टूल होता है। अगर एजेंट की शब्दावली आपके लिए नई है, तो हमारा Introduction to AI Agents कोर्स बिना कोडिंग के मूल बातें कवर करता है।

1. वातावरण सेट करना

हम Jupyter Notebook, मॉडल एक्सेस के लिए QwenCloud, और वेब सर्च व स्क्रैपिंग के लिए Olostep का उपयोग करेंगे।

सबसे पहले, QwenCloud पर एक अकाउंट बनाएं, क्रेडिट जोड़ें या Token Plan की सदस्यता लें, और डैशबोर्ड से एक API कुंजी जनरेट करें। QwenCloud आपके चुने गए क्षेत्र के आधार पर API endpoint प्रदान करता है।

कानूनी रिसर्च के लिए आपको एक Olostep API कुंजी भी चाहिए।

Jupyter Notebook लॉन्च करने से पहले टर्मिनल में अपने environment वेरिएबल सेट करें। आप इन्हें नोटबुक के अंदर os.environ से भी सेट कर सकते हैं।

export QWEN_API_KEY="your-qwen-api-key"
export QWEN_BASE_URL="https://token-plan.maas.qwencloudapi.com/compatible-mode/v1"
export OLOSTEP_API_KEY="your-olostep-api-key"

मैं Token Plan endpoint का उपयोग करता/करती हूँ, जो मुझे मॉडलों तक रियायती पहुँच देता है। यदि आप pay-as-you-go करते हैं, तो अपने क्षेत्र के लिए QwenCloud द्वारा दिखाए गए endpoint का उपयोग करें।

अगला, अपने नोटबुक में आवश्यक डिपेंडेंसी इंस्टॉल करें:

%pip install -q "qwen-agent[rag]" olostep soundfile tqdm

rag एक्स्ट्रा pdfplumber जैसे दस्तावेज़-प्रोसेसिंग पैकेज जोड़ता है, जिसका हम PDF पढ़ने के लिए उपयोग करेंगे। संस्करण 0.0.34 तक, Qwen-Agent स्टार्टअप पर soundfile और tqdm को डिपेंडेंसी घोषित किए बिना भी इम्पोर्ट करता है, इसलिए हम दोनों को स्पष्ट रूप से इंस्टॉल करते हैं।

Qwen4-Max को कॉन्फ़िगर करना

अब, हम मॉडल और Olostep क्लाइंट को इनिशियलाइज़ करेंगे। मैं Singapore क्षेत्र का उपयोग कर रहा/रही हूँ, जहाँ Token Plan भी उपलब्ध है।

import logging
import os
import re
import warnings

# The Olostep SDK reads this at import time, so set it first
os.environ.setdefault("OLOSTEP_API_TIMEOUT", "40")

from olostep import Olostep
from qwen_agent.agents import Assistant
from qwen_agent.llm.schema import Message
from qwen_agent.tools.base import BaseTool
from qwen_agent.utils.utils import extract_text_from_message

warnings.filterwarnings("ignore")
logging.getLogger("qwen_agent_logger").setLevel(logging.ERROR)

MODEL = os.getenv("QWEN_MODEL", "qwen4-max")

LLM = {
    "model": MODEL,
    "model_type": "qwenvl_oai",
    "model_server": os.environ["QWEN_BASE_URL"],
    "api_key": os.environ["QWEN_API_KEY"],
    "generate_cfg": {
        "max_tokens": 3000,
        "extra_body": {"reasoning_effort": "low"},
    },
}

olostep = Olostep(api_key=os.environ["OLOSTEP_API_KEY"])

यह Qwen4-Max को मल्टीमॉडल इनपुट के लिए कॉन्फ़िगर करता है, एक reasoning effort स्तर सेट करता है, और रिसर्च क्लाइंट को इनिशियलाइज़ करता है। ध्यान दें कि OLOSTEP_API_TIMEOUT इम्पोर्ट से पहले सेट किया गया है, क्योंकि SDK इसे लोड होते समय पढ़ता है।

कुछ कॉन्फ़िगरेशन विकल्प समझने लायक हैं:

  • model उस मॉडल को निर्दिष्ट करता है जिसे हम उपयोग करना चाहते हैं।
  • model_type हमें OpenAI-कम्पैटिबल मल्टीमॉडल इंटरफ़ेस के माध्यम से इमेज भेजने देता है।
  • model_server QWEN_BASE_URL के endpoint की ओर इशारा करता है।
  • max_tokens जनरेटेड प्रतिक्रिया की लंबाई सीमित करता है।
  • reasoning_effort नियंत्रित करता है कि मॉडल कितना तर्क करे। हम low उपयोग करते हैं ताकि प्रतिक्रियाएँ तेज़ रहें।
  • OLOSTEP_API_TIMEOUT रिसर्च अनुरोधों पर सेकंड में समय-सीमा सेट करता है।

पुन: प्रयोज्य एजेंट हेल्पर्स बनाना

हम टेक्स्ट और इमेज दोनों इनपुट प्रोसेस करेंगे, इसलिए एजेंट चलाने के लिए एक पुन: प्रयोज्य फ़ंक्शन बनाते हैं।

def run_agent(agent, prompt, images=None):
    content = [{"text": prompt}] + [
        {"image": image} for image in (images or [])
    ]
    final = agent.run_nonstream([
        {"role": "user", "content": content}
    ])
    return extract_text_from_message(
        Message.model_validate(final[-1]),
        add_upload_info=False,
    )

यह फ़ंक्शन प्रॉम्प्ट और वैकल्पिक इमेजेज़ Qwen-Agent को भेजता है, अंतिम प्रतिक्रिया का इंतज़ार करता है, और जनरेटेड टेक्स्ट निकालता है।

हमें PDF पढ़ने के लिए भी एक हेल्पर चाहिए।

def read_pdf(path):
    import pdfplumber

    with pdfplumber.open(path) as pdf:
        return "\n".join(
            page.extract_text() or "" for page in pdf.pages
        )

यह फ़ंक्शन हर PDF पेज से selectable टेक्स्ट निकालता है और उसे एक स्ट्रिंग में जोड़ देता है।

ध्यान दें: pdfplumber OCR नहीं करता। स्कैन किए गए PDF जिनमें केवल इमेज होती हैं, उनके प्रत्येक पेज को इमेज के रूप में रेंडर करें और सीधे Qwen4-Max को भेजें।

2. जोखिम गेट के साथ स्कैम डिटेक्शन बनाना

पहला कस्टम टूल संदिग्ध व्यवहार की पहचान करता है। हर संदिग्ध भुगतान निर्देश को पहचानने के लिए LLM से कहने के बजाय, हम रेग्युलर एक्सप्रेशन के जरिए ज्ञात स्कैम तरकीबों का पता लगा सकते हैं।

यह तेज़, निर्धारक है और कोई मॉडल टोकन उपयोग नहीं करता। अगर आपको सिंटैक्स पर रिफ़्रेशर चाहिए, हमारा Regular Expressions in Python कोर्स इसे कवर करता है।

स्कैम डिटेक्शन नियम परिभाषित करना

आइए रेग्युलर एक्सप्रेशन की एक सूची और सरकारी एजेंसियों व उनके आधिकारिक डोमेन्स के बीच एक मैपिंग से शुरू करें।

RULES = [
    ("gift cards", r"\b(gift\s*cards?|itunes|google play|amazon card)\b"),
    ("crypto", r"\b(bitcoin|btc|usdt|crypto\w*|coinbase|binance)\b"),
    ("wire transfer", r"\b(wire transfer|western union|moneygram)\b"),
    ("payment app", r"\b(zelle|venmo|cash app|paypal)\b"),
    ("arrest threat", r"\b(arrest|warrant|deport\w*)\b"),
    ("extreme urgency", r"\b(within 24 hours|final notice|last chance)\b"),
    ("secrecy", r"\b(do not (tell|discuss|contact)|keep this confidential)\b"),
    ("card numbers by phone", r"\bcard numbers?\b"),
    ("qr or crypto atm", r"\b(qr code|bitcoin atm|crypto atm)\b"),
]

OFFICIAL = {
    "irs": "irs.gov",
    "internal revenue": "irs.gov",
    "ftc": "ftc.gov",
    "cfpb": "consumerfinance.gov",
    "social security": "ssa.gov",
    "uscis": "uscis.gov",
    "justice": "justice.gov",
    "hud": "hud.gov",
    "uscourts": "uscourts.gov",
}

URL_RX = re.compile(r"https?://[^\s)\"'<>]+")

यह कोड स्कैम संकेतक परिभाषित करता है और एजेंसी नामों को उन डोमेन्स से मैप करता है जो वे वास्तव में इस्तेमाल करते हैं। उदाहरण के लिए, यदि कोई नोटिस IRS का उल्लेख करता है, तो एप्लिकेशन उसके लिंक को irs.gov से मिलाकर देखता है।

डोमेन्स निकालना और मान्य करना

इसके बाद, हमें एक हेल्पर चाहिए जो URL से होस्टनेम निकाले।

from urllib.parse import urlparse


def host_of(url):
    return (urlparse(url).hostname or "").lower().rstrip(".")


def is_official_domain(host, domain):
    return host == domain or host.endswith("." + domain)

यह होस्टनेम निकालता है और जांचता है कि क्या यह आधिकारिक डोमेन है या वैध सबडोमेन। यह अंतर मायने रखता है: एक साधारण endswith() चेक fakeirs.gov को IRS वेबसाइट मान लेगा।

रिस्क गेट टूल इम्प्लीमेंट करना

अब हम इन नियमों को एक कस्टम Qwen-Agent टूल में जोड़ सकते हैं।

class RiskGate(BaseTool):
    name = "risk_gate"
    description = (
        "Scan a notice for payment tactics, threats, urgency, "
        "secrecy, and suspicious agency links. "
        "Call once before any other tool."
    )
    parameters = {
        "type": "object",
        "properties": {
            "text": {
                "type": "string",
                "description": (
                    "The full notice text, including links "
                    "and payment instructions."
                ),
            }
        },
        "required": ["text"],
    }

    def call(self, params, **kwargs):
        text = self._verify_json_format_args(params)["text"]
        low = text.lower()
        flags = [
            f"scam indicator: {label}"
            for label, pattern in RULES
            if re.search(pattern, low)
        ]
        agency = next(
            (
                domain
                for word, domain in OFFICIAL.items()
                if re.search(rf"\b{re.escape(word)}\b", low)
            ),
            None,
        )
        if agency:
            hosts = {
                host_of(url)
                for url in URL_RX.findall(text)
            }
            flags += [
                f"lookalike domain: {host} is not {agency}"
                for host in sorted(hosts)
                if host and not is_official_domain(host, agency)
            ]
        return "\n".join(flags) or "no flags"

यह टूल मिलते-जुलते पैटर्न के लिए नोटिस को स्कैन करता है, उसके URL को एजेंसी के आधिकारिक डोमेन से मिलाता है, और संदिग्ध संकेतक वापस करता है। एजेंसी नाम पूरे शब्द के रूप में मिलाए जाते हैं, इसलिए "irs" किसी "first" जैसे शब्द पर ट्रिगर नहीं होता।

उदाहरण के लिए, हमारे टेस्ट 1 के काल्पनिक IRS नोटिस से यह निकलता है:

scam indicator: gift cards
scam indicator: wire transfer
scam indicator: arrest threat
scam indicator: extreme urgency
scam indicator: secrecy
scam indicator: card numbers by phone
lookalike domain: irs-gov-payments.top is not irs.gov

एजेंट ये नतीजे अपने संदर्भ के हिस्से के रूप में प्राप्त करता है और नोटिस संदिग्ध है या नहीं, यह तय करते समय इनका उपयोग करता है।

3. लीगल रिसर्च टूल बनाना

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

इसके बजाय, हम रिसर्च को आधिकारिक US सरकारी वेबसाइटों और Cornell LII तक सीमित रखते हैं। हम Olostep का उपयोग करेंगे क्योंकि यह एक ही रिक्वेस्ट में कई नतीजों को खोज और स्क्रैप कर सकता है। अगर आप किसी और विकल्प से तुलना करना चाहते हैं, तो हमारा Firecrawl ट्यूटोरियल देखें।

रिसर्च प्रतिबंध परिभाषित करना

पहले, अनुमत स्रोतों और रिट्रीवल पर कुछ सीमाएँ परिभाषित करें।

def is_allowed_host(host):
    return host.endswith(".gov") or is_official_domain(
        host, "law.cornell.edu"
    )


MAX_PAGES = 2
PAGE_CHARS = 3000

is_allowed_host() .gov साइटों और Cornell LII को स्वीकार करता है। यह is_official_domain() को पुन: उपयोग करता है, इसलिए fakelaw.cornell.edu जैसा लुक-अलाइक नाम अस्वीकृत होगा। हम अधिकतम 2 पेज रखते हैं, प्रति पेज अधिकतम 3,000 अक्षरों के साथ।

LookupLaw टूल इम्प्लीमेंट करना

अब दूसरा कस्टम टूल बनाते हैं।

class LookupLaw(BaseTool):
    name = "lookup_law"
    description = (
        "Search for official US legal guidance using "
        "government websites and Cornell LII. "
        "Return the most relevant page excerpts."
    )
    parameters = {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "One plain-English legal question.",
            },
            "domain": {
                "type": "string",
                "description": "Optional domain, such as irs.gov.",
            },
        },
        "required": ["query"],
    }

    def __init__(self):
        super().__init__()
        self.sources = []

    def call(self, params, **kwargs):
        args = self._verify_json_format_args(params)
        found = olostep.searches.create(
            args["query"][:200],
            limit=5,
            include_domains=(
                [args["domain"]] if args.get("domain") else None
            ),
            scrape_options={
                "formats": ["markdown"],
                "timeout": 20,
            },
        )
        pages = []
        for link in found.links:
            host = host_of(link["url"])
            if not is_allowed_host(host):
                continue
            body = (
                link.get("markdown_content")
                or link.get("description")
                or ""
            )[:PAGE_CHARS]
            if body:
                self.sources.append(link["url"])
                pages.append(f"### {link['url']}\n{body}")
            if len(pages) == MAX_PAGES:
                break
        return "\n\n".join(pages) or (
            "No official page found. Results outside "
            ".gov and Cornell LII are treated as unreliable. "
            "Try a shorter query with the statute or agency name."
        )

यह टूल Olostep को एक सर्च रिक्वेस्ट भेजता है, नतीजों को फ़िल्टर करता है, पेज सामग्री निकालता है, और चयनित अंश Qwen4-Max को वापस करता है।

तीन इम्प्लीमेंटेशन विवरण ध्यान देने योग्य हैं:

  • हम अधिकतम 5 सर्च नतीजे प्राप्त करते हैं, लेकिन अधिकतम 2 योग्य पेज रखते हैं।
  • हम स्क्रैप किए गए Markdown को प्राथमिकता देते हैं और पेज विवरण पर फ़ॉलबैक करते हैं।
  • हम प्राप्त URL को self.sources में स्टोर करते हैं ताकि एप्लिकेशन विश्लेषण के बाद उन्हें दिखा सके।

4. Qwen-Agent और Qwen4-Max के साथ एजेंट बनाना

अब हमारे पास दोनों कस्टम टूल हैं: risk_gate संदिग्ध व्यवहार की पहचान करता है, और lookup_law प्रासंगिक कानूनी जानकारी प्राप्त करता है। अगला कदम उन्हें समन्वित करने वाला एजेंट बनाना है।

एक सिंगल सिस्टम प्रॉम्प्ट वर्कफ़्लो, टूल क्रम और प्रतिक्रिया फ़ॉर्मेट को परिभाषित करता है। इस तरह के बिल्ड के लिए Qwen-Agent अकेला विकल्प नहीं है, और हमारा Developing LLM Applications with LangChain कोर्स एक और फ़्रेमवर्क कवर करता है।

सिस्टम प्रॉम्प्ट परिभाषित करना

SYSTEM = """You explain a US legal or government notice
to the person who received it, in plain English.
You are not a lawyer.

How to work:
- Read the notice, text or images. Report only what
  the document actually says.
- Call risk_gate once with the notice text before
  using any other tool.
- Treat risk_gate flags as evidence, not proof.
  Flags can make a notice suspicious but cannot
  establish that it is legitimate.
- If the notice is plainly fraudulent, say so and
  skip research.
- Otherwise, call lookup_law with one plain question
  about the main legal issue.
- Call lookup_law a second time only if the first
  call returns no official page.
- Never invent a law, citation, phone number, amount,
  or deadline.
- Report deadlines using the document's own words.
  Separate a stated deadline from whether it is credible.
- If a returned page does not verify a claim,
  explicitly say it could not be verified.
- Never suggest ignoring a legal notice.
- Separate what the document establishes from
  what is assumed.
- Keep each section under 80 words.
- Use plain English, short sentences, and bullets.
- Avoid em dashes and contractions.

Begin with this verdict block:
**Scam:** yes, probably, or no
(confidence: low, medium, or high).
**Time sensitive:** yes or no, followed by the
exact deadline in the document, or "no deadline stated".
**Demand:** the amount and what the document asks
for, or "nothing is demanded".

Then write these sections in order:
### Summary
Explain what the document is and what happens
if nothing is done. Use 3 or 4 sentences.
### Evidence
Include one bullet per important finding.
Quote the document or the official page where
possible. Include risk_gate flags.
If the scan returned no flags, explicitly say so.
No flags is not proof that a notice is legitimate.
### Next steps
Give numbered actions in the order they should
be taken.
If the notice threatens eviction, foreclosure,
a lawsuit, arrest, or deportation, the first action
must be to contact a qualified attorney or legal aid.
Explain that waiting creates a risk.
Never confuse a document's claimed deadline with
a verified legal deadline.

Do not include a sources section or legal disclaimer.
The application appends both."""

यह प्रॉम्प्ट एजेंट की ज़िम्मेदारियाँ परिभाषित करता है और उसे कानूनी जानकारी गढ़ने से रोकता है। एक निर्देश पर विशेष ध्यान दें: डेडलाइन।

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

डिस्क्लेमर और स्रोत हैंडलिंग जोड़ना

हम डिस्क्लेमर को सिस्टम प्रॉम्प्ट से बाहर रखते हैं ताकि Python इसे लगातार जोड़ सके।

NO_SOURCE = (
    "No official page was retrieved for this notice, "
    "so treat any legal statement above as unverified."
)

DISCLAIMER = (
    "\n---\n"
    "**Not legal advice.** Verify deadlines and citations "
    "with the issuing authority, using contact details "
    "you find independently, not those printed in the notice."
)

यह हमें तब के लिए एक फ़ॉलबैक संदेश देता है जब लीगल रिसर्च कोई आधिकारिक स्रोत वापस न करे, और हर प्रतिक्रिया के साथ एक कानूनी डिस्क्लेमर जुड़ता है।

मुख्य विश्लेषण फ़ंक्शन बनाना

अंत में, सब कुछ एक पुन: प्रयोज्य फ़ंक्शन में जोड़ते हैं।

def analyze_notice(text=None, images=None):
    research = LookupLaw()
    agent = Assistant(
        llm=LLM,
        system_message=SYSTEM,
        function_list=[
            RiskGate(),
            research,
        ],
    )
    prompt = (
        f"Notice text:\n\n{text}"
        if text
        else "The notice is attached as image files."
    )
    answer = run_agent(agent, prompt, images)
    sources = "\n".join(
        f"- {url}" for url in research.sources
    )
    return (
        f"{answer}\n\n"
        f"## Sources\n\n"
        f"{sources or NO_SOURCE}\n"
        f"{DISCLAIMER}"
    )

यह फ़ंक्शन हर दस्तावेज़ के लिए नया एजेंट बनाता है, विश्लेषण चलाता है, प्राप्त स्रोत एकत्र करता है, और अंतिम प्रतिक्रिया लौटाता है। हम LookupLaw() को फ़ंक्शन के अंदर बनाते हैं ताकि हर नोटिस को अपनी स्रोत सूची मिल सके।

5. लीगल नोटिस एनालाइज़र का परीक्षण

अब हमारे पास एक काम करता हुआ लीगल नोटिस एनालाइज़र है। आइए इसे 3 सैंपल दस्तावेज़ों पर टेस्ट करें:

  1. एक काल्पनिक IRS स्कैम पत्र।
  2. Florida की एक एविक्शन नोटिस की फ़ोटो।
  3. एक PDF सीज़-एंड-डिसिस्ट पत्र।

हर टेस्ट वर्कफ़्लो के अलग हिस्से को परखेगा।

टेस्ट 1: एक IRS स्कैम पत्र

पहला उदाहरण एक काल्पनिक IRS स्कैम पत्र है। यह दावा करता है कि प्राप्तकर्ता पर 2024 टैक्स वर्ष के लिए $4,870 का संघीय आयकर बकाया है और 24 घंटों के भीतर भुगतान करना होगा।

यह गिरफ़्तारी की धमकी भी देता है, गिफ्ट कार्ड या वायर ट्रांसफ़र से भुगतान मांगता है, और एक संदिग्ध वेबसाइट शामिल करता है। यह रहा सैंपल इनपुट:

from IPython.display import Markdown

FICTIONAL_NOTICE = """
INTERNAL REVENUE SERVICE
NOTICE OF FINAL DEMAND
Date of Notice: November 10, 2026

Our records show an outstanding balance of
$4,870.00 in federal income tax for tax year 2024.

You must resolve this balance within 24 hours.
Failure to comply will result in a warrant for your
arrest and your wages being garnished.

Do not discuss this notice with anyone.

Pay using Apple or Google Play gift cards and
provide the card numbers over the phone, or by
wire transfer through:
https://irs-gov-payments.top/pay?ref=MW4471
""".strip()

Markdown(analyze_notice(text=FICTIONAL_NOTICE))

यह एक काल्पनिक नोटिस बनाता है और उसे विश्लेषण के लिए एजेंट को सबमिट करता है।

आउटपुट:

काल्पनिक IRS स्कैम पत्र के लिए लीगल नोटिस एनालाइज़र का आउटपुट

चित्र 3: काल्पनिक IRS स्कैम पत्र के लिए एनालाइज़र का आउटपुट।

स्कैनर कई संदिग्ध संकेतक पाता है, और एजेंट बाहरी कानूनी रिसर्च छोड़ देता है। एक स्पष्ट स्कैम के लिए हमें यही चाहिए: जब निर्धारक जाँचें पहले से धोखाधड़ी की ओर इशारा कर रही हों, तो एप्लिकेशन रिसर्च पर अतिरिक्त टोकन खर्च नहीं करता।

यह टेस्ट क्या दिखाता है: जोखिम गेट आम स्कैम तरकीबों की पहचान कर सकता है और एजेंट को अनावश्यक बाहरी रिसर्च से बचाने में मदद करता है।

टेस्ट 2: एविक्शन नोटिस की एक फ़ोटो

दूसरा टेस्ट Qwen4-Max की नैटिव विज़न पर केंद्रित है। टेक्स्ट खुद निकालने के बजाय, हम एविक्शन नोटिस की फ़ोटो सीधे मॉडल को भेजते हैं।

हमारा सैंपल Florida का तीन-दिवसीय नोटिस है, जो $1,850 बकाया किराया मांगता है, या 23 नवंबर, 2026 तक संपत्ति का कब्ज़ा। यह रहा कोड:

Markdown(
    analyze_notice(
        images=["samples/eviction.png"]
    )
)

यह फ़ोटो सीधे Qwen4-Max को भेजता है, इसलिए अलग OCR पाइपलाइन की ज़रूरत नहीं। Qwen की विज़न को टूल कॉलिंग के साथ जोड़ने वाला एक और बिल्ड देखने के लिए, हमारा Qwen 3.6 Plus API ट्यूटोरियल इनवॉइस प्रोसेसिंग पर देखें।

आउटपुट:

फ़ोटो खींचे गए Florida एविक्शन नोटिस के लिए लीगल नोटिस एनालाइज़र का आउटपुट

चित्र 4: फ़ोटो खींचे गए एविक्शन नोटिस के लिए एनालाइज़र का आउटपुट।

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

यह टेस्ट क्या दिखाता है: Qwen4-Max सीधे फ़ोटोग्राफ़ किए गए कानूनी दस्तावेज़ों की व्याख्या कर सकता है, जबकि Qwen-Agent अतिरिक्त रिसर्च का समन्वय करता है और अनिश्चितताओं को संप्रेषित करता है।

टेस्ट 3: एक PDF सीज़-एंड-डिसिस्ट पत्र

अंतिम टेस्ट के लिए, हम PDF फ़ॉर्मेट में दो-पेज का सीज़-एंड-डिसिस्ट पत्र उपयोग करते हैं।

दस्तावेज़ 17 U.S.C. §§ 501 और 512 का हवाला देता है, कॉपीराइट उल्लंघन का आरोप लगाता है, और प्राप्तकर्ता से विवादित सामग्री हटाने और 28 नवंबर, 2026 तक अनुपालन की पुष्टि करने को कहता है। PDF में selectable टेक्स्ट है, इसलिए हम अपना read_pdf() हेल्पर उपयोग कर सकते हैं। यह रहा कोड:

pdf_text = read_pdf("samples/legal.pdf")

Markdown(
    analyze_notice(text=pdf_text)
)

यह PDF की सामग्री निकालता है और परिणामी टेक्स्ट को उसी एजेंट को भेजता है।

आउटपुट:

PDF सीज़-एंड-डिसिस्ट पत्र के लिए लीगल नोटिस एनालाइज़र का आउटपुट

चित्र 5: सीज़-एंड-डिसिस्ट पत्र के लिए एनालाइज़र का आउटपुट।

एजेंट आधिकारिक सरकारी या कोर्ट नोटिस और एक निजी कानूनी डिमांड के बीच सही अंतर करता है। यह पहचानता है कि कोई धनराशि नहीं मांगी गई और अपनी सिफ़ारिशें उसी अनुसार समायोजित करता है। रिसर्च टूल ने US Copyright Office का एक प्रासंगिक पेज प्राप्त किया, जो अंतिम स्रोतों में दिखता है।

यह टेस्ट क्या दिखाता है: वही एजेंट PDF पत्राचार संभाल सकता है, कानूनी डिमांड की प्रकृति पहचान सकता है, और उपयुक्त अगले कदम सुझा सकता है।

Qwen4-Max के साथ मेरा अनुभव: अच्छाइयाँ, कमियाँ और दिक्कतें

इस प्रोजेक्ट, अन्य एजेंटिक एप्लिकेशंस, और वाइब कोडिंग के लिए Qwen4-Max का उपयोग करने के बाद, यह है मेरा ईमानदार आकलन।

अच्छाइयाँ

Qwen इकोसिस्टम बहुत कुछ कवर करता है। इसमें speech-to-text, text-to-speech, वेब सर्च, वेब स्क्रैपिंग, और बिना सब कुछ शून्य से लागू किए एजेंटिक एप्लिकेशंस बनाने के लिए एक ओपन-सोर्स टूलकिट शामिल है।

मुझे सबसे ज़्यादा अच्छा लगा कि Qwen4-Max ने विस्तृत निर्देशों का कितना अच्छा पालन किया। इसने आम तौर पर अनुरोधित आउटपुट संरचना का सम्मान किया, दस्तावेज़ों से तारीखें निकालीं, और मेरी टेस्टिंग के दौरान सटीक सारांश बनाए।

इसकी इमेज समझने की क्षमता खास थी। मैंने इसे एक लीगल नोटिस की फ़ोटो दी और इसने बिना अतिरिक्त OCR पाइपलाइन के सामग्री पढ़ ली—जो दस्तावेज़-प्रधान एजेंटिक एप्लिकेशंस के लिए बड़ी मदद है।

कमियाँ

गति सबसे बड़ी समस्या रही। Qwen4-Max वाइब कोडिंग के लिए मेरा पसंदीदा मॉडल नहीं रहा: DeepSeek V4.1 Flash और अन्य मॉडलों की तुलना में, यह अक्सर साधारण टास्क पूरे करने में काफ़ी देर लगाता था।

मैंने अक्सर लगभग 100 टोकन प्रति सेकंड की जनरेशन स्पीड देखी, पर यह संख्या असली लागत छिपाती है। मॉडल ने सीधे-साधे बदलावों पर भी लंबा समय तर्क में बिताया, और कभी-कभी मैं एक साधारण एडिट मांगता/मांगती और अपेक्षा से काफ़ी देर तक इंतज़ार करना पड़ता।

अगर आप तेज़ विकल्प खुद आज़माना चाहते हैं, तो हम इसे अपने DeepSeek V4.1 Flash API ट्यूटोरियल में कवर करते हैं।

दिक्कतें

नैटिव वेब सर्च सबसे निराशाजनक हिस्सा रहा। मेरी टेस्टिंग में, प्रतिक्रिया समय असंगत रहे: वही क्वेरी कभी सेकंडों में लौटती, तो कभी एक मिनट के क़रीब लगते, और कुछ रिक्वेस्ट 400 सेकंड पार करने के बाद भी पूरी नहीं हुईं।

मेरे रिसर्च वर्कफ़्लो के तीन रन लगभग 16 मिनट ले गए। किसी ऐसे एप्लिकेशन के लिए जो बाहरी कानूनी जानकारी पर निर्भर करता है, यह पर्याप्त भरोसेमंद नहीं था।

नैटिव सर्च को Olostep से बदलना मजबूरी बन गया, जिसका मतलब यह भी था कि मैं पूरी तरह Qwen इकोसिस्टम पर निर्भर नहीं रह सका/सकी, जैसा शुरू में सोचा था।

DeepSeek Harness के साथ प्रयोग करते समय मुझे एक और समस्या आई। मैंने स्टॉक मार्केट पर रिसर्च के बारे में एक सरल प्रश्न पूछा, और वर्कफ़्लो ने रिक्वेस्ट पर बहुत समय बिताया और फिर एक त्रुटि लौटा दी। इतना सीधे-सादे टास्क के लिए यह निराशाजनक था।

कुल मिलाकर, Qwen4-Max की क्षमताएँ प्रभावशाली हैं, लेकिन इसका reasoning ओवरहेड और असंगत नैटिव सर्च ऐसे कारक हैं जिन्हें प्रोडक्शन वर्कफ़्लोज़ बनाने से पहले तौलना चाहिए। अगर आप Qwen मॉडलों के साथ बनाना जारी रखना चाहते हैं, तो हमारा Qwen 3.7 Max API ट्यूटोरियल एक self-reviewing प्रोडक्टिविटी एजेंट समझाता है।

Abid Ali Awan

लेखक

Abid Ali Awan

एक प्रमाणित डेटा साइंटिस्ट के रूप में, मैं अत्याधुनिक तकनीक का उपयोग करके नवाचारी मशीन लर्निंग अनुप्रयोग बनाने के लिए उत्साहित रहता/रहती हूँ। स्पीच रिकॉग्निशन, डेटा विश्लेषण और रिपोर्टिंग, MLOps, संवादात्मक AI और NLP में मजबूत पृष्ठभूमि के साथ, मैंने ऐसे बुद्धिमान सिस्टम विकसित करने में अपनी विशेषज्ञता निखारी है जो वास्तविक प्रभाव डाल सकें। तकनीकी दक्षता के अलावा, मैं जटिल अवधारणाओं को स्पष्ट और संक्षिप्त भाषा में प्रस्तुत करने में भी निपुण हूँ। परिणामस्वरूप, मैं डेटा साइंस पर एक मांग में रहने वाला/वाली ब्लॉगर बन गया/गई हूँ, और डेटा प्रोफेशनलों के बढ़ते समुदाय के साथ अपने अनुभव और विचार साझा करता/करती हूँ। वर्तमान में, मैं कंटेंट निर्माण और संपादन पर केंद्रित हूँ, बड़े भाषा मॉडलों के साथ काम करते हुए ऐसा प्रभावशाली और आकर्षक कंटेंट विकसित कर रहा/रही हूँ जो व्यवसायों और व्यक्तियों दोनों को अपने डेटा का अधिकतम लाभ उठाने में मदद कर सके।

विषय