Vai al contenuto principale

Tutorial Qwen4-Max: crea un analizzatore di avvisi legali

Crea un analizzatore di avvisi legali USA con Qwen4-Max, Qwen-Agent e Olostep. Segnala truffe, leggi foto e PDF e verifica le affermazioni su fonti ufficiali.
· 12 min leggi

Scopri con l'IA

Ti è mai capitato di ricevere una comunicazione governativa e chiederti se fosse legittima, se dovessi rispondere o se qualcuno stesse cercando di truffarti?

Gli avvisi legali sono difficili da leggere, soprattutto quando un linguaggio complicato si mescola a richieste di pagamento e scadenze. I truffatori sfruttano questa confusione impersonando enti governativi e creando un falso senso di urgenza.

In questo tutorial costruiremo un analizzatore di avvisi legali USA usando Qwen4-Max e il framework Qwen-Agent. L’app accetta testo, immagini e PDF, evidenzia tattiche di pagamento sospette e cerca risorse legali ufficiali quando deve verificare qualcosa.

Invece di affidarci interamente a un large language model (LLM), lo abbineremo a due strumenti Python. Il primo usa espressioni regolari per intercettare indicatori comuni di truffa. Il secondo usa Olostep per cercare su siti governativi ufficiali e sul Cornell Legal Information Institute (LII).

In breve

  • Costruiamo un analizzatore di avvisi legali con Qwen4-Max, Qwen-Agent e Olostep che accetta testo, foto e PDF.
  • Un filtro di rischio basato su regex segnala schemi fraudolenti e domini sosia prima che il modello faccia qualsiasi ricerca.
  • Uno strumento di ricerca limita le consultazioni ai siti .gov e al Cornell LII, e l’agente salta la ricerca quando un avviso è chiaramente fraudolento.
  • Nei miei test, Qwen4-Max ha letto bene gli avvisi fotografati, ma è stato lento in compiti semplici e la sua ricerca web nativa è stata inaffidabile.

Che cos’è Qwen4-Max?

Qwen4-Max è il modello di punta di Alibaba nella famiglia Qwen4, lanciato il 16 novembre 2026. È un modello MoE (mixture-of-experts) sparso con miglioramenti architetturali, visione nativa e una finestra di contesto più ampia, progettato per ragionamento complesso e applicazioni agentiche.

Ecco le funzionalità più rilevanti per il nostro progetto:

  • Architettura MoE sparsa: Qwen4-Max ha 2,4T parametri backbone, 71B attivi per token e ulteriori 328B di parametri di embedding N-gram. I layer Gated DeltaNet e la Qwen Sparse Attention contengono i costi sul lungo contesto.
  • Visione nativa: Il modello legge le immagini direttamente, quindi possiamo inviare la foto di un avviso legale senza creare una pipeline OCR separata.
  • Finestra di contesto da 1M token: È abbastanza ampia per documenti lunghi e molte informazioni di supporto.
  • Migliore efficienza dei token: Secondo Alibaba, Qwen4-Max usa circa il 35% di token in meno rispetto a Qwen3.8-Max su Work360 con sforzo di ragionamento High, e circa il 49% in meno su Terminal-Bench 4.0. Con sforzo Xhigh, le riduzioni sono circa 24% e 48%.
  • Costi per task inferiori: Su Work360, Qwen4-Max ha ottenuto 52,69, in aumento rispetto a 47,74 per Qwen3.8-Max, mentre il costo medio per task è sceso da $4,43 a $1,67, una riduzione del 62%.

Ecco i risultati dei benchmark dall’annuncio di Alibaba, che mostrano Qwen4-Max migliorare Qwen3.8-Max in quasi tutte le capacità valutate da Alibaba:

Confronto benchmark di Alibaba tra Qwen4-Max e altri modelli in attività di coding, lavoro e compiti a lungo raggio

Figura 1: Risultati benchmark di Qwen4-Max. Immagine tratta da: Qwen, Qwen4-Max: Your New Teammate Has Arrived.

Come funziona l’analizzatore di avvisi legali?

L’analizzatore è un singolo assistente Qwen-Agent che coordina due strumenti Python, mentre Qwen4-Max gestisce comprensione dei documenti e ragionamento. Prima di scrivere codice, vediamo il flusso di lavoro.

Diagramma del flusso di lavoro dell’analizzatore di avvisi legali, dall’input dell’avviso attraverso il filtro di rischio e la ricerca legale fino alla risposta finale

Figura 2: Il flusso di lavoro dell’analizzatore di avvisi legali.

Il flusso ha 6 passaggi:

  1. L’utente invia un avviso come testo, immagine o PDF.
  2. Qwen4-Max legge il documento e ne identifica i contenuti principali.
  3. L’agente chiama risk_gate per controllare istruzioni di pagamento sospette, minacce e link.
  4. Se il documento è palesemente fraudolento, l’agente salta la ricerca esterna.
  5. Altrimenti, l’agente chiama lookup_law per cercare risorse legali ufficiali.
  6. Qwen4-Max produce una risposta strutturata con verdetto, sintesi, evidenze e prossimi passi raccomandati.

La scelta progettuale chiave è che l’LLM non fa tutto. Python gestisce i controlli deterministici, Olostep gestisce la ricerca esterna e Qwen4-Max gestisce comprensione dei documenti e ragionamento.

Questo mantiene il flusso semplice dando all’agente lo strumento giusto per ogni compito. Se la terminologia sugli agenti è nuova per te, il nostro corso Introduzione agli agenti di AI copre le basi senza bisogno di codice.

1. Configurazione dell’ambiente

Useremo Jupyter Notebook, QwenCloud per l’accesso al modello e Olostep per la ricerca e lo scraping web.

Per prima cosa, crea un account su QwenCloud, aggiungi crediti o abbonati a un Token Plan e genera una chiave API dalla dashboard. QwenCloud fornisce un endpoint API in base alla regione selezionata.

Ti servirà anche una chiave API Olostep per la ricerca legale.

Imposta le variabili d’ambiente nel terminale prima di avviare Jupyter Notebook. Puoi anche impostarle all’interno del notebook con 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"

Io uso l’endpoint Token Plan, che offre accesso scontato ai modelli. Se paghi a consumo, usa l’endpoint che QwenCloud mostra per la tua regione.

Successivamente, installa le dipendenze richieste nel tuo notebook:

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

L’extra rag aggiunge pacchetti per l’elaborazione dei documenti come pdfplumber, che useremo per leggere i PDF. Alla versione 0.0.34, Qwen-Agent importa anche soundfile e tqdm all’avvio senza dichiararli come dipendenze, quindi li installiamo esplicitamente.

Configurare Qwen4-Max

Ora inizializziamo il modello e il client Olostep. Sto usando la regione Singapore, che offre anche un 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"])

Questo configura Qwen4-Max per input multimodali, imposta un livello di sforzo di ragionamento e inizializza il client di ricerca. Nota che OLOSTEP_API_TIMEOUT è impostato prima dell’import, perché l’SDK lo legge in fase di caricamento.

Vale la pena capire alcune opzioni di configurazione:

  • model specifica il modello che vogliamo usare.
  • model_type ci permette di inviare immagini tramite l’interfaccia multimodale compatibile con OpenAI.
  • model_server punta all’endpoint da QWEN_BASE_URL.
  • max_tokens limita la lunghezza della risposta generata.
  • reasoning_effort controlla quanto ragionamento fa il modello. Usiamo low per mantenere le risposte rapide.
  • OLOSTEP_API_TIMEOUT imposta un limite di tempo, in secondi, per le richieste di ricerca.

Creare helper riutilizzabili per l’agente

Elaboreremo sia input testuali sia immagini, quindi creiamo una funzione riutilizzabile per eseguire l’agente.

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

Questa funzione invia il prompt e le immagini opzionali a Qwen-Agent, attende la risposta finale ed estrae il testo generato.

Ci serve anche un helper per leggere i 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
        )

Questa funzione estrae il testo selezionabile da ogni pagina del PDF e lo combina in un’unica stringa.

Nota: pdfplumber non esegue OCR. Per i PDF scansionati che contengono solo immagini, renderizza ogni pagina come immagine e inviala direttamente a Qwen4-Max.

2. Rilevamento truffe con un filtro di rischio

Il primo strumento personalizzato identifica comportamenti sospetti. Invece di chiedere all’LLM di riconoscere ogni istruzione di pagamento sospetta, possiamo usare espressioni regolari per rilevare tattiche di truffa note.

È più veloce, deterministico e non usa token del modello. Se vuoi un ripasso della sintassi, il nostro corso Regular Expressions in Python lo copre.

Definire le regole di rilevamento truffe

Iniziamo con un elenco di espressioni regolari e una mappatura tra agenzie governative e i loro domini ufficiali.

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

Questo codice definisce gli indicatori di truffa e mappa i nomi delle agenzie ai domini che usano realmente. Ad esempio, se un avviso menziona l’IRS, l’applicazione controlla i suoi link rispetto a irs.gov.

Estrazione e validazione dei domini

Ci serve poi un helper che estragga l’hostname da 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)

Questo estrae l’hostname e verifica se è il dominio ufficiale o un sottodominio legittimo. La distinzione conta: un semplice controllo endswith() accetterebbe fakeirs.gov come sito IRS.

Implementare lo strumento risk gate

Ora possiamo combinare queste regole in uno strumento personalizzato per 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"

Questo strumento scansiona l’avviso per i pattern corrispondenti, controlla i suoi URL rispetto al dominio ufficiale dell’agenzia e restituisce gli indicatori sospetti. I nomi delle agenzie sono abbinati come parole intere, quindi "irs" non scatta su una parola come "first".

Ad esempio, il nostro finto avviso IRS del Test 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

L’agente riceve questi risultati come parte del suo contesto e li usa quando decide se l’avviso è sospetto.

3. Creare lo strumento di ricerca legale

Il nostro secondo strumento gestisce la ricerca esterna. Non vogliamo che l’agente cerchi su siti a caso, forum o blog di studi legali trattando tutto come autorevole.

Preferiamo invece limitare la ricerca ai siti governativi USA ufficiali e al Cornell LII. Useremo Olostep perché può cercare e fare scraping di più risultati in una singola richiesta. Se vuoi confrontarlo con un’altra opzione, vedi il nostro tutorial su Firecrawl.

Definire le restrizioni di ricerca

Per prima cosa, definiamo le fonti consentite e alcuni limiti su quanto recuperiamo.

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


MAX_PAGES = 2
PAGE_CHARS = 3000

La funzione is_allowed_host() accetta i siti .gov e il Cornell LII. Riusa is_official_domain(), quindi un sosia come fakelaw.cornell.edu viene rifiutato. Teniamo anche al massimo 2 pagine, con un massimo di 3.000 caratteri per pagina.

Implementare lo strumento LookupLaw

Ora creiamo il secondo strumento personalizzato.

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

Questo strumento invia una richiesta di ricerca a Olostep, filtra i risultati, estrae il contenuto delle pagine e restituisce a Qwen4-Max gli estratti selezionati.

Tre dettagli di implementazione degni di nota:

  • Recuperiamo fino a 5 risultati di ricerca ma teniamo al massimo 2 pagine valide.
  • Preferiamo il Markdown estratto e ripieghiamo sulla descrizione della pagina.
  • Salviamo gli URL recuperati in self.sources così l’app può mostrarli dopo l’analisi.

4. Creare l’agente con Qwen-Agent e Qwen4-Max

Ora abbiamo entrambi gli strumenti personalizzati: risk_gate identifica comportamenti sospetti e lookup_law recupera informazioni legali pertinenti. Creiamo quindi l’agente che li coordina.

Un unico prompt di sistema definisce il flusso di lavoro, l’ordine degli strumenti e il formato della risposta. Qwen-Agent non è l’unica opzione per questo tipo di build, e il nostro corso Sviluppare applicazioni LLM con LangChain copre un altro framework.

Definire il prompt di sistema

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

Questo prompt definisce le responsabilità dell’agente e gli impedisce di inventare informazioni legali. Un’istruzione merita attenzione: le scadenze.

Un avviso fraudolento può comunque contenere una scadenza, quindi l’agente deve riportare ciò che il documento afferma spiegando se quella scadenza è credibile.

Aggiungere il disclaimer e la gestione delle fonti

Teniamo il disclaimer fuori dal prompt di sistema così Python può aggiungerlo in modo coerente.

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

Questo ci dà un messaggio di fallback quando la ricerca legale non restituisce una fonte ufficiale e ogni risposta porta un disclaimer legale.

Creare la funzione principale di analisi

Infine, colleghiamo tutto in una funzione riutilizzabile.

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

Questa funzione crea un agente nuovo per ogni documento, esegue l’analisi, raccoglie le fonti recuperate e restituisce la risposta finale. Creiamo LookupLaw() dentro la funzione così ogni avviso ha il suo elenco fonti.

5. Testare l’analizzatore di avvisi legali

Ora abbiamo un analizzatore di avvisi legali funzionante. Proviamolo su 3 documenti di esempio:

  1. Una finta lettera di truffa dell’IRS.
  2. Una fotografia di un avviso di sfratto in Florida.
  3. Una lettera di diffida (cease and desist) in PDF.

Ogni test esercita una parte diversa del flusso di lavoro.

Test 1: una lettera di truffa dell’IRS

Il primo esempio è una finta lettera di truffa dell’IRS. Sostiene che il destinatario deve $4.870 di imposta federale sul reddito e deve pagare entro 24 ore.

Minaccia anche l’arresto, richiede pagamenti con gift card o bonifico e include un sito sospetto. Ecco l’input di esempio:

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

Questo crea un avviso fittizio e lo invia all’agente per l’analisi.

Output:

Output dell’analizzatore di avvisi legali per la finta lettera di truffa IRS

Figura 3: L’output dell’analizzatore per la finta lettera di truffa IRS.

Lo scanner trova diversi indicatori sospetti e l’agente salta la ricerca legale esterna. È ciò che vogliamo per una truffa evidente: l’applicazione non spende token extra in ricerca quando i controlli deterministici indicano già la frode.

Cosa dimostra questo test: Il filtro di rischio può identificare tattiche comuni di truffa e aiutare l’agente a evitare ricerche esterne non necessarie.

Test 2: una fotografia di un avviso di sfratto

Il secondo test si concentra sulla visione nativa di Qwen4-Max. Invece di estrarre noi stessi il testo, inviamo direttamente al modello una fotografia di un avviso di sfratto.

Il nostro esempio è un three-day notice della Florida che richiede $1.850 di affitto non pagato, o il rilascio dell’immobile entro il 23 novembre 2026. Ecco il codice:

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

Questo invia la fotografia direttamente a Qwen4-Max, quindi non serve una pipeline OCR separata. Per un’altra build che combina la visione di Qwen con le chiamate a strumenti, vedi il nostro tutorial sull’API Qwen 3.6 Plus sull’elaborazione delle fatture.

Output:

Output dell’analizzatore per la fotografia dell’avviso di sfratto in Florida

Figura 4: L’output dell’analizzatore per l’avviso di sfratto fotografato.

Il modello ha compreso la fotografia, estratto l’importo e la scadenza e identificato il tipo di avviso. Ha riconosciuto che la pagina legale recuperata non conteneva informazioni sufficienti per verificare lo statuto e ha notato i campi firma e consegna vuoti nel documento di esempio.

Cosa dimostra questo test: Qwen4-Max può interpretare direttamente documenti legali fotografati, mentre Qwen-Agent coordina ulteriori ricerche e comunica l’incertezza.

Test 3: un PDF con lettera di diffida

Per l’ultimo test usiamo una lettera di diffida (cease and desist) di due pagine in formato PDF.

Il documento cita 17 U.S.C. §§ 501 e 512, adduce violazione del copyright e chiede al destinatario di rimuovere il contenuto contestato e confermare la conformità entro il 28 novembre 2026. Il PDF contiene testo selezionabile, quindi possiamo usare il nostro helper read_pdf(). Ecco il codice:

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

Markdown(
    analyze_notice(text=pdf_text)
)

Questo estrae i contenuti del PDF e invia il testo risultante allo stesso agente.

Output:

Output dell’analizzatore per la lettera di diffida in PDF

Figura 5: L’output dell’analizzatore per la lettera di diffida.

L’agente distingue correttamente una richiesta legale privata da un avviso ufficiale governativo o del tribunale. Riconosce che non è richiesto denaro e adatta le raccomandazioni. Lo strumento di ricerca ha recuperato una pagina pertinente dell’Ufficio Copyright degli Stati Uniti, che appare nelle fonti finali.

Cosa dimostra questo test: Lo stesso agente può gestire corrispondenza in PDF, identificare la natura di una richiesta legale e raccomandare i prossimi passi appropriati.

La mia esperienza con Qwen4-Max: pro, contro e criticità

Dopo aver usato Qwen4-Max per questo progetto, altre applicazioni agentiche e del codice “vibe”, ecco la mia valutazione onesta.

I pro

L’ecosistema Qwen copre molti ambiti. Include speech-to-text, text-to-speech, ricerca web, scraping web e un toolkit open-source per costruire applicazioni agentiche senza dover implementare tutto da zero.

Quello che mi è piaciuto di più è quanto bene Qwen4-Max abbia seguito istruzioni dettagliate. In genere ha rispettato la struttura di output richiesta, estratto date dai documenti e prodotto sintesi accurate durante i miei test.

Ha spiccato la sua comprensione delle immagini. Gli ho dato la fotografia di un avviso legale e ha letto i contenuti senza una pipeline OCR aggiuntiva, che è di grande aiuto per applicazioni agentiche ricche di documenti.

I contro

La velocità è stato il problema più grande per me. Qwen4-Max non è stato il mio modello preferito per il vibe coding: rispetto a DeepSeek V4.1 Flash e ad altri modelli testati, spesso impiegava più tempo per completare compiti semplici.

Ho visto regolarmente velocità di generazione intorno ai 100 token al secondo, ma quel numero nasconde il costo reale. Il modello impiegava molto a ragionare su modifiche banali, e a volte chiedevo un semplice edit e aspettavo molto più del previsto.

Se vuoi provare l’opzione più veloce, la trattiamo nel nostro tutorial sull’API DeepSeek V4.1 Flash.

Le criticità

La ricerca web nativa è stata la parte più frustrante. Nei miei test, i tempi di risposta erano incoerenti: la stessa query poteva restituire risultati in pochi secondi o richiedere quasi un minuto, e alcune richieste superavano i 400 secondi senza completarsi.

Tre esecuzioni del mio flusso di ricerca hanno impiegato quasi 16 minuti. Non era abbastanza affidabile per un’applicazione che dipende da informazioni legali esterne.

Sostituire la ricerca nativa con Olostep è diventata una necessità, il che ha anche significato che non potevo fare completo affidamento sull’ecosistema Qwen, come avevo inizialmente pianificato.

Ho incontrato un altro problema sperimentando con il DeepSeek Harness. Ho fatto una semplice domanda sulla ricerca del mercato azionario, e il flusso ha impiegato molto tempo prima di restituire un errore. Frustrante per un compito così semplice.

In generale, Qwen4-Max ha capacità notevoli, ma il suo overhead di ragionamento e la ricerca nativa incoerente vanno valutati prima di costruirci attorno flussi di lavoro in produzione. Se vuoi continuare a costruire con i modelli Qwen, il nostro tutorial sull’API Qwen 3.7 Max illustra un agente di produttività con auto-review.

Abid Ali Awan

Autore

Abid Ali Awan

In quanto data scientist certificato, sono appassionato di sfruttare tecnologie all’avanguardia per creare applicazioni di machine learning innovative. Con una solida esperienza in riconoscimento vocale, analisi e reportistica dei dati, MLOps, AI conversazionale e NLP, ho affinato le mie competenze nello sviluppo di sistemi intelligenti in grado di avere un impatto concreto. Oltre alla mia expertise tecnica, sono anche un comunicatore efficace, con il talento di rendere chiari e sintetici concetti complessi. Di conseguenza, sono diventato un blogger molto seguito in ambito data science, condividendo idee ed esperienze con una community in crescita di professionisti dei dati. Attualmente mi concentro sulla creazione e sull’editing di contenuti, lavorando con large language model per sviluppare contenuti potenti e coinvolgenti che possano aiutare aziende e singoli a valorizzare al meglio i propri dati.

Argomenti

Correlato