Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Cas d'utilisation avancés

Lekcija 10 od 12 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Au-delà des exemples simples
  2. Extraction d’une facture
  3. Analyse des avis aspect par aspect
  4. Classification de texte dans plusieurs catégories
  5. Factorisation de l’appel
  6. Ključne točke

Au-delà des exemples simples

Tu maîtrises désormais Pydantic, Zod et client.chat.parse(). Les trois cas suivants vont au-delà des schémas simples à quatre champs pour aborder des scénarios que tu rencontreras en environnement d’entreprise : documents comptables, analyse détaillée d’avis clients et textes appartenant simultanément à plusieurs catégories. Chacun illustre une technique de modélisation différente.

Extraction d’une facture

Le traitement de documents est le terrain de prédilection des schémas imbriqués. Une facture n’est pas un objet plat : elle contient un en-tête, un pied de page avec les totaux et un nombre variable de lignes de détail ayant leur propre structure. Nous modélisons donc LineItem séparément, puis nous y faisons référence au sein d’une liste. La devise utilise une énumération, ce qui empêche le modèle de renvoyer "euros" ou "€" selon la formulation du document.

from pydantic import BaseModel, Field
from typing import Optional
from enum import Enum

class Currency(str, Enum):
    eur = "EUR"
    usd = "USD"
    gbp = "GBP"

class LineItem(BaseModel):
    description: str = Field(description="Line item description")
    quantity: float = Field(description="Quantity")
    unit_price: float = Field(description="Unit price excluding tax")
    vat_rate: float = Field(description="VAT rate as a percentage (e.g., 20.0)")
    total_ht: float = Field(description="Line total excluding tax")

class InvoiceData(BaseModel):
    invoice_number: str = Field(description="Invoice number")
    date: str = Field(description="Invoice date in YYYY-MM-DD format")
    due_date: Optional[str] = Field(default=None, description="Due date")
    vendor_name: str = Field(description="Vendor name")
    vendor_address: Optional[str] = Field(default=None)
    client_name: str = Field(description="Client name")
    line_items: list[LineItem] = Field(description="Invoice line items")
    subtotal_ht: float = Field(description="Subtotal excluding tax")
    total_vat: float = Field(description="Total VAT amount")
    total_ttc: float = Field(description="Total including tax")
    currency: Currency = Field(description="Currency")
    payment_method: Optional[str] = Field(default=None)

# Extraction
response = client.chat.parse(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": """You are an accounting expert. Extract data from the invoice.
Be precise with amounts. Calculate totals if necessary.
Dates must be in YYYY-MM-DD format."""
        },
        {"role": "user", "content": invoice_text}
    ],
    response_format=InvoiceData,
    temperature=0
)

invoice = response.choices[0].message.parsed
print(f"Invoice {invoice.invoice_number} — {invoice.vendor_name}")
print(f"Total incl. tax: {invoice.total_ttc} {invoice.currency.value}")
for item in invoice.line_items:
    print(f"  - {item.description}: {item.quantity} x {item.unit_price}€ = {item.total_ht}€ excl. tax")

Le format de date imposé dans l’instruction système n’est pas un détail mineur : sans cela, un document français pourrait produire 12/03/2026 tandis qu’un document américain donnerait 03/12/2026, créant deux chaînes indistinguables pour ta base de données. La version TypeScript suit la même architecture, le format étant documenté via .describe().

import { z } from "zod";

const LineItemSchema = z.object({
  description: z.string(),
  quantity: z.number(),
  unitPrice: z.number().describe("Unit price excluding tax"),
  vatRate: z.number().describe("VAT rate in %"),
  totalHt: z.number(),
});

const InvoiceSchema = z.object({
  invoiceNumber: z.string(),
  date: z.string().describe("Format YYYY-MM-DD"),
  dueDate: z.string().nullable(),
  vendorName: z.string(),
  clientName: z.string(),
  lineItems: z.array(LineItemSchema),
  subtotalHt: z.number(),
  totalVat: z.number(),
  totalTtc: z.number(),
  currency: z.enum(["EUR", "USD", "GBP"]),
});

const response = await client.chat.parse({
  model: "mistral-large-latest",
  messages: [
    { role: "system", content: "Extract invoice data precisely." },
    { role: "user", content: invoiceText },
  ],
  responseFormat: InvoiceSchema,
  temperature: 0,
});

const invoice = response.choices[0].message.parsed!;
console.log(`Invoice ${invoice.invoiceNumber} — Total: ${invoice.totalTtc} ${invoice.currency}`);

Analyse des avis aspect par aspect

Un avis client réel est rarement uniformément positif ou négatif. L’avis d’hôtel ci-dessous fait l’éloge de la chambre et du petit-déjeuner, condamne le parking et le Wi-Fi, et offre une vision nuancée du personnel : un score global unique perdrait toute cette information. La solution consiste à modéliser un AspectSentiment réutilisable et à en demander une liste. Le champ evidence est la partie la plus intéressante du schéma : en exigeant une citation du texte, tu forces le modèle à étayer son jugement et tu te donnes les moyens de le vérifier.

from pydantic import BaseModel, Field

class AspectSentiment(BaseModel):
    aspect: str = Field(description="The aspect analyzed (quality, price, service, delivery, etc.)")
    sentiment: str = Field(description="positive, negative, or neutral")
    score: float = Field(description="Score between -1.0 (very negative) and 1.0 (very positive)")
    evidence: str = Field(description="Quote or excerpt from the text justifying the sentiment")

class ReviewAnalysis(BaseModel):
    overall_sentiment: str = Field(description="Overall sentiment: positive, negative, mixed, or neutral")
    overall_score: float = Field(description="Overall score between -1.0 and 1.0")
    aspects: list[AspectSentiment] = Field(description="Aspect-by-aspect analysis")
    recommendation: bool = Field(description="Does the author recommend the product/service?")
    key_strengths: list[str] = Field(description="Identified strengths")
    key_weaknesses: list[str] = Field(description="Identified weaknesses")

review_text = """
The hotel is magnificent; the room was spacious and clean. The breakfast is excellent
with a wide selection. However, the parking is outrageously expensive (€35/night) and the Wi-Fi was
unstable throughout the stay. The reception staff was very welcoming,
but room service took over an hour to deliver our order.
"""

response = client.chat.parse(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Analyze this customer review by detailing each mentioned aspect."
        },
        {"role": "user", "content": review_text}
    ],
    response_format=ReviewAnalysis,
    temperature=0
)

review = response.choices[0].message.parsed
print(f"Overall sentiment: {review.overall_sentiment} ({review.overall_score:+.1f})")
for aspect in review.aspects:
    print(f"  [{aspect.score:+.1f}] {aspect.aspect}: {aspect.sentiment}")

Classification de texte dans plusieurs catégories

Contrairement à la classification simple où une seule étiquette est attribuée, la classification multi-étiquettes reconnaît qu’un texte peut appartenir à plusieurs catégories. L’incident décrit ci-dessous touche simultanément à la sécurité, aux finances, à la fraude et à la protection des données : imposer une seule étiquette appauvrirait la logique de routage.

Deux éléments du schéma méritent attention. reasoning exige une justification pour chaque étiquette, ce qui améliore la qualité des scores. requires_human_review transforme l’incertitude du modèle en signal opérationnel : au lieu de découvrir après coup qu’une classification était douteuse, tu l’escalades automatiquement vers un humain lorsque la confiance tombe sous 0,7.

from pydantic import BaseModel, Field

class LabelScore(BaseModel):
    label: str = Field(description="Category name")
    confidence: float = Field(description="Confidence score between 0.0 and 1.0")
    reasoning: str = Field(description="One-sentence justification")

class MultiLabelClassification(BaseModel):
    primary_label: str = Field(description="Primary category")
    all_labels: list[LabelScore] = Field(
        description="All applicable categories with their confidence scores"
    )
    requires_human_review: bool = Field(
        description="True if classification is uncertain (confidence < 0.7)"
    )

text = """
Our mobile payment application has a security vulnerability allowing
access to banking data. Several customers have reported unauthorized
transactions. The technical team is currently investigating.
"""

response = client.chat.parse(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": """Classify this text among the following categories (multiple possible):
security, finance, technical, legal, customer_support, compliance, fraud, data_privacy.
Assign a confidence score to each applicable category."""
        },
        {"role": "user", "content": text}
    ],
    response_format=MultiLabelClassification,
    temperature=0
)

result = response.choices[0].message.parsed
print(f"Primary category: {result.primary_label}")
print(f"Human review required: {'Yes' if result.requires_human_review else 'No'}")
for label in result.all_labels:
    print(f"  [{label.confidence:.0%}] {label.label} — {label.reasoning}")

Factorisation de l’appel

Ces trois exemples partagent la même mécanique : une instruction système, un texte, un schéma et temperature=0. Au lieu de copier l’appel pour chaque nouveau cas, extrais-le dans une fonction générique. Le TypeVar lié à BaseModel préserve le typage : l’objet retourné a le type du schéma passé en argument, et ton IDE le sait.

from typing import TypeVar, Type
from pydantic import BaseModel

T = TypeVar("T", bound=BaseModel)

def extract(client, text: str, schema: Type[T], system_prompt: str = "") -> T:
    """Reusable structured extraction."""
    messages = []
    if system_prompt:
        messages.append({"role": "system", "content": system_prompt})
    messages.append({"role": "user", "content": text})

    response = client.chat.parse(
        model="mistral-large-latest",
        messages=messages,
        response_format=schema,
        temperature=0
    )
    return response.choices[0].message.parsed

# Usage
invoice = extract(client, invoice_text, InvoiceData, "Extract invoice data.")
review = extract(client, customer_review, ReviewAnalysis, "Analyze this customer review.")
classification = extract(client, ticket, MultiLabelClassification, "Classify this text.")

Trois cas d’utilisation très différents, chacun ne nécessitant qu’une seule ligne de code pour être appelé : tel est le bénéfice concret d’une bonne modélisation de schéma.

Ključne točke

  • Les schémas imbriqués (list[LineItem], list[AspectSentiment]) permettent des analyses complexes
  • Les énumérations (Currency, catégories) contraignent les valeurs possibles
  • Le champ evidence / reasoning force le modèle à justifier ses choix
  • Un wrapper générique réduit la duplication de code
  • temperature=0 est obligatoire pour ces cas d’utilisation en production