Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Naudojimas client.chat.parse()

Paskaita 8 iš 12 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Metodas parse(): individualizuotų struktūrizuotų išvesčių širdis
  2. Pilnas galas į galą kvietimas
  3. Automatiškai pridėtas sistemos priminimas
  4. .parsed prieš .content: du skirtingi naudojimo būdai
  5. Kas vis dar gali nepavykti
  6. Svarbiausi punktai

Metodas parse(): individualizuotų struktūrizuotų išvesčių širdis

client.chat.parse() yra struktūrizuotas client.chat.complete() atitikmuo. Užuot grąžinęs laisvą tekstą arba žalią JSON, kurį turi apdoroti pats, jis tiesiogiai grąžina tipizuotą objektą, atitinkantį tavo Pydantic modelį. Šis pokytis gali atrodyti tik kosmetinis, tačiau iš tikrųjų jis pašalina visą kodo sluoksnį.

Kontrastas aiškiausias greta. Naudodamas complete(), gauni eilutę ir ją pats transformuoji. Naudodamas parse(), objektas atkeliauja paruoštas naudojimui, o jei reikia, prieinamas ir žalias JSON.

# JSON režimas — complete() grąžina JSON tekstą
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    response_format={"type": "json_object"}
)
raw_json: str = response.choices[0].message.content
data = json.loads(raw_json)  # Rankinis apdorojimas

# Individualizuota — parse() grąžina tipizuotą objektą
response = client.chat.parse(
    model="mistral-large-latest",
    messages=messages,
    response_format=MonSchema
)
obj: MonSchema = response.choices[0].message.parsed  # Pydantic objektas
raw_json: str = response.choices[0].message.content   # Žalias JSON taip pat prieinamas

Skirtumas slypi kreipimesi į .parsed: tai tiesiogiai naudojamas Pydantic objektas su IDE automatinio užbaigimo funkcija ir tipo validavimu.

Pilnas galas į galą kvietimas

Šiame pavyzdyje žingsnis po žingsnio parodyti penki realaus duomenų ištraukimo etapai: schemos apibrėžimas su aiškiais aprašymais, kliento sukūrimas, parse() iškvietimas, grąžinto objekto naudojimas ir JSON reprezentacijos gavimas, jei reikia.

from mistralai.client import Mistral
from pydantic import BaseModel, Field
from typing import Optional

# 1. Apibrėžkite schemą
class BookInfo(BaseModel):
    title: str = Field(description="Book title")
    authors: list[str] = Field(description="List of authors")
    year: Optional[int] = Field(default=None, description="Publication year")
    genre: str = Field(description="Main literary genre")
    summary: str = Field(description="Summary in 2-3 sentences")

# 2. Sukurkite klientą
client = Mistral(api_key="your-api-key")

# 3. Iškvieskite parse()
response = client.chat.parse(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "You are an expert librarian. Extract information about the mentioned book."
        },
        {
            "role": "user",
            "content": "I loved '1984' by George Orwell. It's a dystopian novel published in 1949 describing a totalitarian society under constant surveillance."
        }
    ],
    temperature=0
)

# 4. Naudokite apdorotą objektą
book = response.choices[0].message.parsed
print(f"Title: {book.title}")
print(f"Authors: {', '.join(book.authors)}")
print(f"Year: {book.year}")
print(f"Genre: {book.genre}")
print(f"Summary: {book.summary}")

# 5. Žalias JSON taip pat prieinamas
raw = response.choices[0].message.content
print(f"\nRaw JSON: {raw}")

Atkreipk dėmesį, ko nėra sistemos priminime: jokių numatomo formato aprašymų.

Automatiškai pridėtas sistemos priminimas

SDK tai tvarko už tave. Kai naudoji parse(), Mistral automatiškai prideda priešdėlį prie sistemos priminimo:

Your output should be an instance of a JSON object following this schema: { ... }

Šiame priešdėlyje yra JSON schema, sugeneruota iš tavo Pydantic modelio. Tau nereikia aprašyti formato savo priminime – SDK tai padaro už tave. Tai leidžia tavo sistemos žinutei daryti tai, ką ji geriausiai moka: suteikti verslo kontekstą ir nustatyti kokybės reikalavimus, pavyzdžiui, sumų tikslumą arba kaip tvarkyti trūkstamus duomenis.

response = client.chat.parse(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            # Nereikia aprašyti JSON formato – tai automatinė
            # Susikoncentruokite į KONTEKSTĄ ir KOKYBĘ
            "content": """You are an expert financial analyst.
Be precise with amounts and percentages.
If data is not available in the text, use null."""
        },
        {"role": "user", "content": report_text}
    ],
    response_format=FinancialReport
)

.parsed prieš .content: du skirtingi naudojimo būdai

Tipizuotas objektas, pasiekiamas per .parsed, yra tai, ką manipuliuoji savo programos logikoje. Jis atskleidžia atributus su jų tipais, palaiko iteraciją, konvertuoja į žodyną naudodamas model_dump() ir serializuoja naudodamas model_dump_json().

book = response.choices[0].message.parsed

# Tipizuota prieiga su IDE automatinio užbaigimo funkcija
print(book.title)        # str
print(book.authors)      # list[str]
print(book.year)         # Optional[int]

# Iteracija per sąrašus
for author in book.authors:
    print(f"  - {author}")

# Konvertavimas į žodyną
book_dict = book.model_dump()

# Serializavimas į JSON
book_json = book.model_dump_json(indent=2)

Tuo tarpu žalias JSON lieka naudingas sistemos ribose: žurnalų rašymui, saugojimui duomenų bazėje arba atsakymo perdavimui tokiam, koks yra, kitai API.

raw = response.choices[0].message.content

# Tai JSON eilutė, naudinga:
# - Žurnalų rašymui
# - Saugojimui duomenų bazėje
# - Siuntimui kitai API

import json
data = json.loads(raw)

Kas vis dar gali nepavykti

Garantuota schema neužtikrina, kad tavo kodas bus imunitetas viskam. API gali grąžinti tinklo ar tarnybos klaidą, o .parsed gali būti None, jei atsakymas buvo nutrauktas. Toliau pateiktas šablonas atskirai tvarko abu atvejus – SDKError API klaidoms, ValidationError schemos klaidoms – ir kartotina bandymus tik ribotą skaičių kartų.

from mistralai.client import Mistral
from mistralai.client.errors import SDKError
from pydantic import ValidationError

client = Mistral(api_key="your-api-key")

def extract_structured(text: str, schema, max_retries: int = 2):
    """Struktūrizuotas ištraukimas su klaidų apdorojimu."""
    for attempt in range(max_retries + 1):
        try:
            response = client.chat.parse(
                model="mistral-large-latest",
                messages=[
                    {"role": "system", "content": "Extract the requested information."},
                    {"role": "user", "content": text}
                ],
                response_format=schema,
                temperature=0,
                max_tokens=1024
            )

            parsed = response.choices[0].message.parsed
            if parsed is None:
                raise ValueError("Parsed is None—response may be truncated")

            return parsed

        except SDKError as e:
            print(f"API error (attempt {attempt + 1}): {e}")
            if attempt == max_retries:
                raise
        except ValidationError as e:
            print(f"Validation error (attempt {attempt + 1}): {e}")
            if attempt == max_retries:
                raise

# Naudojimas
try:
    book = extract_structured("'The Little Prince' by Saint-Exupéry, 1943", BookInfo)
    print(f"Extracted: {book.title} by {', '.join(book.authors)}")
except Exception as e:
    print(f"Final failure: {e}")

Čia galioja tas pats refleksas, matytas naudojant JSON režimą: atsakymas, nutrauktas dėl max_tokens, sukuria nebaigtą arba nulinį objektą, o finish_reason tau apie tai praneša dar prieš tai, kai tai atrasi toliau vamzdyno grandinėje.

response = client.chat.parse(
    model="mistral-large-latest",
    messages=messages,
    response_format=MonSchema,
    max_tokens=256
)

if response.choices[0].finish_reason != "stop":
    print(f"Warning: finish_reason = {response.choices[0].finish_reason}")
    # "length" = nutrauktas atsakymas, padidinkite max_tokens

Svarbiausi punktai

  • client.chat.parse() pakeičia client.chat.complete() individualizuotoms struktūrizuotoms išvestims
  • .parsed grąžina tipizuotą Pydantic objektą; .content grąžina žalią JSON
  • Schema automatiškai pridedama prie sistemos priminimo – nereikia aprašyti formato
  • Visada tikrink finish_reason ir tvarkyk SDKError bei ValidationError klaidas
  • Naudok model_dump(), kad konvertuotum apdorotą objektą į Python žodyną