Pular para o conteúdo principal

Tutorial Qwen4-Max: construa um analisador de notificações legais

Crie um analisador de notificações legais dos EUA com Qwen4-Max, Qwen-Agent e Olostep. Sinalize golpes, leia fotos e PDFs e verifique alegações em fontes oficiais.
· 12 min leer

Explore com IA

Você já recebeu uma notificação do governo e ficou na dúvida se era legítima, se precisava responder ou se era alguém tentando te aplicar um golpe?

Notificações legais são difíceis de entender, principalmente quando linguagem jurídica complicada se mistura com cobranças e prazos. Golpistas se aproveitam dessa confusão, fingindo ser órgãos públicos e criando uma falsa sensação de urgência.

Neste tutorial, vamos construir um analisador de notificações legais dos EUA usando Qwen4-Max e o framework Qwen-Agent. O aplicativo aceita texto, imagens e PDFs, sinaliza táticas suspeitas de pagamento e pesquisa recursos legais oficiais quando precisa verificar alguma informação.

Em vez de depender 100% de um LLM, vamos combiná-lo com duas ferramentas em Python. A primeira usa expressões regulares para capturar indícios comuns de golpe. A segunda usa o Olostep para pesquisar em sites oficiais do governo e no Cornell Legal Information Institute (LII).

Em poucas palavras

  • Construímos um analisador de notificações legais com Qwen4-Max, Qwen-Agent e Olostep que aceita texto, fotos e PDFs.
  • Um filtro de risco baseado em regex sinaliza padrões de golpe e domínios parecidos antes do modelo fazer qualquer pesquisa.
  • Uma ferramenta de pesquisa limita as consultas a sites .gov e ao Cornell LII, e o agente pula a pesquisa quando a notificação é claramente fraudulenta.
  • Nos meus testes, o Qwen4-Max leu bem notificações fotografadas, mas foi lento em tarefas simples e sua busca nativa na web foi pouco confiável.

O que é o Qwen4-Max?

Qwen4-Max é o modelo principal da Alibaba na família Qwen4, lançado em 16 de novembro de 2026. É um modelo MoE esparso com melhorias arquiteturais, visão nativa e janela de contexto maior, projetado para raciocínio complexo e aplicações com agentes.

Veja os recursos mais relevantes para o nosso projeto:

  • Arquitetura MoE esparsa: Qwen4-Max tem 2,4T de parâmetros no backbone, 71B ativos por token e mais 328B de parâmetros de embedding N-gram. Camadas Gated DeltaNet e Qwen Sparse Attention reduzem os custos em contextos longos.
  • Visão nativa: O modelo lê imagens diretamente, então podemos enviar a foto de uma notificação legal sem precisar construir um pipeline separado de OCR.
  • Janela de contexto de 1M de tokens: Grande o suficiente para documentos extensos e muitas informações de apoio.
  • Melhor eficiência de tokens: Segundo a Alibaba, o Qwen4-Max usa cerca de 35% menos tokens que o Qwen3.8-Max no Work360 com esforço de raciocínio High, e cerca de 49% menos no Terminal-Bench 4.0. Em Xhigh, as reduções são de aproximadamente 24% e 48%.
  • Custos menores por tarefa: No Work360, o Qwen4-Max marcou 52,69, acima de 47,74 do Qwen3.8-Max, enquanto o custo médio por tarefa caiu de US$ 4,43 para US$ 1,67, redução de 62%.

Estes são os resultados de benchmark no anúncio da Alibaba, mostrando o Qwen4-Max superando o Qwen3.8-Max em quase todas as capacidades avaliadas:

Comparação de benchmarks da Alibaba do Qwen4-Max e outros modelos em tarefas de código, trabalho e longo horizonte

Figura 1: Resultados de benchmark do Qwen4-Max. Imagem de: Qwen, Qwen4-Max: Your New Teammate Has Arrived.

Como funciona o analisador de notificações legais?

O analisador é um único assistente Qwen-Agent que coordena duas ferramentas em Python, enquanto o Qwen4-Max cuida da compreensão do documento e do raciocínio. Antes de escrever qualquer código, vamos ver o fluxo.

Diagrama do fluxo do analisador, da entrada da notificação ao filtro de risco, pesquisa legal e resposta final

Figura 2: Fluxo de trabalho do analisador de notificações legais.

O fluxo tem 6 etapas:

  1. O usuário envia a notificação como texto, imagem ou PDF.
  2. O Qwen4-Max lê o documento e identifica seu conteúdo principal.
  3. O agente chama risk_gate para verificar instruções de pagamento suspeitas, ameaças e links.
  4. Se o documento for obviamente fraudulento, o agente pula a pesquisa externa.
  5. Do contrário, o agente chama lookup_law para pesquisar recursos legais oficiais.
  6. O Qwen4-Max produz uma resposta estruturada com veredito, resumo, evidências e próximos passos recomendados.

A principal decisão de design é que o LLM não faz tudo. Python cuida das checagens determinísticas, o Olostep faz a pesquisa externa e o Qwen4-Max cuida da compreensão do documento e do raciocínio.

Isso mantém o fluxo simples, dando ao agente a ferramenta certa para cada tarefa. Se a terminologia de agentes for nova para você, nosso curso Introduction to AI Agents cobre os fundamentos sem exigir código.

1. Preparando o ambiente

Vamos usar Jupyter Notebook, QwenCloud para acesso aos modelos e Olostep para busca e raspagem na web.

Primeiro, crie uma conta no QwenCloud, adicione créditos ou assine um Token Plan e gere uma chave de API no painel. O QwenCloud fornece um endpoint de API com base na região selecionada.

Você também vai precisar de uma chave de API do Olostep para a pesquisa legal.

Defina suas variáveis de ambiente no terminal antes de abrir o Jupyter Notebook. Você também pode defini-las dentro do notebook com 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 uso o endpoint do Token Plan, que dá acesso com desconto aos modelos. Se você pagar conforme o uso, utilize o endpoint que o QwenCloud mostra para a sua região.

Em seguida, instale as dependências necessárias no seu notebook:

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

O extra rag adiciona pacotes de processamento de documentos como o pdfplumber, que usaremos para ler PDFs. A partir da versão 0.0.34, o Qwen-Agent também importa soundfile e tqdm na inicialização sem declará-los como dependências, então instalamos ambos explicitamente.

Configurando o Qwen4-Max

Agora, vamos inicializar o modelo e o cliente do Olostep. Estou usando a região de Cingapura, que também oferece Token Plan.

import logging
import os
import re
import warnings

# O SDK do Olostep lê isto no momento do import, então defina primeiro
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"])

Isso configura o Qwen4-Max para entrada multimodal, define um nível de esforço de raciocínio e inicializa o cliente de pesquisa. Observe que OLOSTEP_API_TIMEOUT é definido antes do import, porque o SDK lê essa variável ao carregar.

Algumas opções de configuração valem atenção:

  • model especifica o modelo que queremos usar.
  • model_type permite enviar imagens pela interface multimodal compatível com OpenAI.
  • model_server aponta para o endpoint de QWEN_BASE_URL.
  • max_tokens limita o tamanho da resposta gerada.
  • reasoning_effort controla quanto raciocínio o modelo faz. Usamos low para respostas mais rápidas.
  • OLOSTEP_API_TIMEOUT define, em segundos, o tempo limite para solicitações de pesquisa.

Criando helpers reutilizáveis do agente

Vamos processar entradas de texto e imagem, então criaremos uma função reutilizável para rodar o 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,
    )

Essa função envia o prompt e, opcionalmente, imagens ao Qwen-Agent, aguarda a resposta final e extrai o texto gerado.

Também precisamos de um helper para ler PDFs.

def read_pdf(path):
    import pdfplumber

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

Essa função extrai o texto selecionável de cada página do PDF e combina tudo em uma única string.

Observação: o pdfplumber não faz OCR. Para PDFs digitalizados que contêm apenas imagens, renderize cada página como imagem e envie diretamente ao Qwen4-Max.

2. Detectando golpes com um filtro de risco

A primeira ferramenta personalizada identifica comportamentos suspeitos. Em vez de pedir ao LLM que reconheça toda instrução suspeita de pagamento, podemos usar expressões regulares para detectar táticas de golpe conhecidas.

Isso é mais rápido, determinístico e não consome tokens do modelo. Se quiser revisar a sintaxe, nosso curso Regular Expressions in Python cobre o tema.

Definindo as regras de detecção

Comecemos com uma lista de expressões regulares e um mapeamento entre órgãos públicos e seus domínios oficiais.

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

Esse código define os indicadores de golpe e mapeia nomes de órgãos para os domínios que eles realmente usam. Por exemplo, se uma notificação menciona o IRS, o app confere seus links contra irs.gov.

Extraindo e validando domínios

Agora, precisamos de um helper que extraia o hostname de uma 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)

Isso extrai o hostname e verifica se é o domínio oficial ou um subdomínio legítimo. A distinção é importante: um simples endswith() aceitaria fakeirs.gov como se fosse um site do IRS.

Implementando a ferramenta risk gate

Agora podemos combinar essas regras em uma ferramenta personalizada do 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"

Essa ferramenta varre a notificação em busca de padrões, confere as URLs com o domínio oficial do órgão e retorna os indícios suspeitos. Os nomes dos órgãos são casados como palavras inteiras, então "irs" não dispara em palavras como "first".

Por exemplo, nossa notificação fictícia do IRS do Teste 1 produz:

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

O agente recebe esses resultados no contexto e os usa para decidir se a notificação é suspeita.

Nossa segunda ferramenta cuida da pesquisa externa. Não queremos que o agente busque em sites aleatórios, fóruns ou blogs de escritórios e trate tudo como autoridade.

Em vez disso, restringimos a pesquisa a sites oficiais do governo dos EUA e ao Cornell LII. Vamos usar o Olostep porque ele consegue pesquisar e raspar vários resultados em uma única requisição. Se quiser comparar com outra opção, veja nosso tutorial do Firecrawl.

Definindo as restrições de pesquisa

Primeiro, vamos definir as fontes permitidas e alguns limites sobre quanto conteúdo trazer.

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


MAX_PAGES = 2
PAGE_CHARS = 3000

A função is_allowed_host() aceita sites .gov e o Cornell LII. Ela reutiliza is_official_domain(), então um domínio parecido como fakelaw.cornell.edu é rejeitado. Também mantemos no máximo 2 páginas, com até 3.000 caracteres por página.

Implementando a ferramenta LookupLaw

Agora vamos criar a segunda ferramenta personalizada.

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

Essa ferramenta envia uma busca ao Olostep, filtra os resultados, extrai o conteúdo das páginas e devolve os trechos selecionados ao Qwen4-Max.

Três detalhes importantes:

  • Buscamos até 5 resultados, mas mantemos no máximo 2 páginas qualificadas.
  • Preferimos o Markdown raspado e caímos para a descrição da página se necessário.
  • Guardamos as URLs recuperadas em self.sources para o app exibi-las após a análise.

4. Montando o agente com Qwen-Agent e Qwen4-Max

Agora temos as duas ferramentas personalizadas: risk_gate identifica comportamentos suspeitos e lookup_law recupera informações legais relevantes. Em seguida, criamos o agente que coordena tudo.

Um único prompt de sistema define o fluxo, a ordem das ferramentas e o formato da resposta. O Qwen-Agent não é a única opção para esse tipo de construção; nosso curso Developing LLM Applications with LangChain cobre outro framework.

Definindo o prompt de 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."""

Esse prompt define as responsabilidades do agente e impede que ele invente informações legais. Uma instrução merece destaque: prazos.

Uma notificação fraudulenta pode trazer prazo assim mesmo, então o agente deve relatar o que o documento afirma e explicar se esse prazo é crível.

Adicionando o aviso e o tratamento de fontes

Mantemos o aviso fora do prompt de sistema para o Python anexá-lo de forma consistente.

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

Isso nos dá uma mensagem de fallback quando a pesquisa legal não retorna uma fonte oficial, e toda resposta carrega um aviso legal.

Criando a função principal de análise

Por fim, vamos conectar tudo em uma função reutilizável.

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

Essa função cria um agente novo para cada documento, roda a análise, coleta as fontes recuperadas e retorna a resposta final. Criamos o LookupLaw() dentro da função para que cada notificação tenha sua própria lista de fontes.

5. Testando o analisador de notificações legais

Agora temos um analisador funcional. Vamos testá-lo em 3 documentos de exemplo:

  1. Uma carta de golpe fictícia do IRS.
  2. Uma foto de notificação de despejo na Flórida.
  3. Um PDF de carta de cessar e desistir.

Cada teste exercita uma parte diferente do fluxo.

Teste 1: carta de golpe do IRS

Nosso primeiro exemplo é uma carta fictícia de golpe do IRS. Ela afirma que o destinatário deve US$ 4.870 de imposto de renda federal e precisa pagar em 24 horas.

Também ameaça prisão, exige pagamento com gift cards ou transferência bancária e inclui um site suspeito. Veja a entrada de exemplo:

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

Isso cria uma notificação fictícia e a envia ao agente para análise.

Saída:

Saída do analisador para a carta fictícia de golpe do IRS

Figura 3: Saída do analisador para a carta fictícia de golpe do IRS.

O scanner encontra vários indícios suspeitos, e o agente pula a pesquisa legal externa. É o que queremos em um golpe óbvio: o app não gasta tokens a mais quando checagens determinísticas já apontam fraude.

O que este teste demonstra: o filtro de risco identifica táticas comuns de golpe e ajuda o agente a evitar pesquisas externas desnecessárias.

Teste 2: foto de uma notificação de despejo

O segundo teste destaca a visão nativa do Qwen4-Max. Em vez de extrair o texto por conta própria, enviamos uma foto de uma notificação de despejo direto ao modelo.

Nosso exemplo é uma three-day notice da Flórida exigindo US$ 1.850 de aluguel em atraso ou a posse do imóvel até 23 de novembro de 2026. Veja o código:

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

Isso envia a foto diretamente ao Qwen4-Max, sem precisar de um pipeline de OCR separado. Para outro build que combina a visão do Qwen com chamadas de ferramenta, veja nosso tutorial da API Qwen 3.6 Plus sobre processamento de faturas.

Saída:

Saída do analisador para a notificação de despejo fotografada da Flórida

Figura 4: Saída do analisador para a notificação de despejo fotografada.

O modelo entendeu a foto, extraiu o valor e o prazo e identificou o tipo de notificação. Reconheceu que a página oficial recuperada não tinha informação suficiente para verificar o estatuto e notou campos de assinatura e entrega em branco no documento de exemplo.

O que este teste demonstra: o Qwen4-Max interpreta documentos legais fotografados diretamente, enquanto o Qwen-Agent coordena a pesquisa adicional e comunica incertezas.

Teste 3: PDF de carta de cessar e desistir

No teste final, usamos uma carta de cessar e desistir em PDF com duas páginas.

O documento cita 17 U.S.C. §§ 501 e 512, alega violação de direitos autorais e pede que o destinatário remova o conteúdo contestado e confirme conformidade até 28 de novembro de 2026. O PDF tem texto selecionável, então podemos usar nosso helper read_pdf(). Veja o código:

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

Markdown(
    analyze_notice(text=pdf_text)
)

Isso extrai o conteúdo do PDF e envia o texto resultante para o mesmo agente.

Saída:

Saída do analisador para a carta de cessar e desistir em PDF

Figura 5: Saída do analisador para a carta de cessar e desistir.

O agente diferencia corretamente uma demanda legal privada de uma notificação oficial de governo ou tribunal. Ele reconhece que não há cobrança de dinheiro e ajusta as recomendações. A ferramenta de pesquisa recuperou uma página relevante do US Copyright Office, que aparece nas fontes finais.

O que este teste demonstra: o mesmo agente lida com correspondência em PDF, identifica a natureza da demanda legal e recomenda próximos passos adequados.

Minha experiência com o Qwen4-Max: prós, contras e pontos críticos

Depois de usar o Qwen4-Max neste projeto, em outras aplicações com agentes e em vibe coding, aqui vai minha avaliação sincera.

Os prós

O ecossistema Qwen cobre bastante coisa. Inclui fala-para-texto, texto-para-fala, busca na web, raspagem de páginas e um toolkit open source para construir aplicações com agentes sem implementar tudo do zero.

O que mais gostei foi o quanto o Qwen4-Max seguiu instruções detalhadas. Em geral, respeitou o formato de saída solicitado, extraiu datas de documentos e produziu resumos precisos nos meus testes.

Seu entendimento de imagens se destacou. Eu dei a foto de uma notificação legal e ele leu o conteúdo sem pipeline extra de OCR, o que ajuda muito em aplicações com muitos documentos.

Os contras

A velocidade foi o maior problema para mim. O Qwen4-Max não foi meu modelo preferido para vibe coding: comparado ao DeepSeek V4.1 Flash e outros modelos que testei, ele muitas vezes demorou mais do que o esperado em tarefas simples.

Vi com frequência velocidades de geração de cerca de 100 tokens por segundo, mas esse número esconde o custo real. O modelo gastou muito tempo raciocinando sobre mudanças triviais e, às vezes, eu pedia um ajuste simples e esperava bem mais do que esperava.

Se você quiser testar a opção mais rápida, cobrimos no nosso tutorial da API DeepSeek V4.1 Flash.

Os pontos críticos

A busca nativa na web foi a parte mais frustrante. Nos meus testes, os tempos de resposta foram inconsistentes: a mesma consulta podia voltar em segundos ou levar quase um minuto, e algumas requisições passaram de 400 segundos sem concluir.

Três execuções do meu fluxo de pesquisa levaram quase 16 minutos. Isso não foi confiável o suficiente para um app que depende de informação legal externa.

Trocar a busca nativa pelo Olostep virou necessidade, o que também significou que eu não poderia depender inteiramente do ecossistema Qwen, como planejei inicialmente.

Enfrentei outro problema ao experimentar o DeepSeek Harness. Fiz uma pergunta simples sobre pesquisa do mercado de ações, e o fluxo gastou muito tempo antes de retornar um erro. Frustrante para uma tarefa tão direta.

No geral, o Qwen4-Max tem capacidades impressionantes, mas o overhead de raciocínio e a busca nativa inconsistente precisam ser ponderados antes de você construir fluxos de produção em torno dele. Se quiser continuar com modelos Qwen, nosso tutorial da API Qwen 3.7 Max mostra um agente de produtividade com autoavaliação.

Abid Ali Awan

Autor

Abid Ali Awan

Sou um cientista de dados certificado que gosta de criar aplicativos de aprendizado de máquina e escrever blogs sobre ciência de dados. No momento, estou me concentrando na criação e edição de conteúdo e no trabalho com modelos de linguagem de grande porte.

Temas

Relacionado

Tutorial

Guia de Introdução ao Ajuste Fino de LLMs