Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Pokročilé prípady použitia

Lekcia 10 z 12 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Ďalej než jednoduché príklady
  2. Extrakcia faktúry
  3. Analýza hodnotení podľa aspektov
  4. Klasifikácia textu do viacerých kategórií
  5. Faktorizácia volania
  6. Kľúčové poznatky

Ďalej než jednoduché príklady

Ovládaš Pydantic, Zod a client.chat.parse(). Nasledujúce tri prípady presahujú jednoduché schémy so štyrmi poľami a smerujú k scenárom, s ktorými sa stretneš v podnikových prostrediach: účtovné dokumenty, podrobná analýza hodnotení zákazníkov a texty patriace súčasne do viacerých kategórií. Každý z nich ilustruje inú techniku modelovania.

Extrakcia faktúry

Spracovanie dokumentov je prirodzeným územím pre vnorené schémy. Faktúra nie je plochý objekt: obsahuje hlavičku, pätičku so súčtami a premenný počet riadkových položiek, ktoré majú vlastnú štruktúru. Preto modelujeme LineItem samostatne a následne naň odkazujeme v rámci zoznamu. Mena používa enumeráciu (enum), čo zabraňuje modelu vracať hodnoty ako "euros" alebo "€" v závislosti od formulácie v dokumente.

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

Formát dátumu vynútený v systémovom prompte nie je zanedbateľným detailom: bez neho by francúzsky dokument mohol vyprodukovať 12/03/2026, zatiaľ čo americký 03/12/2026, čo by vytvorilo dva nerozlíšiteľné reťazce pre tvoju databázu. Verzia v TypeScripte nasleduje rovnakú architektúru, pričom formát je zdokumentovaný pomocou .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}`);

Analýza hodnotení podľa aspektov

Skutočné hodnotenie zákazníka je zriedkavo jednotne pozitívne alebo negatívne. Nižšie uvedené hodnotenie hotela chváli izbu a raňajky, odsudzuje parkovanie a Wi-Fi a ponúka vyvážený pohľad na personál: jediné globálne skóre by stratilo všetky tieto informácie. Riešením je modelovať opakovane použiteľný AspectSentiment a požadovať zoznam týchto objektov. Pole evidence je najzaujímavejšou časťou schémy – tým, že vyžaduje citáciu z textu, prinútiš model ukotviť svoj úsudok a dáš si prostriedok na jeho overenie.

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

Klasifikácia textu do viacerých kategórií

Na rozdiel od jednoduchej klasifikácie, kde je priradený jediný štítok, viacštítková klasifikácia (multi-label) uznáva, že text môže patriť do niekoľkých kategórií súčasne. Nižšie opísaný incident sa týka bezpečnosti, financií, podvodov a ochrany údajov naraz: vynútenie jediného štítka by ochudobnilo logiku smerovania.

Dva prvky schémy si zaslúžia pozornosť. reasoning vyžaduje odôvodnenie pre každý štítok, čo zlepšuje kvalitu skóre. requires_human_review mení neistotu modelu na operačný signál: namiesto toho, aby si dodatočne zisťoval, že klasifikácia bola pochybná, automaticky ju eskaluješ človeku, keď dôvera klesne pod 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}")

Faktorizácia volania

Tieto tri príklady zdieľajú rovnakú mechaniku: systémový prompt, text, schéma a temperature=0. Namiesto kopírovania volania pre každý nový prípad ho extrahuj do generickej funkcie. TypeVar viazaný na BaseModel zachováva typovanie: vrátený objekt má typ schémy odovzdanej ako argument a tvoje IDE to vie.

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

Tri veľmi odlišné prípady použitia, z ktorých každý si vyžaduje iba jeden riadok kódu na volanie: to je konkrétny prínos dobrého modelovania schém.

Kľúčové poznatky

  • Vnorené schémy (list[LineItem], list[AspectSentiment]) umožňujú komplexné analýzy
  • Enumerácie (Currency, kategórie) obmedzujú možné hodnoty
  • Pole evidence / reasoning núti model odôvodniť svoje voľby
  • Generický obal znižuje duplikáciu kódu
  • temperature=0 je pre tieto produkčné prípady použitia povinné