Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Cásanna Úsáide Ardleibhéil

Ceacht 10 as 12 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Thar Samplaí Simplí
  2. Fachtú a Eastóscadh
  3. Léirmheasanna a Anailísiú Gné ar Ghné
  4. Téacs a Aicmiú i gCatagóirí Iolracha
  5. An Glao a Fhachtóiriú
  6. Príomhphointí

Thar Samplaí Simplí

Tá máistreacht bainte amach agat ar Pydantic, Zod, agus client.chat.parse(). Bogann na trí chás seo a leanas thar scéimre ceithre réimse simplí go dtí cásanna a bhuaileann tú leo i dtimpeallachtaí fiontair: doiciméid chuntasaíochta, anailís mhionsonraithe ar léirmheasanna custaiméirí, agus téacsanna a bhaineann le roinnt catagóirí ag an am céanna. Léiríonn gach ceann acu teicníc mhúnlaithe difriúil.

Fachtú a Eastóscadh

Is é próiseáil doiciméad críoch nádúrtha na scéimre neadaithe. Ní réad cothrom é fachtú: tá ceanntásc ann, buntásc le hiomláin, agus líon athraitheach míreanna líne a bhfuil a struchtúr féin acu. Dá bhrí sin, déanaimid samhaltú ar LineItem ar leithligh agus ansin tagraímid dó laistigh de liosta. Úsáideann an t-airgeadra áireamh (enum), rud a chuireann cosc ar an tsamhail "euros" nó "€" a thabhairt ar ais ag brath ar conas atá an doiciméad curtha in iúl.

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

Ní mionsonraí é an formáid dáta a fhorghníomhítear sa leid córais: gan é, d’fhéadfadh doiciméad Francach 12/03/2026 a tháirgeadh agus ceann Meiriceánach 03/12/2026, rud a chruthódh dhá shreang nach féidir a idirdhealú i do bhunachar sonraí. Leanann an leagan TypeScript an ailtireacht chéanna, agus an fhormáid doiciméadaithe trí .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}`);

Léirmheasanna a Anailísiú Gné ar Ghné

Is annamh a bhíonn léirmheas fíor chustaiméara dearfach nó diúltach go hiomlán. Molann an léirmheas óstáin thíos an seomra agus an bhricfeasta, cáineann sé an pháircáil agus an Wi-Fi, agus tugann sé tuairim chuíchuích ar an bhfoireann: chaillfeadh scór domhanda amháin an t-eolas seo go léir. Is é an réiteach ná AspectSentiment in-athúsáidte a mhúnlú agus liosta díobh a iarradh. Is é an réimse evidence an chuid is suimiúla den scéimre—trí luachan ón téacs a éileamh, cuireann tú iallach ar an tsamhail a breithiúnas a bhunú agus tugann tú duit féin na modhanna chun é a fhíorú.

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

Téacs a Aicmiú i gCatagóirí Iolracha

Murab ionann agus aicmiú simplí, áit a shanntar lipéad amháin, aithníonn aicmiú il-lipéad go bhféadfadh téacs baint le roinnt catagóirí. Baineann an teagmhas a thuairiscítear thíos le slándáil, airgeadas, calaois, agus cosaint sonraí ag an am céanna: dhéanfadh lipéad amháin a fhorchur dochar ar an loighic ródaireachta.

Tá dhá eilimint sa scéimre a thuilleann aird. Éilíonn reasoning údar le gach lipéad, rud a fheabhsaíonn cáilíocht na scóir. Tiontaíonn requires_human_review éiginnteacht na samhla ina comhartha oibríochtúil: in ionas teacht ar an eolas tar éis na fíricí go raibh aicmiú amhrasach, déanann tú é a ardú go huathoibríoch go dtí duine nuair a thiteann an muinín faoi 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}")

An Glao a Fhachtóiriú

Roinneann na trí shampla seo na meicníochtaí céanna: leid córais, téacs, scéimre, agus temperature=0. In ionas an glao a chóipeáil do gach cás nua, eastóscaigh é i bhfeidhm ghinearálta. Caomhnaíonn an TypeVar atá ceangailte le BaseModel an clóscríobh: tá cineál an réada a thuirtear comhionann le cineál na scéimre a ritear mar argóint, agus tá a fhios ag d’IDE é sin.

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

Trí chás úsáide an-difriúil, agus ní theastaíonn ach líne amháin cóid chun gach ceann acu a ghlaow: sin an tairbhe chruinne a bhaineann le múnlú maith scéimre.

Príomhphointí

  • Cuireann scéimre neadaithe (list[LineItem], list[AspectSentiment]) anailísí casta ar chumas
  • Cuireann áireamh (Currency, catagóirí) srian ar na luachanna is féidir
  • Cuireann an réimse evidence / reasoning iallach ar an tsamhail a roghanna a údar
  • Laghdaíonn fillteán ginearálta dúbailt cóid
  • Tá temperature=0 éigeantach do na cásanna úsáide táirgeachta seo