Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Avancerede brugstilfælde

Lektion 10 af 12 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Ud over simple eksempler
  2. Uddragelse af en faktura
  3. Analyse af anmeldelser aspekt for aspekt
  4. Klassificering af tekst i flere kategorier
  5. Faktorisering af kaldet
  6. Vigtige pointer

Ud over simple eksempler

Du har mestret Pydantic, Zod og client.chat.parse(). De næste tre tilfælde går videre fra simple skemaer med fire felter til scenarier, du vil støde på i virksomhedsmiljøer: regnskabsdokumenter, detaljeret analyse af kundeanmeldelser og tekster, der tilhører flere kategorier samtidigt. Hvert eksempel illustrerer en anden modelleringsteknik.

Uddragelse af en faktura

Dokumentbehandling er det naturlige domæne for nestede skemaer. En faktura er ikke et fladt objekt: Den indeholder en header, en footer med summer og et variabelt antal linjeposter, der har deres egen struktur. Derfor modellerer vi LineItem separat og refererer derefter til den inden i en liste. Valutaen bruger en enum, hvilket forhindrer modellen i at returnere "euros" eller "€" afhængigt af, hvordan dokumentet er formuleret.

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

Datoformatet, der håndhæves i system-prompten, er ikke en ubetydelig detalje: Uden det kunne et fransk dokument producere 12/03/2026, mens et amerikansk giver 03/12/2026, hvilket skaber to ikke-skelnelige strenge til din database. TypeScript-versionen følger den samme arkitektur, hvor formatet dokumenteres 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 af anmeldelser aspekt for aspekt

En rigtig kundeanmeldelse er sjældent ensartet positiv eller negativ. Hotelanmeldelsen nedenfor roser værelset og morgenmaden, fordømmer parkeringen og Wi-Fi’et og giver en nuanceret vurdering af personalet: En enkelt global score ville miste alle disse oplysninger. Løsningen er at modellere en genanvendelig AspectSentiment og anmode om en liste over dem. Feltet evidence er den mest interessante del af skemaet – ved at kræve et citat fra teksten tvinger du modellen til at funderne sin vurdering og giver dig selv midlerne til at verificere den.

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

Klassificering af tekst i flere kategorier

I modsætning til simpel klassificering, hvor der tildeles ét enkelt mærke, genkender multi-label-klassificering, at en tekst kan tilhøre flere kategorier. Hændelsen beskrevet nedenfor berører samtidig sikkerhed, finans, svindel og databeskyttelse: At tvinge ét enkelt mærke igennem ville fattiggøre routeringslogikken.

To elementer i skemaet fortjener opmærksomhed. reasoning kræver en begrundelse for hvert mærke, hvilket forbedrer kvaliteten af scoringerne. requires_human_review omdanner modelusikkerhed til et operationelt signal: I stedet for først efterfølgende at opdage, at en klassificering var tvivlsom, eskalerer du den automatisk til et menneske, når tilliden falder under 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}")

Faktorisering af kaldet

Disse tre eksempler deler den samme mekanisme: En system-prompt, en tekst, et skema og temperature=0. I stedet for at kopiere kaldet for hvert nyt tilfælde, kan du udtrække det til en generisk funktion. TypeVar bundet til BaseModel bevarer typningen: Det returnerede objekt har typen af det skema, der sendes som argument, og din IDE ved det.

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

Tre meget forskellige brugstilfælde, der hver kun kræver én enkelt kode linje at kalde: Dette er den konkrete fordel ved god skemamodellering.

Vigtige pointer

  • Nestede skemaer (list[LineItem], list[AspectSentiment]) muliggør komplekse analyser
  • Enums (Currency, kategorier) begrænser mulige værdier
  • Feltet evidence / reasoning tvinger modellen til at begrunde sine valg
  • En generisk wrapper reducerer kode-duplikering
  • temperature=0 er obligatorisk for disse produktionsbrugstilfælde