Accéder au contenu principal

Tutoriel Qwen4-Max : créer un analyseur d’avis juridiques

Créez un analyseur d’avis juridiques américains avec Qwen4-Max, Qwen-Agent et Olostep. Détectez les arnaques, lisez des photos et des PDF, et vérifiez les affirmations auprès de sources officielles.
· 12 min lire

Explorez l'IA

Avez-vous déjà reçu un courrier d’une administration et hésité sur sa légitimité, sur la nécessité d’y répondre, ou craint une tentative d’arnaque ?

Les avis juridiques sont difficiles à lire, surtout quand un langage complexe se mêle à des demandes de paiement et des délais. Les fraudeurs exploitent cette confusion en se faisant passer pour des agences gouvernementales et en créant un sentiment d’urgence artificiel.

Dans ce tutoriel, nous allons créer un analyseur d’avis juridiques américains avec Qwen4-Max et le framework Qwen-Agent. L’application accepte du texte, des images et des PDF, signale les tactiques de paiement suspectes et interroge des ressources juridiques officielles lorsqu’une vérification est nécessaire.

Plutôt que de tout confier à un grand modèle de langage (LLM), nous l’associerons à deux outils Python. Le premier utilise des expressions régulières pour repérer des indices d’arnaque courants. Le second s’appuie sur Olostep pour rechercher sur des sites gouvernementaux officiels et le Cornell Legal Information Institute (LII).

En bref

  • Nous construisons un analyseur d’avis juridiques avec Qwen4-Max, Qwen-Agent et Olostep qui accepte du texte, des photos et des PDF.
  • Un filtre de risque basé sur des regex signale les schémas d’arnaque et les domaines d’imitation avant toute recherche par le modèle.
  • Un outil de recherche limite les consultations aux sites en .gov et au Cornell LII, et l’agent saute la recherche quand un avis est manifestement frauduleux.
  • Lors de mes tests, Qwen4-Max a bien lu des avis photographiés, mais s’est montré lent sur des tâches simples et sa recherche web native était peu fiable.

Qu’est-ce que Qwen4-Max ?

Qwen4-Max est le modèle phare d’Alibaba dans la famille Qwen4, lancé le 16 novembre 2026. C’est un modèle MoE (mixture-of-experts) parcimonieux avec des améliorations d’architecture, une vision native et une fenêtre de contexte élargie, conçu pour le raisonnement complexe et les applications agentiques.

Voici les fonctionnalités les plus pertinentes pour notre projet :

  • Architecture MoE parcimonieuse : Qwen4-Max dispose de 2,4 T de paramètres de base, 71 B actifs par jeton, et 328 B supplémentaires pour les embeddings N-gram. Les couches Gated DeltaNet et la Qwen Sparse Attention réduisent le coût des longs contextes.
  • Vision native : Le modèle lit les images directement, nous pouvons donc envoyer la photo d’un avis juridique sans mettre en place un pipeline OCR séparé.
  • Fenêtre de contexte d’un million de tokens : Suffisante pour de longs documents et beaucoup d’informations de support.
  • Meilleure efficacité de tokens : Selon Alibaba, Qwen4-Max utilise environ 35 % de tokens en moins que Qwen3.8-Max sur Work360 avec un effort de raisonnement élevé, et environ 49 % de moins sur Terminal-Bench 4.0. À l’effort Xhigh, les réductions sont d’environ 24 % et 48 %.
  • Coûts de tâche plus faibles : Sur Work360, Qwen4-Max a obtenu 52,69, contre 47,74 pour Qwen3.8-Max, tandis que le coût moyen par tâche est passé de 4,43 $ à 1,67 $, soit une baisse de 62 %.

Voici les résultats de benchmark de l’annonce d’Alibaba, montrant Qwen4-Max en progrès par rapport à Qwen3.8-Max sur presque toutes les capacités évaluées par Alibaba :

Comparatif de benchmarks d’Alibaba entre Qwen4-Max et d’autres modèles sur des tâches de code, de travail et de long horizon

Figure 1 : Résultats de benchmark de Qwen4-Max. Image issue de : Qwen, Qwen4-Max: Your New Teammate Has Arrived.

Comment fonctionne l’analyseur d’avis juridiques ?

L’analyseur est un unique assistant Qwen-Agent qui orchestre deux outils Python, tandis que Qwen4-Max gère la compréhension de document et le raisonnement. Avant d’écrire du code, regardons le flux de travail.

Schéma du flux de l’analyseur d’avis juridiques, de l’entrée de l’avis jusqu’au filtre de risque et à la recherche juridique, puis à la réponse finale

Figure 2 : Le flux de l’analyseur d’avis juridiques.

Le flux compte 6 étapes :

  1. L’utilisateur soumet un avis en texte, image ou PDF.
  2. Qwen4-Max lit le document et en identifie le contenu principal.
  3. L’agent appelle risk_gate pour vérifier les instructions de paiement suspectes, les menaces et les liens.
  4. Si le document est manifestement frauduleux, l’agent saute la recherche externe.
  5. Sinon, l’agent appelle lookup_law pour rechercher dans des ressources juridiques officielles.
  6. Qwen4-Max produit une réponse structurée avec un verdict, un résumé, des éléments probants et les prochaines étapes recommandées.

Le choix de conception clé est que le LLM ne fait pas tout. Python gère les vérifications déterministes, Olostep la recherche externe, et Qwen4-Max la compréhension et le raisonnement sur les documents.

Cela garde le flux simple tout en dotant l’agent de l’outil adapté à chaque tâche. Si la terminologie des agents est nouvelle pour vous, notre cours Introduction to AI Agents couvre les fondamentaux sans coder.

1. Configuration de l’environnement

Nous utiliserons Jupyter Notebook, QwenCloud pour l’accès au modèle, et Olostep pour la recherche et l’extraction web.

Commencez par créer un compte sur QwenCloud, ajoutez des crédits ou abonnez-vous à un Token Plan, puis générez une clé API depuis le tableau de bord. QwenCloud fournit un endpoint API selon la région choisie.

Vous aurez également besoin d’une clé API Olostep pour la recherche juridique.

Définissez vos variables d’environnement dans le terminal avant de lancer Jupyter Notebook. Vous pouvez aussi les définir dans le notebook avec 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"

J’utilise l’endpoint Token Plan, qui offre un accès à prix réduit aux modèles. Si vous payez à l’usage, utilisez l’endpoint indiqué par QwenCloud pour votre région.

Ensuite, installez les dépendances requises dans votre notebook :

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

Le supplément rag ajoute des packages de traitement de documents comme pdfplumber, que nous utiliserons pour lire des PDF. En version 0.0.34, Qwen-Agent importe aussi soundfile et tqdm au démarrage sans les déclarer en dépendances, donc nous les installons explicitement.

Configurer Qwen4-Max

Initialisons maintenant le modèle et le client Olostep. J’utilise la région Singapour, qui propose également un Token Plan.

import logging
import os
import re
import warnings

# Le SDK Olostep lit ceci à l'import, donc définissez-le d'abord
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"])

Cela configure Qwen4-Max pour l’entrée multimodale, définit un niveau d’effort de raisonnement et initialise le client de recherche. Notez que OLOSTEP_API_TIMEOUT est défini avant l’import, car le SDK le lit au chargement.

Quelques options de configuration à connaître :

  • model spécifie le modèle à utiliser.
  • model_type nous permet d’envoyer des images via l’interface multimodale compatible OpenAI.
  • model_server pointe vers l’endpoint défini par QWEN_BASE_URL.
  • max_tokens limite la longueur de la réponse générée.
  • reasoning_effort contrôle l’ampleur du raisonnement du modèle. Nous utilisons low pour des réponses rapides.
  • OLOSTEP_API_TIMEOUT fixe une limite de temps, en secondes, pour les requêtes de recherche.

Créer des helpers réutilisables pour l’agent

Nous traiterons à la fois des entrées texte et image, créons donc une fonction réutilisable pour exécuter l’agent.

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

Cette fonction envoie l’invite et, le cas échéant, les images à Qwen-Agent, attend la réponse finale et en extrait le texte généré.

Nous avons aussi besoin d’un helper pour lire les 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
        )

Cette fonction extrait le texte sélectionnable de chaque page du PDF et le concatène en une seule chaîne.

Remarque : pdfplumber ne fait pas d’OCR. Pour les PDF scannés ne contenant que des images, rendez chaque page sous forme d’image et envoyez-la directement à Qwen4-Max.

2. Détecter les arnaques avec un filtre de risque

Le premier outil personnalisé identifie les comportements suspects. Plutôt que de demander au LLM de reconnaître toutes les instructions de paiement douteuses, nous pouvons utiliser des expressions régulières pour détecter des tactiques connues.

C’est plus rapide, déterministe et n’utilise aucun jeton du modèle. Si vous souhaitez réviser la syntaxe, notre cours Regular Expressions in Python la couvre.

Définir les règles de détection

Commençons par une liste d’expressions régulières et une correspondance entre des agences gouvernementales et leurs domaines officiels.

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

Ce code définit les indicateurs d’arnaque et associe des noms d’agences aux domaines qu’elles utilisent réellement. Par exemple, si un avis mentionne l’IRS, l’application vérifie ses liens par rapport à irs.gov.

Extraire et valider les domaines

Ensuite, nous avons besoin d’un helper qui extrait le nom d’hôte d’une 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)

On extrait le nom d’hôte et on vérifie s’il s’agit du domaine officiel ou d’un sous-domaine légitime. La nuance est importante : un simple endswith() accepterait fakeirs.gov comme site de l’IRS.

Implémenter l’outil de filtre de risque

Nous pouvons maintenant combiner ces règles dans un outil personnalisé 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"

Cet outil scanne l’avis pour trouver des correspondances, vérifie ses URL par rapport au domaine officiel de l’agence et renvoie les indicateurs suspects. Les noms d’agences sont recherchés comme des mots entiers, ainsi « irs » ne déclenche pas sur un mot comme « first ».

Par exemple, notre faux avis de l’IRS du Test 1 renvoie :

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’agent reçoit ces résultats dans son contexte et les utilise pour déterminer si l’avis est suspect.

3. Créer l’outil de recherche juridique

Notre second outil gère la recherche externe. Nous ne voulons pas que l’agent fouille des sites aléatoires, des forums ou des blogs de cabinets et traite tout ce qu’il trouve comme autorité.

À la place, nous limitons la recherche aux sites officiels du gouvernement américain et au Cornell LII. Nous utilisons Olostep car il peut rechercher et extraire plusieurs résultats en une seule requête. Si vous souhaitez comparer avec une autre option, consultez notre tutoriel Firecrawl.

Définir les restrictions de recherche

Définissons d’abord les sources autorisées et quelques limites sur ce que nous récupérons.

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


MAX_PAGES = 2
PAGE_CHARS = 3000

La fonction is_allowed_host() accepte les sites en .gov et le Cornell LII. Elle réutilise is_official_domain(), ainsi un imitateur comme fakelaw.cornell.edu est rejeté. Nous conservons au plus 2 pages, avec un maximum de 3 000 caractères par page.

Implémenter l’outil LookupLaw

Créons maintenant le deuxième outil personnalisé.

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

Cet outil envoie une requête de recherche à Olostep, filtre les résultats, extrait le contenu des pages et renvoie à Qwen4-Max les extraits retenus.

Trois points d’implémentation à noter :

  • Nous récupérons jusqu’à 5 résultats de recherche mais conservons au plus 2 pages qualifiées.
  • Nous privilégions le Markdown extrait et, à défaut, la description de la page.
  • Nous stockons les URL récupérées dans self.sources afin que l’application puisse les afficher après l’analyse.

4. Construire l’agent avec Qwen-Agent et Qwen4-Max

Nous avons maintenant nos deux outils personnalisés : risk_gate identifie les signaux suspects, et lookup_law récupère des informations juridiques pertinentes. Créons l’agent qui les coordonne.

Un seul prompt système définit le flux, l’ordre des outils et le format de réponse. Qwen-Agent n’est pas la seule option pour ce type de projet, et notre cours Developing LLM Applications with LangChain présente un autre framework.

Définir le prompt système

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

Ce prompt définit les responsabilités de l’agent et l’empêche d’inventer des informations juridiques. Une consigne mérite une attention particulière : les délais.

Un avis frauduleux peut tout de même contenir un délai, donc l’agent doit rapporter ce que le document affirme tout en indiquant si ce délai est crédible.

Ajouter l’avertissement et la gestion des sources

Nous gardons l’avertissement en dehors du prompt système afin que Python l’ajoute systématiquement.

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

Cela nous fournit un message de repli lorsque la recherche n’obtient aucune source officielle, et chaque réponse inclut un avertissement juridique.

Créer la fonction principale d’analyse

Enfin, relions le tout dans une fonction réutilisable.

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

Cette fonction crée un agent neuf pour chaque document, exécute l’analyse, collecte les sources récupérées et renvoie la réponse finale. Nous instancions LookupLaw() à l’intérieur pour que chaque avis ait sa propre liste de sources.

5. Tester l’analyseur d’avis juridiques

Nous avons maintenant un analyseur opérationnel. Testons-le sur 3 documents :

  1. Une lettre d’arnaque fictive de l’IRS.
  2. La photographie d’un avis d’expulsion en Floride.
  3. Une lettre de mise en demeure au format PDF.

Chaque test sollicite une partie différente du flux.

Test 1 : une lettre d’arnaque de l’IRS

Notre premier exemple est une lettre d’arnaque fictive de l’IRS. Elle prétend que le destinataire doit 4 870 $ d’impôt fédéral sur le revenu et doit payer sous 24 heures.

Elle menace aussi d’arrestation, exige des paiements en cartes-cadeaux ou par virement, et inclut un site douteux. Voici l’entrée d’exemple :

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

Cela crée un avis fictif et le soumet à l’agent pour analyse.

Sortie :

Sortie de l’analyseur pour la fausse lettre d’arnaque de l’IRS

Figure 3 : Sortie de l’analyseur pour la lettre d’arnaque fictive de l’IRS.

Le scanner trouve plusieurs indicateurs suspects et l’agent saute la recherche externe. C’est l’effet recherché pour une arnaque évidente : l’application n’engage pas de jetons supplémentaires en recherche quand les vérifications déterministes pointent déjà vers la fraude.

Ce que démontre ce test : Le filtre de risque peut identifier des tactiques d’arnaque courantes et aider l’agent à éviter des recherches externes inutiles.

Test 2 : une photographie d’avis d’expulsion

Le second test met l’accent sur la vision native de Qwen4-Max. Au lieu d’extraire nous-mêmes le texte, nous envoyons directement au modèle la photo d’un avis d’expulsion.

Notre exemple est un avis de trois jours en Floride exigeant 1 850 $ de loyer impayé, ou la restitution du logement pour le 23 novembre 2026. Voici le code :

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

Cela envoie la photo directement à Qwen4-Max, sans pipeline OCR séparé. Pour un autre projet combinant la vision de Qwen et l’appel d’outils, consultez notre tutoriel Qwen 3.6 Plus API sur le traitement de factures.

Sortie :

Sortie de l’analyseur pour la photo de l’avis d’expulsion en Floride

Figure 4 : Sortie de l’analyseur pour l’avis d’expulsion photographié.

Le modèle a compris la photo, extrait le montant et l’échéance, et identifié le type d’avis. Il a signalé que la page juridique récupérée ne suffisait pas à vérifier le texte de loi, et il a repéré des champs de signature et de remise vides dans le document d’exemple.

Ce que démontre ce test : Qwen4-Max peut interpréter directement des documents juridiques photographiés, tandis que Qwen-Agent coordonne la recherche additionnelle et exprime les incertitudes.

Test 3 : une mise en demeure en PDF

Pour le dernier test, nous utilisons une lettre de mise en demeure de deux pages au format PDF.

Le document cite 17 U.S.C. §§ 501 et 512, allègue une violation de droits d’auteur et demande de retirer le contenu litigieux et de confirmer la conformité d’ici le 28 novembre 2026. Le PDF contient du texte sélectionnable, nous pouvons donc utiliser notre helper read_pdf(). Voici le code :

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

Markdown(
    analyze_notice(text=pdf_text)
)

Cela extrait le contenu du PDF et envoie le texte obtenu au même agent.

Sortie :

Sortie de l’analyseur pour la mise en demeure au format PDF

Figure 5 : Sortie de l’analyseur pour la mise en demeure.

L’agent distingue correctement une demande juridique privée d’un avis officiel émanant d’une administration ou d’un tribunal. Il reconnaît qu’aucun paiement n’est exigé et ajuste ses recommandations. L’outil de recherche a récupéré une page pertinente de l’US Copyright Office, affichée dans les sources finales.

Ce que démontre ce test : Le même agent peut traiter une correspondance PDF, identifier la nature d’une demande juridique et recommander les bonnes prochaines étapes.

Mon expérience avec Qwen4-Max : le pour, le contre et les limites

Après avoir utilisé Qwen4-Max pour ce projet, d’autres applications agentiques et du « vibe coding », voici mon avis honnête.

Les points forts

L’écosystème Qwen est très complet. Il inclut reconnaissance vocale, synthèse vocale, recherche web, scraping, et une boîte à outils open source pour créer des applications agentiques sans tout réimplémenter.

Ce que j’ai le plus apprécié est la qualité d’exécution des consignes détaillées par Qwen4-Max. Il a généralement respecté la structure attendue, extrait des dates et produit des résumés fiables lors de mes tests.

Sa compréhension d’images ressort du lot. Je lui ai donné la photo d’un avis juridique et il en a lu le contenu sans pipeline OCR supplémentaire, un vrai plus pour des applications agentiques orientées documents.

Les points faibles

La vitesse a été le plus gros écueil. Qwen4-Max n’a pas été mon modèle préféré pour le « vibe coding » : comparé à DeepSeek V4.1 Flash et d’autres modèles testés, il mettait souvent sensiblement plus de temps à terminer des tâches simples.

J’ai régulièrement observé des débits autour de 100 tokens par seconde, mais ce chiffre masque le coût réel. Le modèle passait longtemps à raisonner sur des modifications triviales, et il m’est arrivé d’attendre bien plus que prévu pour une simple retouche.

Si vous voulez essayer l’option plus rapide, nous la couvrons dans notre tutoriel DeepSeek V4.1 Flash API.

Les vrais soucis

La recherche web native a été la partie la plus frustrante. Durant mes tests, les temps de réponse étaient incohérents : une même requête pouvait revenir en quelques secondes ou prendre près d’une minute, et certaines dépassaient 400 secondes sans aboutir.

Trois exécutions de mon flux de recherche ont pris presque 16 minutes. Insuffisant pour une application qui dépend d’informations juridiques externes.

Remplacer la recherche native par Olostep est devenu indispensable, ce qui m’a aussi empêché de m’appuyer entièrement sur l’écosystème Qwen comme prévu au départ.

J’ai rencontré un autre problème en testant le DeepSeek Harness. J’ai posé une simple question sur la recherche boursière, et le flux a passé beaucoup de temps avant de renvoyer une erreur. Frustrant pour une tâche aussi simple.

Au global, Qwen4-Max offre des capacités impressionnantes, mais son surcoût de raisonnement et l’irrégularité de sa recherche native sont à considérer avant de bâtir des workflows de production autour. Si vous souhaitez continuer avec les modèles Qwen, notre tutoriel Qwen 3.7 Max API détaille un agent de productivité en auto-relecture.

Abid Ali Awan

Auteur

Abid Ali Awan

En tant que data scientist certifié, je suis passionné par l'utilisation des technologies de pointe pour créer des applications innovantes d'apprentissage automatique. Avec une solide expérience en reconnaissance vocale, en analyse de données et en reporting, en MLOps, en IA conversationnelle et en NLP, j'ai affiné mes compétences dans le développement de systèmes intelligents qui peuvent avoir un impact réel. En plus de mon expertise technique, je suis également un communicateur compétent, doué pour distiller des concepts complexes dans un langage clair et concis. En conséquence, je suis devenu un blogueur recherché dans le domaine de la science des données, partageant mes idées et mes expériences avec une communauté grandissante de professionnels des données. Actuellement, je me concentre sur la création et l'édition de contenu, en travaillant avec de grands modèles linguistiques pour développer un contenu puissant et attrayant qui peut aider les entreprises et les particuliers à tirer le meilleur parti de leurs données.

Sujets

Contenus associés