Zum Hauptinhalt springen

Qwen4-Max Tutorial: Baue einen Analyzer für amtliche Schreiben

Baue einen US-Notice-Analyzer mit Qwen4-Max, Qwen-Agent und Olostep. Decke Betrug auf, lies Fotos und PDFs, und prüfe Behauptungen gegen offizielle Quellen.
· 12 Min. lesen

Entdecke KI

Hast du schon einmal ein amtliches Schreiben bekommen und dich gefragt, ob es echt ist, ob du reagieren musst – oder ob dich jemand betrügen will?

Amtliche Schreiben sind oft schwer zu verstehen – erst recht, wenn komplizierte Formulierungen mit Zahlungsaufforderungen und kurzen Fristen vermischt werden. Betrüger nutzen diese Verwirrung aus, geben sich als Behörden aus und erzeugen künstlichen Zeitdruck.

In diesem Tutorial bauen wir einen US-Notice-Analyzer mit Qwen4-Max und dem Qwen-Agent-Framework. Die Anwendung akzeptiert Text, Bilder und PDFs, markiert verdächtige Zahlungstaktiken und durchsucht offizielle Rechtsquellen, wenn etwas verifiziert werden muss.

Statt uns komplett auf ein Large Language Model (LLM) zu verlassen, kombinieren wir es mit zwei Python-Tools. Das erste nutzt reguläre Ausdrücke, um typische Betrugsindikatoren zu erkennen. Das zweite verwendet Olostep, um auf offiziellen Regierungswebsites und beim Cornell Legal Information Institute (LII) zu recherchieren.

Kurz zusammengefasst

  • Wir bauen einen Analyzer für amtliche Schreiben mit Qwen4-Max, Qwen-Agent und Olostep, der Text, Fotos und PDFs akzeptiert.
  • Ein regex-basierter Risk Gate markiert Betrugsmuster und Lookalike-Domains, noch bevor das Modell recherchiert.
  • Ein Recherche-Tool beschränkt Treffer auf .gov-Seiten und Cornell LII; bei offensichtlichen Fälschungen überspringt der Agent die Recherche.
  • In meinen Tests hat Qwen4-Max abfotografierte Schreiben gut gelesen, war bei einfachen Aufgaben aber langsam und in der nativen Websuche unzuverlässig.

Was ist Qwen4-Max?

Qwen4-Max ist das Flaggschiffmodell von Alibaba in der Qwen4-Familie, veröffentlicht am 16. November 2026. Es ist ein sparsames Mixture-of-Experts-(MoE)-Modell mit Architekturverbesserungen, nativer Vision und großem Kontextfenster – ausgelegt für komplexes Reasoning und agentische Anwendungen.

Das sind die wichtigsten Features für unser Projekt:

  • Sparse-MoE-Architektur: Qwen4-Max hat 2,4T Backbone-Parameter, 71B aktive Parameter pro Token und zusätzliche 328B N-Gramm-Embedding-Parameter. Gated-DeltaNet-Schichten und Qwen Sparse Attention halten die Long-Context-Kosten niedrig.
  • Native Vision: Das Modell liest Bilder direkt. Wir können also ein Foto eines amtlichen Schreibens senden, ohne eine separate OCR-Pipeline zu bauen.
  • 1M-Token-Kontextfenster: Groß genug für lange Dokumente und umfangreiche Zusatzinformationen.
  • Höhere Tokeneffizienz: Laut Alibaba nutzt Qwen4-Max auf Work360 bei hoher Reasoning-Tiefe etwa 35 % weniger Tokens als Qwen3.8-Max und auf Terminal-Bench 4.0 etwa 49 % weniger. Bei Xhigh sind es ca. 24 % bzw. 48 % weniger.
  • Niedrigere Aufgabenkosten: Auf Work360 stieg der Score von 47,74 (Qwen3.8-Max) auf 52,69, während die Durchschnittskosten pro Aufgabe von $4,43 auf $1,67 sanken – eine Reduktion um 62 %.

Die folgenden Benchmark-Ergebnisse aus Alibabas Ankündigung zeigen, dass Qwen4-Max Qwen3.8-Max bei nahezu jeder von Alibaba bewerteten Fähigkeit übertrifft:

Alibabas Benchmark-Vergleich von Qwen4-Max und anderen Modellen für Coding-, Work- und Long-Horizon-Aufgaben

Abbildung 1: Qwen4-Max-Benchmark-Ergebnisse. Bildquelle: Qwen, Qwen4-Max: Your New Teammate Has Arrived.

Der Analyzer ist ein einzelner Qwen-Agent-Assistent, der zwei Python-Tools koordiniert, während Qwen4-Max das Dokumentenverständnis und das Reasoning übernimmt. Bevor wir Code schreiben, schauen wir uns den Workflow an.

Ablaufdiagramm des Legal-Notice-Analyzers: von der Eingabe über Risk Gate und Rechtsrecherche bis zur Antwort

Abbildung 2: Workflow des Legal-Notice-Analyzers.

Der Ablauf hat 6 Schritte:

  1. Die Nutzenden übermitteln das Schreiben als Text, Bild oder PDF.
  2. Qwen4-Max liest das Dokument und erkennt die Kernaussagen.
  3. Der Agent ruft risk_gate auf, um verdächtige Zahlungsanweisungen, Drohungen und Links zu prüfen.
  4. Ist das Dokument offensichtlich gefälscht, überspringt der Agent die externe Recherche.
  5. Andernfalls ruft der Agent lookup_law auf, um in offiziellen Rechtsquellen zu suchen.
  6. Qwen4-Max liefert eine strukturierte Antwort mit Urteil, Zusammenfassung, Belegen und empfohlenen nächsten Schritten.

Die zentrale Designentscheidung: Das LLM macht nicht alles. Python übernimmt deterministische Checks, Olostep die externe Recherche, und Qwen4-Max das Verständnis und Reasoning.

So bleibt der Workflow schlank, während der Agent für jede Aufgabe das passende Werkzeug hat. Ist Agenten-Terminologie neu für dich, deckt unser Kurs Introduction to AI Agents die Grundlagen ohne Coding ab.

1. Umgebung einrichten

Wir nutzen Jupyter Notebook, QwenCloud für den Modellzugang und Olostep für Websuche und Scraping.

Lege zuerst ein Konto bei QwenCloud an, lade Guthaben auf oder abonniere einen Token-Plan und generiere im Dashboard einen API-Schlüssel. QwenCloud stellt je nach Region ein API-Endpoint bereit.

Für die Rechtsrecherche brauchst du außerdem einen Olostep-API-Schlüssel.

Setze deine Umgebungsvariablen im Terminal, bevor du Jupyter Notebook startest. Alternativ kannst du sie im Notebook mit os.environ setzen.

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"

Ich nutze das Token-Plan-Endpoint, das vergünstigten Zugriff bietet. Wenn du nutzungsbasiert zahlst, verwende stattdessen das für deine Region angezeigte Endpoint.

Installiere als Nächstes die benötigten Abhängigkeiten im Notebook:

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

Das Extra rag bringt Dokumenten-Tools wie pdfplumber mit, das wir zum Lesen von PDFs nutzen. Ab Version 0.0.34 importiert Qwen-Agent beim Start außerdem soundfile und tqdm, ohne sie als Dependencies zu deklarieren – daher installieren wir beide explizit.

Qwen4-Max konfigurieren

Als Nächstes initialisieren wir das Modell und den Olostep-Client. Ich nutze die Region Singapur, die ebenfalls einen Token-Plan anbietet.

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

Diese Konfiguration aktiviert multimodale Eingaben, setzt den Reasoning-Aufwand und initialisiert den Recherche-Client. Beachte, dass OLOSTEP_API_TIMEOUT vor dem Import gesetzt wird, weil das SDK die Variable beim Laden ausliest.

Einige Optionen sind wichtig zu verstehen:

  • model legt das gewünschte Modell fest.
  • model_type erlaubt uns, Bilder über die OpenAI-kompatible Multimodal-Schnittstelle zu senden.
  • model_server zeigt auf das Endpoint aus QWEN_BASE_URL.
  • max_tokens begrenzt die Länge der generierten Antwort.
  • reasoning_effort steuert die Reasoning-Tiefe. Wir verwenden low für schnelle Antworten.
  • OLOSTEP_API_TIMEOUT setzt ein Zeitlimit in Sekunden für Rechercheanfragen.

Wiederverwendbare Agent-Helfer erstellen

Wir verarbeiten Text- und Bildeingaben. Erstellen wir dafür eine wiederverwendbare Funktion zum Ausführen des Agents.

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

Diese Funktion sendet Prompt und optionale Bilder an Qwen-Agent, wartet auf die finale Antwort und extrahiert den erzeugten Text.

Wir brauchen außerdem einen Helfer zum Lesen von 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
        )

Diese Funktion extrahiert auswählbaren Text aus allen PDF-Seiten und fügt ihn zu einem String zusammen.

Hinweis: pdfplumber führt kein OCR durch. Für gescannte PDFs, die nur Bilder enthalten, rendere jede Seite als Bild und sende sie direkt an Qwen4-Max.

2. Betrugserkennung mit einem Risk Gate

Das erste Custom-Tool identifiziert verdächtiges Verhalten. Statt das LLM jede suspekte Zahlungsanweisung erkennen zu lassen, nutzen wir reguläre Ausdrücke, um bekannte Betrugstaktiken zu detektieren.

Das ist schneller, deterministisch und verbraucht keine Modell-Tokens. Wenn du eine Auffrischung zur Syntax brauchst, deckt unser Kurs Regular Expressions in Python das Thema ab.

Regeln für die Betrugserkennung definieren

Starten wir mit einer Liste regulärer Ausdrücke und einer Zuordnung zwischen Behörden und ihren offiziellen Domains.

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

Dieser Code definiert Betrugsindikatoren und ordnet Behördennamen den Domains zu, die diese Behörden tatsächlich nutzen. Wenn ein Schreiben z. B. den IRS erwähnt, prüft die Anwendung seine Links gegen irs.gov.

Domains extrahieren und validieren

Als Nächstes brauchen wir einen Helfer, der den Hostnamen aus einer URL extrahiert.

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)

Das extrahiert den Hostnamen und prüft, ob es sich um die offizielle Domain oder eine legitime Subdomain handelt. Das ist wichtig: Ein simples endswith() würde fakeirs.gov als IRS-Website durchwinken.

Das Risk-Gate-Tool implementieren

Jetzt kombinieren wir die Regeln zu einem eigenen Qwen-Agent-Tool.

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"

Dieses Tool scannt das Schreiben nach Mustern, prüft URLs gegen die offizielle Domain der Behörde und gibt verdächtige Indikatoren zurück. Behördennamen werden als ganze Wörter gematcht, damit „irs“ nicht in „first“ auslöst.

Unser fiktives IRS-Schreiben aus Test 1 ergibt zum Beispiel:

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

Der Agent erhält diese Ergebnisse im Kontext und bezieht sie in die Bewertung der Seriosität ein.

3. Das Rechtsrecherche-Tool erstellen

Unser zweites Tool übernimmt die externe Recherche. Wir wollen nicht, dass der Agent beliebige Websites, Foren oder Kanzlei-Blogs durchsucht und alles als autoritativ behandelt.

Stattdessen beschränken wir die Recherche auf offizielle US-Regierungswebsites und das Cornell LII. Wir nutzen Olostep, weil es mehrere Ergebnisse in einem Request suchen und scrapen kann. Wenn du eine Alternative vergleichen willst, sieh dir unser Firecrawl-Tutorial an.

Recherchebeschränkungen definieren

Definieren wir zuerst erlaubte Quellen und Abrufgrenzen.

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


MAX_PAGES = 2
PAGE_CHARS = 3000

Die Funktion is_allowed_host() akzeptiert .gov-Seiten und Cornell LII. Sie nutzt is_official_domain() wieder, sodass Lookalikes wie fakelaw.cornell.edu abgelehnt werden. Außerdem behalten wir maximal 2 Seiten mit je höchstens 3.000 Zeichen.

Das Tool LookupLaw implementieren

Jetzt erstellen wir das zweite Custom-Tool.

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

Dieses Tool sendet eine Suchanfrage an Olostep, filtert die Ergebnisse, extrahiert Seiteninhalte und gibt die ausgewählten Auszüge an Qwen4-Max zurück.

Drei Umsetzungsdetails sind wichtig:

  • Wir holen bis zu 5 Suchtreffer, behalten aber höchstens 2 qualifizierte Seiten.
  • Wir bevorzugen gescraptes Markdown und greifen ersatzweise auf die Seitenbeschreibung zurück.
  • Wir speichern die abgerufenen URLs in self.sources, damit die Anwendung sie nach der Analyse anzeigen kann.

4. Den Agenten mit Qwen-Agent und Qwen4-Max bauen

Wir haben nun beide Custom-Tools: risk_gate erkennt verdächtiges Verhalten, und lookup_law holt relevante Rechtsinformationen. Als Nächstes erstellen wir den Agenten, der beides koordiniert.

Ein einzelner System-Prompt definiert Workflow, Tool-Reihenfolge und Antwortformat. Qwen-Agent ist nicht die einzige Option dafür; unser Kurs Developing LLM Applications with LangChain zeigt ein anderes Framework.

Den System-Prompt definieren

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

Dieser Prompt definiert die Verantwortung des Agents und verhindert, dass er Rechtsinformationen erfindet. Ein Punkt verdient besondere Beachtung: Fristen.

Auch ein betrügerisches Schreiben kann eine Frist enthalten. Der Agent muss daher berichten, was das Dokument behauptet, und zugleich bewerten, wie glaubwürdig diese Frist ist.

Disclaimer und Quellenhandling ergänzen

Wir halten den Disclaimer außerhalb des System-Prompts, damit Python ihn konsistent anhängen kann.

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

So haben wir eine Fallback-Meldung, wenn keine offizielle Quelle gefunden wird, und jeder Output enthält einen rechtlichen Hinweis.

Die Hauptfunktion für die Analyse erstellen

Zum Schluss verbinden wir alles in einer wiederverwendbaren Funktion.

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

Diese Funktion erstellt für jedes Dokument einen frischen Agenten, führt die Analyse aus, sammelt die Quellen und gibt die finale Antwort zurück. Wir instanziieren LookupLaw() in der Funktion, damit jedes Schreiben seine eigene Quellenliste hat.

Wir haben jetzt einen funktionsfähigen Analyzer. Testen wir ihn an 3 Beispieldokumenten:

  1. Ein fiktiver IRS-Betrugsbrief.
  2. Ein Foto einer Räumungsmitteilung aus Florida.
  3. Ein PDF mit einer Unterlassungsaufforderung (Cease and Desist).

Jeder Test adressiert einen anderen Teil des Workflows.

Test 1: Ein IRS-Betrugsbrief

Unser erstes Beispiel ist ein fiktiver IRS-Betrugsbrief. Er behauptet, die empfangende Person schulde $4.870 an Einkommensteuer und müsse innerhalb von 24 Stunden zahlen.

Außerdem droht er mit Verhaftung, fordert Geschenkkarten oder eine Überweisung und enthält eine verdächtige Website. Hier ist die Beispiel-Eingabe:

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

Das erzeugt ein fiktives Schreiben und schickt es zur Analyse an den Agenten.

Ausgabe:

Ausgabe des Legal-Notice-Analyzers für den fiktiven IRS-Betrugsbrief

Abbildung 3: Ausgabe des Analyzers für den fiktiven IRS-Betrugsbrief.

Der Scanner findet mehrere verdächtige Indikatoren, und der Agent überspringt die externe Rechtsrecherche. Genau das wünschen wir uns bei einem offensichtlichen Betrug: Die Anwendung verbraucht keine zusätzlichen Tokens, wenn die deterministischen Checks bereits auf Betrug hindeuten.

Was dieser Test zeigt: Der Risk Gate erkennt gängige Betrugstaktiken und hilft dem Agenten, unnötige externe Recherche zu vermeiden.

Test 2: Ein Foto einer Räumungsmitteilung

Der zweite Test fokussiert Qwen4-Max’ native Vision. Statt den Text selbst zu extrahieren, senden wir ein Foto der Mitteilung direkt an das Modell.

Unser Beispiel ist eine Florida-Three-Day-Notice mit $1.850 Mietrückstand oder Besitzübergabe bis zum 23. November 2026. Der Code sieht so aus:

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

Das Foto geht direkt an Qwen4-Max; eine separate OCR-Pipeline ist nicht nötig. Ein weiteres Build, das Qwens Vision mit Toolaufrufen kombiniert, findest du in unserem Qwen 3.6 Plus API Tutorial zur Rechnungsverarbeitung.

Ausgabe:

Ausgabe des Legal-Notice-Analyzers für die abfotografierte Räumungsmitteilung aus Florida

Abbildung 4: Ausgabe des Analyzers für die fotografierte Räumungsmitteilung.

Das Modell hat das Foto verstanden, Betrag und Frist extrahiert und die Art der Mitteilung erkannt. Es hat klargestellt, dass die gefundene Rechtsseite die Norm nicht ausreichend verifiziert, und leere Unterschrifts- und Zustellfelder im Beleg erkannt.

Was dieser Test zeigt: Qwen4-Max kann abfotografierte Rechtsdokumente direkt interpretieren, während Qwen-Agent zusätzliche Recherche koordiniert und Unsicherheit transparent macht.

Test 3: Ein PDF mit Unterlassungsaufforderung

Im letzten Test nutzen wir ein zweiseitiges PDF mit einer Unterlassungsaufforderung (Cease and Desist).

Das Dokument zitiert 17 U.S.C. §§ 501 und 512, behauptet eine Urheberrechtsverletzung und fordert die Entfernung des strittigen Inhalts sowie eine Bestätigung bis zum 28. November 2026. Das PDF enthält auswählbaren Text, daher nutzen wir unseren Helfer read_pdf(). Hier der Code:

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

Markdown(
    analyze_notice(text=pdf_text)
)

Das extrahiert den PDF-Inhalt und sendet den Text an denselben Agenten.

Ausgabe:

Ausgabe des Legal-Notice-Analyzers für die PDF-Unterlassungsaufforderung

Abbildung 5: Ausgabe des Analyzers für die Unterlassungsaufforderung.

Der Agent unterscheidet korrekt zwischen einer privaten rechtlichen Forderung und einer amtlichen oder gerichtlichen Mitteilung. Er erkennt, dass kein Geld verlangt wird, und passt die Empfehlungen an. Das Recherche-Tool hat eine relevante Seite des US Copyright Office gefunden, die in den Quellen erscheint.

Was dieser Test zeigt: Derselbe Agent kann PDF-Korrespondenz verarbeiten, die Art einer Forderung erkennen und passende nächste Schritte empfehlen.

Meine Erfahrungen mit Qwen4-Max: Licht und Schatten

Nach der Nutzung von Qwen4-Max für dieses Projekt, weitere agentische Anwendungen und Vibe Coding hier mein ehrliches Fazit.

Die Stärken

Das Qwen-Ökosystem deckt viel ab: Speech-to-Text, Text-to-Speech, Websuche, Webscraping und ein Open-Source-Toolkit, um agentische Anwendungen ohne kompletten Neuaufbau umzusetzen.

Am meisten hat mir gefallen, wie gut Qwen4-Max detaillierten Anweisungen folgt. In meinen Tests hielt es sich meist an die gewünschte Struktur, extrahierte Daten korrekt und lieferte präzise Zusammenfassungen.

Die Bildverständnisleistung stach heraus. Ich habe ein Foto eines amtlichen Schreibens übergeben, und das Modell las den Inhalt ohne zusätzliche OCR-Pipeline – ein großer Vorteil für dokumentenlastige Agenten.

Die Schwächen

Die Geschwindigkeit war mein größtes Problem. Für Vibe Coding war Qwen4-Max nicht mein bevorzugtes Modell: Im Vergleich zu DeepSeek V4.1 Flash und anderen Modellen dauerte es bei einfachen Aufgaben spürbar länger.

Ich sah regelmäßig Generierungsgeschwindigkeiten um 100 Tokens pro Sekunde, aber das verschleiert die eigentlichen Kosten. Das Modell verbrachte viel Zeit mit Reasoning über einfache Änderungen. Manchmal bat ich um eine kleine Anpassung und wartete deutlich länger als erwartet.

Wenn du die schnellere Option selbst testen willst, behandeln wir sie im DeepSeek V4.1 Flash API Tutorial.

Die Problemzonen

Die native Websuche war am frustrierendsten. In meinen Tests waren die Antwortzeiten inkonsistent: Dieselbe Anfrage kam teils in Sekunden zurück oder dauerte fast eine Minute, manche Requests liefen über 400 Sekunden ohne Abschluss.

Drei Durchläufe meines Recherche-Workflows brauchten fast 16 Minuten. Das ist zu unzuverlässig für eine Anwendung, die von externer Rechtsinformation abhängt.

Die native Suche durch Olostep zu ersetzen, war notwendig. Das bedeutete aber auch, dass ich mich nicht vollständig auf das Qwen-Ökosystem stützen konnte, wie ursprünglich geplant.

Ein weiteres Problem trat beim Experimentieren mit dem DeepSeek Harness auf. Ich stellte eine einfache Frage zur Aktienmarktrecherche, und der Workflow brauchte sehr lange, bevor er mit einem Fehler endete. Das war für eine so simple Aufgabe frustrierend.

Unterm Strich hat Qwen4-Max beeindruckende Fähigkeiten, aber der Reasoning-Overhead und die inkonsistente native Suche sollten bedacht werden, bevor du produktive Workflows darum baust. Wenn du weiter mit Qwen-Modellen entwickeln willst, zeigt unser Qwen 3.7 Max API Tutorial einen selbstprüfenden Produktivitätsagenten.

Abid Ali Awan

Autor

Abid Ali Awan

Als zertifizierter Data Scientist ist es meine Leidenschaft, modernste Technologien zu nutzen, um innovative Machine Learning-Anwendungen zu entwickeln. Mit meinem fundierten Hintergrund in den Bereichen Spracherkennung, Datenanalyse und Reporting, MLOps, KI und NLP habe ich meine Fähigkeiten bei der Entwicklung intelligenter Systeme verfeinert, die wirklich etwas bewirken können. Neben meinem technischen Fachwissen bin ich auch ein geschickter Kommunikator mit dem Talent, komplexe Konzepte in eine klare und prägnante Sprache zu fassen. Das hat dazu geführt, dass ich ein gefragter Blogger zum Thema Datenwissenschaft geworden bin und meine Erkenntnisse und Erfahrungen mit einer wachsenden Gemeinschaft von Datenexperten teile. Zurzeit konzentriere ich mich auf die Erstellung und Bearbeitung von Inhalten und arbeite mit großen Sprachmodellen, um aussagekräftige und ansprechende Inhalte zu entwickeln, die sowohl Unternehmen als auch Privatpersonen helfen, das Beste aus ihren Daten zu machen.

Themen

Ähnlich

Tutorial

OLS-Regression: Die wichtigsten Ideen erklärt