Saltar al contenido principal

Tutorial de Qwen4-Max: crea un analizador de avisos legales

Crea un analizador de avisos legales de EE. UU. con Qwen4-Max, Qwen-Agent y Olostep. Detecta estafas, lee fotos y PDFs y verifica afirmaciones frente a fuentes oficiales.
· 12 min leer

Explora con IA

¿Alguna vez has recibido un aviso del gobierno y te has preguntado si era legítimo, si debías responder o si alguien intentaba estafarte?

Los avisos legales son difíciles de entender, sobre todo cuando mezclan lenguaje complejo con exigencias de pago y plazos. Los estafadores aprovechan esa confusión haciéndose pasar por organismos públicos y generando una falsa sensación de urgencia.

En este tutorial, vamos a crear un analizador de avisos legales de EE. UU. usando Qwen4-Max y el framework Qwen-Agent. La aplicación acepta texto, imágenes y PDFs, marca tácticas de pago sospechosas y consulta recursos legales oficiales cuando necesita verificar algo.

En lugar de depender por completo de un modelo de lenguaje grande (LLM), lo combinaremos con dos herramientas en Python. La primera usa expresiones regulares para detectar indicadores habituales de estafa. La segunda utiliza Olostep para buscar en sitios web oficiales del gobierno y en el Cornell Legal Information Institute (LII).

En pocas palabras

  • Construimos un analizador de avisos legales con Qwen4-Max, Qwen-Agent y Olostep que acepta texto, fotos y PDFs.
  • Una compuerta de riesgo basada en regex marca patrones de estafa y dominios suplantados antes de que el modelo haga ninguna investigación.
  • Una herramienta de investigación limita las consultas a sitios .gov y Cornell LII, y el agente omite la investigación cuando un aviso es claramente fraudulento.
  • En mis pruebas, Qwen4-Max leyó bien avisos fotografiados, pero fue lento en tareas sencillas y su búsqueda web nativa fue poco fiable.

¿Qué es Qwen4-Max?

Qwen4-Max es el modelo insignia de Alibaba dentro de la familia Qwen4, lanzado el 16 de noviembre de 2026. Es un modelo MoE (mixture-of-experts) disperso con mejoras arquitectónicas, visión nativa y una ventana de contexto mayor, pensado para razonamiento complejo y aplicaciones agenticas.

Estas son las funciones más relevantes para nuestro proyecto:

  • Arquitectura MoE dispersa: Qwen4-Max tiene 2,4T de parámetros en el backbone, 71B activos por token y 328B adicionales en parámetros de embeddings N-gram. Las capas Gated DeltaNet y Qwen Sparse Attention contienen los costes en contextos largos.
  • Visión nativa: El modelo lee imágenes directamente, así que podemos enviar una fotografía de un aviso legal sin montar un pipeline de OCR aparte.
  • Ventana de contexto de 1M tokens: Suficiente para documentos largos y abundante información de apoyo.
  • Mejor eficiencia de tokens: Según Alibaba, Qwen4-Max usa aproximadamente un 35% menos de tokens que Qwen3.8-Max en Work360 con esfuerzo de razonamiento High, y alrededor de un 49% menos en Terminal-Bench 4.0. Con esfuerzo Xhigh, las reducciones son aproximadamente del 24% y 48%.
  • Menor coste por tarea: En Work360, Qwen4-Max obtuvo 52,69, frente a 47,74 de Qwen3.8-Max, mientras que el coste medio por tarea bajó de 4,43 $ a 1,67 $, una reducción del 62%.

Estos son los resultados de benchmarks del anuncio de Alibaba, donde se ve que Qwen4-Max mejora a Qwen3.8-Max en casi todas las capacidades evaluadas:

Comparativa de benchmarks de Alibaba entre Qwen4-Max y otros modelos en tareas de código, trabajo y largo horizonte

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

¿Cómo funciona el analizador de avisos legales?

El analizador es un único asistente de Qwen-Agent que coordina dos herramientas en Python, mientras Qwen4-Max se encarga de la comprensión de documentos y el razonamiento. Antes de escribir código, veamos el flujo de trabajo.

Diagrama del flujo del analizador de avisos legales, desde la entrada del aviso pasando por la compuerta de riesgo y la investigación legal hasta la respuesta final

Figura 2: Flujo de trabajo del analizador de avisos legales.

El flujo tiene 6 pasos:

  1. El usuario envía un aviso como texto, imagen o PDF.
  2. Qwen4-Max lee el documento e identifica su contenido principal.
  3. El agente llama a risk_gate para buscar instrucciones de pago sospechosas, amenazas y enlaces.
  4. Si el documento es claramente fraudulento, el agente omite la investigación externa.
  5. Si no, el agente llama a lookup_law para buscar en recursos legales oficiales.
  6. Qwen4-Max genera una respuesta estructurada con veredicto, resumen, evidencias y próximos pasos recomendados.

La decisión clave de diseño es que el LLM no lo hace todo. Python se encarga de comprobaciones deterministas, Olostep de la investigación externa, y Qwen4-Max de la comprensión del documento y el razonamiento.

Así el flujo se mantiene simple y el agente tiene una herramienta adecuada para cada tarea. Si la terminología de agentes te suena nueva, nuestro curso Introduction to AI Agents cubre los fundamentos sin necesidad de programar.

1. Preparación del entorno

Usaremos Jupyter Notebook, QwenCloud para acceder al modelo y Olostep para búsqueda y scraping web.

Primero, crea una cuenta en QwenCloud, añade créditos o suscríbete a un Token Plan y genera una clave de API desde el panel. QwenCloud proporciona un endpoint de API según la región que elijas.

También necesitarás una clave de API de Olostep para la investigación legal.

Configura tus variables de entorno en la terminal antes de lanzar Jupyter Notebook. También puedes configurarlas dentro 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"

Yo uso el endpoint del Token Plan, que ofrece acceso con descuento a los modelos. Si pagas por uso, utiliza el endpoint que QwenCloud muestre para tu región.

Después, instala las dependencias necesarias en tu notebook:

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

El extra rag añade paquetes de procesamiento de documentos como pdfplumber, que usaremos para leer PDFs. En la versión 0.0.34, Qwen-Agent también importa soundfile y tqdm al arrancar sin declararlas como dependencias, así que instalamos ambas explícitamente.

Configurar Qwen4-Max

A continuación, inicializamos el modelo y el cliente de Olostep. Estoy usando la región de Singapur, que también ofrece 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"])

Esto configura Qwen4-Max para entrada multimodal, define un nivel de esfuerzo de razonamiento e inicializa el cliente de investigación. Ten en cuenta que OLOSTEP_API_TIMEOUT se establece antes del import, porque el SDK lo lee al cargarse.

Conviene entender algunas opciones de configuración:

  • model especifica el modelo que queremos usar.
  • model_type nos permite enviar imágenes por la interfaz multimodal compatible con OpenAI.
  • model_server apunta al endpoint de QWEN_BASE_URL.
  • max_tokens limita la longitud de la respuesta generada.
  • reasoning_effort controla cuánto razona el modelo. Usamos low para respuestas rápidas.
  • OLOSTEP_API_TIMEOUT fija un límite de tiempo, en segundos, para las solicitudes de investigación.

Crear utilidades reutilizables para el agente

Procesaremos entradas de texto e imagen, así que creemos una función reutilizable para ejecutar el 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,
    )

Esta función envía el prompt y las imágenes opcionales a Qwen-Agent, espera la respuesta final y extrae el texto generado.

También necesitamos una utilidad para leer 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
        )

Esta función extrae el texto seleccionable de cada página del PDF y lo combina en una sola cadena.

Nota: pdfplumber no hace OCR. Para PDFs escaneados que solo contienen imágenes, renderiza cada página como imagen y envíala directamente a Qwen4-Max.

2. Detección de estafas con una compuerta de riesgo

La primera herramienta personalizada identifica comportamientos sospechosos. En vez de pedirle al LLM que reconozca todas las instrucciones de pago dudosas, podemos usar expresiones regulares para detectar tácticas conocidas.

Es más rápido, determinista y no usa tokens del modelo. Si necesitas repasar la sintaxis, nuestro curso Regular Expressions in Python lo cubre.

Definir reglas de detección

Empecemos con una lista de expresiones regulares y un mapeo entre agencias y sus dominios oficiales.

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

Este código define los indicadores de estafa y relaciona nombres de agencias con los dominios que realmente usan. Por ejemplo, si un aviso menciona el IRS, la aplicación comprueba sus enlaces contra irs.gov.

Extraer y validar dominios

Ahora necesitamos una utilidad que extraiga el hostname de una 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)

Esto extrae el hostname y comprueba si es el dominio oficial o un subdominio legítimo. La distinción importa: una comprobación básica con endswith() aceptaría fakeirs.gov como si fuera del IRS.

Implementar la herramienta de compuerta de riesgo

Ahora podemos combinar estas reglas en una herramienta personalizada de 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"

Esta herramienta escanea el aviso en busca de patrones, compara sus URLs con el dominio oficial de la agencia y devuelve los indicadores sospechosos. Los nombres de agencia se buscan como palabras completas, de modo que "irs" no salta por una palabra como "first".

Por ejemplo, nuestro aviso ficticio del 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

El agente recibe estos resultados como parte de su contexto y los usa para decidir si el aviso es sospechoso.

Nuestra segunda herramienta gestiona la investigación externa. No queremos que el agente busque en webs aleatorias, foros o blogs de bufetes y trate todo lo que encuentre como autorizado.

En su lugar, restringimos la investigación a sitios oficiales del gobierno de EE. UU. y al Cornell LII. Usaremos Olostep porque puede buscar y hacer scraping de varios resultados en una sola solicitud. Si quieres compararlo con otra opción, consulta nuestro tutorial de Firecrawl.

Definir las restricciones de investigación

Primero, definamos las fuentes permitidas y algunos límites sobre cuánto recuperamos.

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


MAX_PAGES = 2
PAGE_CHARS = 3000

La función is_allowed_host() acepta sitios .gov y Cornell LII. Reutiliza is_official_domain(), por lo que un dominio suplantado como fakelaw.cornell.edu se rechaza. También mantenemos como máximo 2 páginas y 3.000 caracteres por página.

Implementar la herramienta LookupLaw

Ahora creemos la segunda herramienta 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."
        )

Esta herramienta envía una búsqueda a Olostep, filtra los resultados, extrae el contenido de las páginas y devuelve los fragmentos seleccionados a Qwen4-Max.

Tres detalles de implementación a destacar:

  • Recuperamos hasta 5 resultados de búsqueda pero conservamos como mucho 2 páginas válidas.
  • Preferimos el Markdown raspado y recurrimos a la descripción de la página si hace falta.
  • Guardamos las URLs recuperadas en self.sources para mostrarlas después del análisis.

4. Construir el agente con Qwen-Agent y Qwen4-Max

Ya tenemos las dos herramientas personalizadas: risk_gate identifica conductas sospechosas y lookup_law recupera información legal relevante. Ahora creamos el agente que las coordina.

Un único prompt de sistema define el flujo de trabajo, el orden de herramientas y el formato de respuesta. Qwen-Agent no es la única opción para este tipo de desarrollo; nuestro curso Developing LLM Applications with LangChain cubre otro framework.

Definir el prompt del 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."""

Este prompt define las responsabilidades del agente y evita que invente información legal. Una instrucción merece atención especial: los plazos.

Un aviso fraudulento puede incluir un plazo, así que el agente debe informar de lo que el documento afirma y explicar si ese plazo es creíble.

Mantenemos el aviso legal fuera del prompt del sistema para que Python pueda añadirlo siempre de forma coherente.

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

Esto nos da un mensaje de respaldo cuando la investigación legal no devuelve una fuente oficial, y cada respuesta lleva un aviso legal.

Crear la función principal de análisis

Por último, conectemos todo en una función reutilizable.

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

Esta función crea un agente nuevo para cada documento, ejecuta el análisis, recoge las fuentes recuperadas y devuelve la respuesta final. Creamos LookupLaw() dentro de la función para que cada aviso tenga su propia lista de fuentes.

5. Probar el analizador de avisos legales

Ya tenemos un analizador funcional. Probémoslo con 3 documentos de ejemplo:

  1. Una carta falsa del IRS (estafa).
  2. La fotografía de un aviso de desahucio en Florida.
  3. Una carta de cese y desistimiento en PDF.

Cada prueba pone a trabajar una parte distinta del flujo.

Prueba 1: una carta de estafa del IRS

El primer ejemplo es una carta falsa del IRS. Afirma que la persona debe 4.870 $ en impuesto federal sobre la renta y que debe pagar en 24 horas.

Además, amenaza con arresto, exige pago con tarjetas regalo o transferencia y añade un sitio web sospechoso. Este es el input de ejemplo:

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

Esto crea un aviso ficticio y lo envía al agente para su análisis.

Salida:

Salida del analizador para la carta falsa del IRS

Figura 3: Salida del analizador para la carta de estafa del IRS.

El escáner encuentra varios indicadores sospechosos y el agente omite la investigación legal externa. Es lo deseable ante una estafa obvia: la aplicación no gasta tokens extra en investigar cuando las comprobaciones deterministas ya apuntan a fraude.

Qué demuestra esta prueba: La compuerta de riesgo puede identificar tácticas comunes de estafa y ayudar al agente a evitar investigación externa innecesaria.

Prueba 2: una fotografía de un aviso de desahucio

La segunda prueba se centra en la visión nativa de Qwen4-Max. En vez de extraer nosotros el texto, enviamos directamente la fotografía de un aviso de desahucio al modelo.

Nuestro ejemplo es un aviso de tres días de Florida que exige 1.850 $ de alquiler impagado o la posesión del inmueble para el 23 de noviembre de 2026. Este es el código:

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

Esto envía la fotografía directamente a Qwen4-Max, sin necesidad de un pipeline de OCR aparte. Para otro desarrollo que combina la visión de Qwen con llamadas a herramientas, consulta nuestro tutorial de la API de Qwen 3.6 Plus sobre procesamiento de facturas.

Salida:

Salida del analizador para el aviso de desahucio de Florida fotografiado

Figura 4: Salida del analizador para el aviso de desahucio fotografiado.

El modelo entendió la fotografía, extrajo el importe y el plazo, e identificó el tipo de aviso. Reconoció que la página legal recuperada no tenía suficiente información para verificar el precepto legal y detectó campos de firma y entrega en blanco en el documento de muestra.

Qué demuestra esta prueba: Qwen4-Max puede interpretar directamente documentos legales fotografiados, mientras Qwen-Agent coordina la investigación adicional y comunica la incertidumbre.

Prueba 3: un PDF de cese y desistimiento

En la última prueba usamos una carta de cese y desistimiento de dos páginas en formato PDF.

El documento cita 17 U.S.C. §§ 501 y 512, alega infracción de copyright y pide retirar el contenido en disputa y confirmar el cumplimiento antes del 28 de noviembre de 2026. El PDF contiene texto seleccionable, así que podemos usar nuestra utilidad read_pdf(). Este es el código:

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

Markdown(
    analyze_notice(text=pdf_text)
)

Esto extrae el contenido del PDF y envía el texto resultante al mismo agente.

Salida:

Salida del analizador para la carta de cese y desistimiento en PDF

Figura 5: Salida del analizador para la carta de cese y desistimiento.

El agente distingue correctamente una reclamación legal privada de un aviso oficial de gobierno o tribunal. Reconoce que no se exige dinero y ajusta sus recomendaciones. La herramienta de investigación recuperó una página relevante de la Oficina de Copyright de EE. UU., que aparece en las fuentes finales.

Qué demuestra esta prueba: El mismo agente puede manejar correspondencia en PDF, identificar la naturaleza de una reclamación legal y recomendar los siguientes pasos adecuados.

Mi experiencia con Qwen4-Max: lo bueno, lo malo y lo mejorable

Tras usar Qwen4-Max para este proyecto, otras aplicaciones agenticas y vibe coding, este es mi balance honesto.

Lo bueno

El ecosistema Qwen cubre mucho terreno. Incluye reconocimiento y síntesis de voz, búsqueda y scraping web, y un toolkit de código abierto para crear aplicaciones agenticas sin implementarlo todo desde cero.

Lo que más me gustó fue lo bien que Qwen4-Max siguió instrucciones detalladas. En general respetó la estructura pedida, extrajo fechas de documentos y produjo resúmenes precisos en mis pruebas.

Destaca su comprensión de imágenes. Le pasé la foto de un aviso legal y leyó el contenido sin un pipeline extra de OCR, lo que ayuda mucho en aplicaciones agenticas centradas en documentos.

Lo malo

La velocidad fue el mayor problema. Qwen4-Max no fue mi modelo preferido para vibe coding: comparado con DeepSeek V4.1 Flash y otros modelos que probé, a menudo tardaba claramente más en terminar tareas sencillas.

Vi con frecuencia velocidades de generación de unos 100 tokens por segundo, pero ese número oculta el coste real. El modelo dedicaba mucho tiempo a razonar sobre cambios triviales, y a veces pedía un ajuste simple y la espera era mucho mayor de lo esperado.

Si quieres probar la opción más rápida, la cubrimos en nuestro tutorial de la API de DeepSeek V4.1 Flash.

Lo mejorable

La búsqueda web nativa fue lo más frustrante. En mis pruebas, los tiempos de respuesta eran irregulares: la misma consulta podía devolver en segundos o tardar cerca de un minuto, y algunas peticiones superaban los 400 segundos sin completarse.

Tres ejecuciones de mi flujo de investigación tardaron casi 16 minutos. No fue lo bastante fiable para una aplicación que depende de información legal externa.

Sustituir la búsqueda nativa por Olostep se volvió imprescindible, lo que también significó que no podía depender por completo del ecosistema Qwen, como había planeado al principio.

Tuve otro problema al experimentar con DeepSeek Harness. Hice una pregunta sencilla sobre investigar el mercado bursátil y el flujo pasó mucho tiempo en la solicitud antes de devolver un error. Frustrante para una tarea tan simple.

En conjunto, Qwen4-Max tiene capacidades impresionantes, pero su sobrecarga de razonamiento y la búsqueda nativa inconsistente conviene valorarlas antes de montar flujos de producción a su alrededor. Si quieres seguir construyendo con modelos Qwen, nuestro tutorial de la API de Qwen 3.7 Max recorre un agente de productividad con auto-revisión.

Abid Ali Awan

Autor

Abid Ali Awan

Soy un científico de datos certificado que disfruta creando aplicaciones de aprendizaje automático y escribiendo blogs sobre ciencia de datos. Actualmente me centro en la creación de contenidos, la edición y el trabajo con grandes modelos lingüísticos.

Temas