Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Kasutusjuhtude täiustatud näited

Õppetund 10 / 12 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Lihtsatest näidetest kaugemale
  2. Arve ekstraheerimine
  3. Arvustuste analüüsimine aspektide kaupa
  4. Teksti liigitamine mitmesse kategooriasse
  5. Kutse faktoriseerimine
  6. Peamised punktid

Lihtsatest näidetest kaugemale

Oled omandanud Pydanticu, Zodi ja client.chat.parse() kasutamise. Järgmised kolm juhtumit viivad sind nelja väljaga lihtsatest skeemidest edasi stsenaariumideni, millega kohtud ettevõtluskeskkonnas: raamatupidamisdokumendid, üksikasjalik klientide arvustuste analüüs ja tekstid, mis kuuluvad samaaegselt mitmesse kategooriasse. Igaüks neist illustreerib erinevat modelleerimistehnikat.

Arve ekstraheerimine

Dokumentide töötlemine on pesastatud skeemide loomulik valdkond. Arve ei ole lame objekt: see sisaldab päist, jalust summadega ja muutuvat arvu ridade üksusi, millel on oma struktuur. Seetõttu modelleerime LineItem eraldi ja viitame sellele seejärel loendis. Valuuta jaoks kasutame loendit (enum), mis takistab mudelil tagastamast kord "euros" ja kord "€" sõltuvalt sellest, kuidas dokument on sõnastatud.

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

Süsteemikäsus määratud kuupäevaformaat ei ole tühiasi: ilma selleta võib prantsuskeelne dokument toota 12/03/2026, samas kui ameerika oma annab 03/12/2026, luues sinu andmebaasi jaoks kaks eristamatut stringi. TypeScripti versioon järgib sama arhitektuuri, kus formaat on dokumenteeritud .describe() abil.

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}`);

Arvustuste analüüsimine aspektide kaupa

Tegelik klientide arvustus on harva ühtlaselt positiivne või negatiivne. Allpool toodud hotelli arvustus kiidab tuba ja hommikusööki, mõistab hukka parkimise ja Wi-Fi ning pakub personali suhtes nüansirikast vaadet: üksainus üldskoor kaotaks kogu selle info. Lahenduseks on modelleerida taaskasutatav AspectSentiment ja küsida nende loendit. Väli evidence on skeemi kõige huvitavam osa – nõudes tekstist tsitaati, sunnid mudelit oma hinnangut põhjendama ja annad endale vahendid selle kontrollimiseks.

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

Teksti liigitamine mitmesse kategooriasse

Erinevalt lihtsast liigitamisest, kus omistatakse üksainus silt, tunneb mitme sildiga liigitamine ära, et tekst võib kuuluda mitmesse kategooriasse. Allpool kirjeldatud intsident puudutab samaaegselt turvalisust, rahandust, pettust ja andmekaitset: ühe sildi pealesurumine vaesestaks marsruutimise loogikat.

Skeemis väärivad tähelepanu kaks elementi. reasoning nõuab iga sildi jaoks põhjendust, mis parandab skoori kvaliteeti. requires_human_review muudab mudeli ebakindluse operatiivseks signaaliks: selle asemel, et avastada tagantjärele, et liigitus oli kahtlane, eskaleerid selle automaatselt inimesele, kui kindlustunne langeb alla 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}")

Kutse faktoriseerimine

Nendel kolmel näitel on ühine mehhanika: süsteemikäsk, tekst, skeem ja temperature=0. Selle asemel, et kopeerida kutset iga uue juhtumi jaoks, eralda see üldisesse funktsiooni. BaseModel-iga seotud TypeVar säilitab tüübid: tagastatud objektil on argumendina edastatud skeemi tüüp ja sinu IDE teab seda.

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

Kolm väga erinevat kasutusjuhtu, millest igaüks nõuab kutsumiseks vaid ühte koodirida: see on hea skeemimodelleerimise konkreetne kasu.

Peamised punktid

  • Pesastatud skeemid (list[LineItem], list[AspectSentiment]) võimaldavad keerukat analüüsi
  • Loendid (Currency, kategooriad) piiravad võimalikke väärtusi
  • Väli evidence / reasoning sunnib mudelit oma valikuid põhjendama
  • Üldine mähisfunktsioon vähendab koodi dubleerimist
  • temperature=0 on nende tootmiskasutuste puhul kohustuslik