Naudojimas client.chat.parse()
Šiame puslapyje
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čiaclient.chat.complete()individualizuotoms struktūrizuotoms išvestims.parsedgrąžina tipizuotą Pydantic objektą;.contentgrąžina žalią JSON- Schema automatiškai pridedama prie sistemos priminimo – nereikia aprašyti formato
- Visada tikrink
finish_reasonir tvarkykSDKErrorbeiValidationErrorklaidas - Naudok
model_dump(), kad konvertuotum apdorotą objektą į Python žodyną