Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Haladó használati esetek

10. lecke 12 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Túl az egyszerű példákon
  2. Számla adatok kinyerése
  3. Vélemények szempont szerinti elemzése
  4. Szövegek besorolása több kategóriába
  5. A hívás faktorizálása
  6. Főbb megállapítások

Túl az egyszerű példákon

Már elsajátítottad a Pydanticot, a Zodot és a client.chat.parse() metódust. A következő három eset kilép a négy mezős egyszerű sémák világából, és olyan forgatókönyveket mutat be, amelyekkel vállalati környezetben találkozhatsz: számviteli dokumentumok feldolgozása, részletes ügyfélvélemény-elemzés, valamint olyan szövegek kategorizálása, amelyek egyszerre több osztályba is tartoznak. Mindegyik eset egy másik modellezési technikát illusztrál.

Számla adatok kinyerése

A dokumentumfeldolgozás a beágyazott sémák természetes terepe. Egy számla nem lapos objektum: tartalmaz egy fejlécet, egy végösszegeket tartalmazó láblécet, valamint változó számú soros tételt, amelyek saját struktúrával rendelkeznek. Ezért a LineItem osztályt külön modellezzük, majd egy listán belül hivatkozunk rá. A pénznemhez enumerációt (enum) használunk, ami megakadályozza, hogy a modell a dokumentum szövegezésétől függően hol "euros", hol "€" értéket adjon vissza.

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

A rendszerüzenetben (system prompt) kikényszerített dátumformátum nem apróság: enélkül egy francia dokumentum 12/03/2026 formátumot eredményezhet, míg egy amerikai 03/12/2026-ot, ami az adatbázisod számára két megkülönböztethetetlen karakterláncot jelent. A TypeScript verzió ugyanerre az architektúrára épül, ahol a formátumot a .describe() metódussal dokumentáljuk.

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

Vélemények szempont szerinti elemzése

Egy valós ügyfélvélemény ritkán egységesen pozitív vagy negatív. Az alábbi szállodai értékelés dicséri a szobát és a reggelit, elítéli a parkolást és a Wi-Fi-t, valamint árnyalt képet fest a személyzetről: egyetlen globális pontszám elveszítené ezt az összes információt. A megoldás egy újrahasználható AspectSentiment modell létrehozása, és egy lista kérése belőlük. Az evidence (bizonyíték) mező a séma legérdekesebb része – azzal, hogy idézetet követelsz a szövegből, arra kényszeríted a modellt, hogy megalapozza az ítéletét, és számodra is lehetővé teszi annak ellenőrzését.

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

Szövegek besorolása több kategóriába

Az egyszerű osztályozással ellentétben, ahol csak egyetlen címkét rendelünk hozzá, a többcímkés (multi-label) osztályozás felismeri, hogy egy szöveg több kategóriába is tartozhat. Az alább leírt incidens egyszerre érinti a biztonságot, a pénzügyeket, a csalást és az adatvédelmet: egyetlen címke kikényszerítése szegényesebbé tenné az útvonalválasztási logikát.

A séma két eleme külön figyelmet érdemel. A reasoning (indoklás) mező minden címkéhez indoklást kér, ami javítja a pontszámok minőségét. A requires_human_review (emberi felülvizsgálat szükséges) mező a modell bizonytalanságát működési jellé alakítja: ahelyett, hogy utólag derülne ki, hogy egy besorolás kétes volt, automatikusan emberi felülvizsgálatra escalárod az esetet, amikor a bizonyosság 0,7 alá csökken.

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

A hívás faktorizálása

Ez a három példa ugyanazt a mechanikát követi: egy rendszerüzenet, egy szöveg, egy séma és a temperature=0 beállítás. Ahelyett, hogy minden új esetben másolnád a hívást, érdemes azt egy általános függvénybe kiemelni. A BaseModel-hez kötött TypeVar megőrzi a típusokat: a visszatérési objektum típusa megegyezik az argumentumként átadott séma típusával, és az IDE-d is ismeri ezt.

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

Három nagyon különböző használati eset, amelyek mindegyike mindössze egyetlen sor kóddal hívható meg: ez a jó séma-modellezés kézzelfogható előnye.

Főbb megállapítások

  • A beágyazott sémák (list[LineItem], list[AspectSentiment]) lehetővé teszik a komplex elemzéseket
  • Az enumerációk (Currency, kategóriák) korlátozzák a lehetséges értékeket
  • Az evidence (bizonyíték) vagy reasoning (indoklás) mező arra kényszeríti a modellt, hogy indokolja meg választásait
  • Egy általános wrapper csökkenti a kódismétlést
  • A temperature=0 beállítás kötelező ezekben a produkciós használati esetekben