Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Primeri napredne uporabe

Lekcija 10 od 12 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Onkraj preprostih primerov
  2. Pridobivanje podatkov iz računa
  3. Analiza mnenj po vidikih
  4. Razvrščanje besedila v več kategorij
  5. Poenotenje klica
  6. Ključne ugotovitve

Onkraj preprostih primerov

Obvladal si Pydantic, Zod in client.chat.parse(). Naslednji trije primeri presegajo preproste sheme s štirimi polji in te popeljejo v scenarije, s katerimi se boš srečal v podjetniških okoljih: računovodske dokumente, podrobno analizo mnenj strank in besedila, ki hkrati spadajo v več kategorij. Vsak primer ilustrira drugačno tehniko modeliranja.

Pridobivanje podatkov iz računa

Obdelava dokumentov je naravno področje za gnezdenje shem. Račun ni ploščat objekt: vsebuje glavo, nogo s seštevki in spremenljivo število postavk, ki imajo svojo strukturo. Zato model LineItem definiramo ločeno in ga nato uporabimo v seznamu. Valuta uporablja enumeracijo (enum), kar prepreči, da bi model vrnil "euros" ali "€", odvisno od tega, kako je dokument zapisan.

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

Format datuma, vsiljen v sistemskem pozivu, ni malenkost: brez njega bi francoski dokument lahko proizvedel 12/03/2026, ameriški pa 03/12/2026, kar bi v tvoji bazi podatkov ustvarilo dva nerazločljiva niza. Različica v TypeScriptu sledi isti arhitekturi, pri čemer je format dokumentiran prek .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}`);

Analiza mnenj po vidikih

Pravo mnenje stranke redko enakomerno pozitivno ali negativno. Spodnja ocena hotela hvali sobo in zajtrk, obsoja parkirišče in Wi-Fi ter ponuja niansiran pogled na osebje: ena sama globalna ocena bi izgubila vse te informacije. Rešitev je modeliranje ponovno uporabnega AspectSentiment in zahteva seznama teh elementov. Polje evidence je najbolj zanimiv del sheme – z zahtevo po citatu iz besedila prisiliš model, da utemelji svojo sodbo, sebi pa omogočiš preverjanje.

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

Razvrščanje besedila v več kategorij

Za razliko od preprostega razvrščanja, kjer je dodeljena ena sama oznaka, razvrščanje z več oznakami (multi-label) priznava, da lahko besedilo spada v več kategorij hkrati. Spodaj opisani incident se hkrati dotika varnosti, financ, goljufij in varstva podatkov: prisiljevanje ene same oznake bi osiromašilo logiko usmerjanja.

Dva elementa sheme si zaslužita pozornost. reasoning zahteva utemeljitev za vsako oznako, kar izboljša kakovost ocen. requires_human_review pretvori negotovost modela v operativni signal: namesto da bi naknadno ugotovil, da je bila razvrstitev dvomljiva, jo samodejno escaliraš človeku, ko zaupanje pade 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}")

Poenotenje klica

Ti trije primeri delijo isto mehaniko: sistemski poziv, besedilo, shema in temperature=0. Namesto da bi klic kopiral za vsak nov primer, ga izvleci v splošno funkcijo. TypeVar, omejen na BaseModel, ohranja tipizacijo: vrnjeni objekt ima tip sheme, podane kot argument, in tvoje razvojno okolje (IDE) to ve.

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

Trije zelo različni primeri uporabe, od katerih vsak zahteva le eno vrstico kode za klic: to je konkretna prednost dobrega modeliranja shem.

Ključne ugotovitve

  • Gnezdenje shem (list[LineItem], list[AspectSentiment]) omogoča kompleksne analize
  • Enumeracije (Currency, kategorije) omejujejo možne vrednosti
  • Polje evidence / reasoning prisili model, da utemelji svoje izbire
  • Splošni ovitek zmanjša podvajanje kode
  • temperature=0 je obvezen za te produkcijske primere uporabe