Sari la conținutul principal

Tutorial Qwen4-Max: Construiește un analizor de notificări legale

Construiește un analizor de notificări legale din SUA cu Qwen4-Max, Qwen-Agent și Olostep. Marchează escrocheriile, citește fotografii și PDF-uri și verifică afirmațiile în surse oficiale.
· 12 min. citește

Descoperă cu AI

Ți s-a întâmplat să primești o notificare de la o instituție publică și să te întrebi dacă este legitimă, dacă trebuie să răspunzi sau dacă cineva încearcă să te păcălească?

Notificările legale sunt greu de citit, mai ales când limbajul complicat se împletește cu cereri de plată și termene limită. Escrocii profită de această confuzie, se dau drept agenții guvernamentale și creează un sentiment fals de urgență.

În acest tutorial, vom construi un analizor pentru notificări legale din SUA folosind Qwen4-Max și cadrul Qwen-Agent. Aplicația acceptă text, imagini și PDF-uri, marchează tacticile suspecte de plată și caută resurse legale oficiale atunci când are nevoie de verificări.

În loc să ne bazăm exclusiv pe un model lingvistic de mari dimensiuni (LLM), îl combinăm cu două unelte Python. Prima folosește expresii regulate pentru a depista indicatori comuni de fraudă. A doua folosește Olostep pentru a căuta pe site-uri oficiale guvernamentale și pe Cornell Legal Information Institute (LII).

Pe scurt

  • Construim un analizor de notificări legale cu Qwen4-Max, Qwen-Agent și Olostep, care acceptă text, fotografii și PDF-uri.
  • Un filtru de risc bazat pe regex marchează tiparele de înșelătorie și domeniile lookalike înainte ca modelul să facă vreo cercetare.
  • O unealtă de cercetare limitează căutările la site-uri .gov și Cornell LII, iar agentul sare peste cercetare când o notificare e clar frauduloasă.
  • În testele mele, Qwen4-Max a citit bine notificările fotografiate, dar a fost lent pe sarcini simple, iar căutarea sa web nativă a fost nesigură.

Ce este Qwen4-Max?

Qwen4-Max este modelul de vârf al Alibaba din familia Qwen4, lansat pe 16 noiembrie 2026. Este un model sparse mixture-of-experts (MoE), cu îmbunătățiri arhitecturale, viziune nativă și o fereastră de context mai mare, conceput pentru raționament complex și aplicații agentice.

Iată caracteristicile cele mai relevante pentru proiectul nostru:

  • Arhitectură MoE rară: Qwen4-Max are 2,4T parametri backbone, 71B activi per token și încă 328B parametri de embedding N-gram. Straturile Gated DeltaNet și Qwen Sparse Attention reduc costurile pentru contexte lungi.
  • Viziune nativă: Modelul citește imagini direct, astfel că putem trimite o fotografie a notificării legale fără să construim un pipeline separat de recunoaștere optică a caracterelor (OCR).
  • Fereastră de context de 1M tokeni: Suficient de mare pentru documente lungi și multă informație de sprijin.
  • Eficiență mai bună a tokenilor: Conform Alibaba, Qwen4-Max folosește cu aproximativ 35% mai puțini tokeni decât Qwen3.8-Max pe Work360 la efort de raționament High și cu aproximativ 49% mai puțini pe Terminal-Bench 4.0. La efort Xhigh, reducerile sunt de aproximativ 24% și 48%.
  • Costuri mai mici per sarcină: Pe Work360, Qwen4-Max a obținut 52,69, față de 47,74 pentru Qwen3.8-Max, în timp ce costul mediu per sarcină a scăzut de la 4,43 $ la 1,67 $, o reducere de 62%.

Aici sunt rezultatele de benchmark din anunțul Alibaba, care arată că Qwen4-Max îmbunătățește Qwen3.8-Max la aproape toate capabilitățile evaluate de Alibaba:

Comparația benchmark Alibaba a Qwen4-Max și altor modele pe sarcini de codare, lucru și orizont lung

Figura 1: Rezultatele benchmark Qwen4-Max. Imagine preluată din: Qwen, Qwen4-Max: Noul tău coechipier a sosit.

Cum funcționează analizorul de notificări legale?

Analizorul este un singur asistent Qwen-Agent care coordonează două unelte Python, în timp ce Qwen4-Max se ocupă de înțelegerea documentelor și raționament. Înainte de a scrie cod, să vedem fluxul de lucru.

Diagrama fluxului de lucru al analizorului de notificări legale, de la introducerea notificării, prin filtrul de risc și cercetarea legală, până la răspunsul final

Figura 2: Fluxul de lucru al analizorului de notificări legale.

Fluxul are 6 pași:

  1. Utilizatorul trimite o notificare ca text, imagine sau PDF.
  2. Qwen4-Max citește documentul și îi identifică principalele conținuturi.
  3. Agentul apelează risk_gate pentru a verifica instrucțiunile suspecte de plată, amenințările și linkurile.
  4. Dacă documentul este în mod evident fraudulos, agentul sare peste cercetarea externă.
  5. În caz contrar, agentul apelează lookup_law pentru a căuta resurse legale oficiale.
  6. Qwen4-Max produce un răspuns structurat cu un verdict, un rezumat, dovezi și pași recomandați.

Alegerea-cheie de proiectare este că LLM-ul nu face totul. Python se ocupă de verificările deterministe, Olostep se ocupă de cercetarea externă, iar Qwen4-Max de înțelegerea documentelor și raționament.

Asta păstrează fluxul simplu, oferind în același timp agentului un instrument potrivit pentru fiecare sarcină. Dacă terminologia specifică agenților îți este nouă, cursul nostru Introducere în agenți AI acoperă elementele de bază fără a necesita cod.

1. Configurarea mediului

Vom folosi Jupyter Notebook, QwenCloud pentru acces la model și Olostep pentru căutare web și scraping.

Mai întâi, creează un cont pe QwenCloud, adaugă credite sau abonează-te la un Plan Token și generează o cheie API din dashboard. QwenCloud oferă un endpoint API în funcție de regiunea pe care o selectezi.

Vei avea nevoie și de o cheie API Olostep pentru cercetare juridică.

Setează variabilele de mediu în terminal înainte să pornești Jupyter Notebook. Le poți seta și din notebook cu 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"

Eu folosesc endpoint-ul pentru Planul Token, care îmi oferă acces la modele la preț redus. Dacă plătești în funcție de consum, folosește endpoint-ul pe care ți-l arată QwenCloud pentru regiunea ta.

Apoi, instalează dependențele necesare în notebook:

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

Extra-ul rag adaugă pachete de procesare a documentelor precum pdfplumber, pe care îl vom folosi pentru a citi PDF-uri. Începând cu versiunea 0.0.34, Qwen-Agent importă la pornire soundfile și tqdm fără a le declara drept dependențe, așa că le instalăm explicit.

Configurarea Qwen4-Max

În continuare, inițializăm modelul și clientul Olostep. Eu folosesc regiunea Singapore, care oferă de asemenea un Plan Token.

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

Aceasta configurează Qwen4-Max pentru input multimodal, setează un nivel de efort pentru raționament și inițializează clientul de cercetare. Observă că OLOSTEP_API_TIMEOUT este setat înainte de import, deoarece SDK-ul îl citește la încărcare.

Câteva opțiuni de configurare merită înțelese:

  • model specifică modelul pe care vrem să îl folosim.
  • model_type ne permite să trimitem imagini prin interfața multimodală compatibilă cu OpenAI.
  • model_server indică endpoint-ul din QWEN_BASE_URL.
  • max_tokens limitează lungimea răspunsului generat.
  • reasoning_effort controlează cât raționament face modelul. Folosim low pentru răspunsuri rapide.
  • OLOSTEP_API_TIMEOUT setează o limită de timp, în secunde, pentru cererile de cercetare.

Crearea helperilor reutilizabili pentru agent

Vom procesa atât input text, cât și imagini, așa că să creăm o funcție reutilizabilă pentru a rula agentul.

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

Această funcție trimite promptul și imaginile opționale către Qwen-Agent, așteaptă răspunsul final și extrage textul generat.

Avem nevoie și de un helper pentru citirea PDF-urilor.

def read_pdf(path):
    import pdfplumber

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

Această funcție extrage textul selectabil de pe fiecare pagină PDF și îl combină într-un singur șir.

Notă: pdfplumber nu face OCR. Pentru PDF-uri scanate care conțin doar imagini, redă fiecare pagină ca imagine și trimite-o direct la Qwen4-Max.

2. Construirea detecției de fraudă cu un filtru de risc

Prima unealtă personalizată identifică comportamente suspecte. În loc să cerem LLM-ului să recunoască fiecare instrucțiune suspectă de plată, putem folosi expresii regulate pentru a detecta tacticile cunoscute de înșelătorie.

Este mai rapid, determinist și nu folosește tokeni ai modelului. Dacă ai nevoie de un refresh al sintaxei, cursul nostru Regular Expressions in Python îl acoperă.

Definirea regulilor de detecție a fraudei

Să începem cu o listă de expresii regulate și o mapare între agenții guvernamentale și domeniile lor oficiale.

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)\"'<>]+")

Acest cod definește indicatorii de înșelătorie și maparea numelor de agenții la domeniile pe care le folosesc de fapt. De exemplu, dacă o notificare menționează IRS, aplicația își verifică linkurile față de irs.gov.

Extragerea și validarea domeniilor

În continuare, avem nevoie de un helper care extrage numele de gazdă dintr-un 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)

Acesta extrage hostname-ul și verifică dacă este domeniul oficial sau un subdomeniu legitim. Distincția contează: o verificare simplă cu endswith() ar accepta fakeirs.gov drept site IRS.

Implementarea uneltei de filtru de risc

Acum putem combina aceste reguli într-o unealtă personalizată pentru 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"

Această unealtă scanează notificarea pentru tipare care se potrivesc, verifică URL-urile față de domeniul oficial al agenției și returnează indicatorii suspecti. Numele agențiilor sunt potrivite ca cuvinte întregi, astfel încât „irs” nu declanșează potriviri în cuvinte precum „first”.

De exemplu, notificarea noastră IRS fictivă din Testul 1 produce:

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

Agentul primește aceste rezultate ca parte a contextului și le folosește când decide dacă notificarea este suspectă.

3. Crearea uneltei de cercetare juridică

A doua noastră unealtă se ocupă de cercetarea externă. Nu vrem ca agentul să caute pe site-uri la întâmplare, forumuri sau bloguri ale firmelor de avocatură și să trateze tot ce găsește drept autoritar.

În schimb, restricționăm cercetarea la site-uri oficiale ale guvernului SUA și la Cornell LII. Vom folosi Olostep pentru că poate căuta și extrage conținut din mai multe rezultate într-o singură cerere. Dacă vrei să îl compari cu o altă opțiune, vezi tutorialul nostru Firecrawl.

Definirea restricțiilor de cercetare

Mai întâi, să definim sursele permise și câteva limite privind cât preluăm.

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


MAX_PAGES = 2
PAGE_CHARS = 3000

Funcția is_allowed_host() acceptă site-urile .gov și Cornell LII. Refolosește is_official_domain(), astfel încât un lookalike precum fakelaw.cornell.edu este respins. De asemenea, păstrăm cel mult 2 pagini, cu maximum 3.000 de caractere per pagină.

Implementarea uneltei LookupLaw

Acum să creăm a doua unealtă personalizată.

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."
        )

Această unealtă trimite o cerere de căutare la Olostep, filtrează rezultatele, extrage conținutul paginilor și returnează fragmentele selectate către Qwen4-Max.

Trei detalii de implementare merită remarcate:

  • Recuperăm până la 5 rezultate de căutare, dar păstrăm cel mult 2 pagini eligibile.
  • Preferăm Markdown-ul extras și, dacă nu există, descrierea paginii.
  • Stocăm URL-urile recuperate în self.sources astfel încât aplicația să le poată afișa după analiză.

4. Construirea agentului cu Qwen-Agent și Qwen4-Max

Acum avem ambele unelte personalizate: risk_gate identifică comportamentul suspect, iar lookup_law aduce informații legale relevante. În continuare, creăm agentul care le coordonează.

Un singur prompt de sistem definește fluxul de lucru, ordinea uneltelor și formatul răspunsului. Qwen-Agent nu este singura opțiune pentru un astfel de build, iar cursul nostru Developing LLM Applications with LangChain acoperă un alt framework.

Definirea promptului de sistem

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."""

Acest prompt definește responsabilitățile agentului și îl împiedică să inventeze informații legale. O instrucțiune merită privită mai atent: termenele limită.

O notificare frauduloasă poate conține totuși un termen limită, așa că agentul trebuie să raporteze ce pretinde documentul, explicând în același timp dacă acel termen e credibil.

Adăugarea avertismentului și gestionarea surselor

Păstrăm avertismentul în afara promptului de sistem, astfel încât Python să îl poată adăuga constant.

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."
)

Aceasta ne oferă un mesaj de rezervă când cercetarea juridică nu returnează nicio sursă oficială, iar fiecare răspuns poartă un avertisment legal.

Crearea funcției principale de analiză

În final, conectăm totul într-o funcție reutilizabilă.

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

Această funcție creează un agent proaspăt pentru fiecare document, rulează analiza, colectează sursele recuperate și returnează răspunsul final. Creăm LookupLaw() în interiorul funcției, astfel încât fiecare notificare să aibă propria listă de surse.

5. Testarea analizorului de notificări legale

Acum avem un analizor funcțional pentru notificări legale. Să îl testăm pe 3 documente de probă:

  1. O scrisoare IRS fictivă de tip scam.
  2. O fotografie a unei notificări de evacuare din Florida.
  3. Un PDF cu o scrisoare de tip cease and desist.

Fiecare test exercită o parte diferită a fluxului.

Testul 1: O scrisoare IRS de tip scam

Primul exemplu este o scrisoare IRS fictivă de tip scam. Susține că destinatarul datorează 4.870 $ impozit federal pe venit și trebuie să plătească în 24 de ore.

De asemenea, amenință cu arestarea, cere plata cu carduri cadou sau transfer bancar și include un site suspect. Iată inputul de exemplu:

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

Aceasta creează o notificare fictivă și o trimite agentului pentru analiză.

Output:

Output-ul analizorului de notificări legale pentru scrisoarea IRS fictivă de tip scam

Figura 3: Output-ul analizorului pentru scrisoarea IRS fictivă de tip scam.

Scannerul găsește mai mulți indicatori suspecti, iar agentul sare peste cercetarea juridică externă. Asta ne dorim pentru un scam evident: aplicația nu cheltuie tokeni suplimentari pe cercetare când verificările deterministe indică deja frauda.

Ce demonstrează acest test: Filtrul de risc poate identifica tactici comune de înșelătorie și îl poate ajuta pe agent să evite cercetarea externă inutilă.

Testul 2: O fotografie a unei notificări de evacuare

Al doilea test se concentrează pe viziunea nativă a Qwen4-Max. În loc să extragem noi textul, trimitem direct o fotografie a unei notificări de evacuare către model.

Exemplul nostru este o notificare de trei zile din Florida, care cere 1.850 $ chirie restantă sau eliberarea proprietății până la 23 noiembrie 2026. Iată codul:

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

Aceasta trimite fotografia direct la Qwen4-Max, deci nu este nevoie de un pipeline OCR separat. Pentru un alt build care combină viziunea Qwen cu apelarea uneltelor, vezi tutorialul API Qwen 3.6 Plus despre procesarea facturilor.

Output:

Output-ul analizorului de notificări legale pentru fotografia notificării de evacuare din Florida

Figura 4: Output-ul analizorului pentru notificarea de evacuare fotografiată.

Modelul a înțeles fotografia, a extras suma și termenul, și a identificat tipul notificării. A recunoscut că pagina legală recuperată nu conținea informații suficiente pentru a verifica articolul de lege și a observat câmpurile de semnătură și predare necompletate din documentul de probă.

Ce demonstrează acest test: Qwen4-Max poate interpreta direct documente legale fotografiate, în timp ce Qwen-Agent coordonează cercetarea suplimentară și comunică incertitudinea.

Testul 3: Un PDF cu o scrisoare de tip cease and desist

Pentru ultimul test, folosim o scrisoare de tip cease and desist în format PDF, pe două pagini.

Documentul citează 17 U.S.C. §§ 501 și 512, acuză încălcarea drepturilor de autor și cere destinatarului să elimine conținutul disputat și să confirme conformarea până la 28 noiembrie 2026. PDF-ul conține text selectabil, așa că putem folosi helperul nostru read_pdf(). Iată codul:

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

Markdown(
    analyze_notice(text=pdf_text)
)

Aceasta extrage conținutul PDF-ului și trimite textul rezultat aceluiași agent.

Output:

Output-ul analizorului de notificări legale pentru scrisoarea PDF de tip cease and desist

Figura 5: Output-ul analizorului pentru scrisoarea de tip cease and desist.

Agentul distinge corect o cerere juridică privată de o notificare oficială a guvernului sau a unei instanțe. Observă că nu se solicită bani și își ajustează recomandările. Unealta de cercetare a recuperat o pagină relevantă de la Oficiul pentru Drepturi de Autor al SUA, care apare în sursele finale.

Ce demonstrează acest test: Același agent poate gestiona corespondență PDF, identifica natura unei cereri legale și recomanda pașii adecvați.

Experiența mea cu Qwen4-Max: pro, contra și puncte slabe

După ce am folosit Qwen4-Max pentru acest proiect, alte aplicații agentice și vibe coding, iată evaluarea mea sinceră.

Partea bună

Ecosistemul Qwen acoperă mult teren. Include speech-to-text, text-to-speech, căutare web, scraping web și un toolkit open-source pentru a construi aplicații agentice fără a implementa totul de la zero.

Ce mi-a plăcut cel mai mult a fost cât de bine a urmat Qwen4-Max instrucțiuni detaliate. De obicei a respectat structura de output cerută, a extras date din documente și a produs rezumate corecte în testele mele.

S-a remarcat prin înțelegerea imaginilor. I-am dat o fotografie a unei notificări legale și a citit conținutul fără un pipeline OCR suplimentar, ceea ce ajută mult în aplicațiile agentice centrate pe documente.

Partea mai puțin bună

Viteza a fost cea mai mare problemă pentru mine. Qwen4-Max nu a fost modelul meu preferat pentru vibe coding: comparat cu DeepSeek V4.1 Flash și alte modele testate, deseori a durat vizibil mai mult să termine sarcini simple.

Am văzut regulat viteze de generare în jur de 100 tokeni pe secundă, dar acel număr ascunde costul real. Modelul a petrecut mult timp raționând asupra unor modificări simple și uneori ceream o editare de bază și așteptam mult mai mult decât mă așteptam.

Dacă vrei să încerci varianta mai rapidă, o acoperim în tutorialul API DeepSeek V4.1 Flash.

Partea neplăcută

Căutarea web nativă a fost partea cea mai frustrantă. În testele mele, timpii de răspuns au fost inconsistenți: aceeași interogare putea reveni în câteva secunde sau dura aproape un minut, iar unele cereri depășeau 400 de secunde fără să se încheie.

Trei rulări ale fluxului meu de cercetare au durat aproape 16 minute. Asta nu a fost suficient de fiabil pentru o aplicație care depinde de informații legale externe.

Înlocuirea căutării native cu Olostep a devenit o necesitate, ceea ce a însemnat și că nu m-am putut baza integral pe ecosistemul Qwen, așa cum plănuisem inițial.

Am dat peste o altă problemă când am experimentat cu DeepSeek Harness. Am pus o întrebare simplă despre cercetarea pieței bursiere, iar fluxul a petrecut mult timp pe cerere înainte să întoarcă o eroare. A fost frustrant pentru o sarcină atât de simplă.

Per total, Qwen4-Max are capabilități impresionante, dar costul de raționament și căutarea nativă inconsistentă merită cântărite înainte să construiești fluxuri de producție în jurul lui. Dacă vrei să continui cu modelele Qwen, tutorialul nostru Qwen 3.7 Max API parcurge un agent de productivitate care își face auto-revizie.

Subiecte