Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Cas d'usage avancés

Nodarbība 10 no 12 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  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. Galvenās atziņas

Au-delà des exemples simples

Tu as maîtrisé 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 naturel 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. Par conséquent, nous modélisons 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 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 à demander une liste de ceux-ci. 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’usage 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.

Galvenās atziņas

  • 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’usage en production