Úsáid a bhaint as client.chat.parse()
Ar an leathanach seo
An Modh parse(): Croílár na nAschur Struchtúrtha Saincheaptha
Is ionann client.chat.parse() agus leagan struchtúrtha de client.chat.complete(). In ionad téacs saor nó JSON amh a thabhairt ar ais nach mór duit féin a pharsáil, tugann sé oibiacht chlóscríofa ar ais a mheaitseálann do mhúnla Pydantic go díreach. D’fhéadfadh sé go bhfuil an t-athrú cosúil le gné aeistéitiúil, ach i ndáiríre, cuireann sé deireadh le sraith iomlán cóid.
Is soiléire an chodarsnacht nuair a fheiceann tú iad taobh le taobh. Le complete(), faigheann tú teaghrán agus déanann tú é a chlaochlú féin. Le parse(), tagann an oibiacht réidh le húsáid, agus tá an JSON amh ar fáil fós má tá gá leis.
# Mód JSON — filleann complete() téacs JSON
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) # Parsáil láimhe
# Saincheaptha — filleann parse() oibiacht chlóscríofa
response = client.chat.parse(
model="mistral-large-latest",
messages=messages,
response_format=MonSchema
)
obj: MonSchema = response.choices[0].message.parsed # Oibiacht Pydantic
raw_json: str = response.choices[0].message.content # Tá JSON amh ar fáil freisin
Baineann an difríocht le rochtain ar .parsed: oibiacht Pydantic atá inúsáidte go díreach le huathchríochnú IDE agus bailíochtú cineáil.
Glao Iomlán ó Thús go Deireadh
Taispeánann an sampla seo a leanas cúig chéim eastósctha iarbhír: sainmhínigh an scéima le cur síos soiléir, cruthaigh an cliant, glaoigh ar parse(), úsáid an oibiacht a filltear, agus faigh an léiriú JSON más gá.
from mistralai.client import Mistral
from pydantic import BaseModel, Field
from typing import Optional
# 1. Sainmhínigh an scéima
class BookInfo(BaseModel):
title: str = Field(description="Teideal an leabhair")
authors: list[str] = Field(description="Liosta na n-údar")
year: Optional[int] = Field(default=None, description="Bliain foilsithe")
genre: str = Field(description="Príomhsheánra liteartha")
summary: str = Field(description="Achoimre i 2-3 abairt")
# 2. Cruthaigh an cliant
client = Mistral(api_key="your-api-key")
# 3. Glaoigh ar parse()
response = client.chat.parse(
model="mistral-large-latest",
messages=[
{
"role": "system",
"content": "Is leabharlannaí saineolach tú. Bain faisnéis amach faoin leabhar a luaitear."
},
{
"role": "user",
"content": "Thaitin '1984' le George Orwell go mór liom. Is úrscéal diostópach é a foilsíodh i 1949 a chuireann síos ar chumann totalach faoi mhaoirseacht leanúnach."
}
],
temperature=0
)
# 4. Úsáid an oibiacht pharsáilte
book = response.choices[0].message.parsed
print(f"Teideal: {book.title}")
print(f"Údair: {', '.join(book.authors)}")
print(f"Bliain: {book.year}")
print(f"Seánra: {book.genre}")
print(f"Achoimre: {book.summary}")
# 5. Tá JSON amh ar fáil freisin
raw = response.choices[0].message.content
print(f"\nJSON Amh: {raw}")
Tabhair faoi deara nach bhfuil sa leid córais: gan cur síos ar an bhformáid a bhfuiltear ag súil léi.
An Leid Córais a Chuirtear leis go huathoibríoch
Déanann an SDK é seo. Nuair a úsáideann tú parse(), cuireann Mistral réimír leis an leid córais go huathoibríoch:
Your output should be an instance of a JSON object following this schema: { ... }
Tá an scéima JSON sa réimír seo a ghintear ó do mhúnla Pydantic. Ní gá duit an fhormáid a chur síos i do leid – déanann an SDK é sin duit. Saoraíonn sé seo do theachtaireacht chórais chun an rud is fearr atá inti a dhéanamh: comhthéacs gnó a sholáthar agus ceanglais cháilíochta a shocrú, amhail cruinneas maidir le méideanna nó conas déileáil le sonraí atá in easnamh.
response = client.chat.parse(
model="mistral-large-latest",
messages=[
{
"role": "system",
# Ní gá an fhormáid JSON a chur síos – tá sé uathoibríoch
# Díriú ar CHOMHTHÉACS agus CÁILÍOCHT
"content": """Is anailísí airgeadais saineolach tú.
Bí cruinn le méideanna agus céatadáin.
Mura bhfuil sonraí ar fáil sa téacs, úsáid null."""
},
{"role": "user", "content": report_text}
],
response_format=FinancialReport
)
.parsed vs .content: Dhá Úsáid Ar leith
Is é an oibiacht chlóscríofa, atá inrochtana trí .parsed, an rud a láimhseálann tú i do loighic feidhmchláir. Nochtann sé tréithe lena gcineálacha, tacaíonn sé le hiatrú, tiontaíonn sé go foclóir le model_dump(), agus déanann sé sraitheachtú le model_dump_json().
book = response.choices[0].message.parsed
# Rochtain chlóscríofa le huathchríochnú IDE
print(book.title) # str
print(book.authors) # list[str]
print(book.year) # Optional[int]
# Iatrú thar liostaí
for author in book.authors:
print(f" - {author}")
# Tiontaigh go foclóir
book_dict = book.model_dump()
# Sraitheachtú go JSON
book_json = book.model_dump_json(indent=2)
Ar an láimh eile, fanann an JSON amh úsáideach ag teorainneacha an chórais: le haghaidh logáil, stóráil bunachair sonraí, nó an freagra a sheoladh mar atá sé chuig API eile.
raw = response.choices[0].message.content
# Is teaghrán JSON é seo, úsáideach le haghaidh:
# - Logáil
# - Stóráil bunachair sonraí
# - Seoladh chuig API eile
import json
data = json.loads(raw)
Cad is Féidir a Theip Fós
Ní dhéanann scéima ráthaithe do chód díonach ar gach rud. Is féidir leis an API earráid líonra nó seirbhíse a thabhairt ar ais, agus is féidir le .parsed a bheith None má briseadh isteach ar an bhfreagra. Déileálann an patrún thíos leis an dá chás ar leith – SDKError don API, ValidationError don scéima – agus déanann sé iarracht arís ach uair theoranta amháin.
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):
"""Eastóscadh struchtúrtha le láimhseáil earráidí."""
for attempt in range(max_retries + 1):
try:
response = client.chat.parse(
model="mistral-large-latest",
messages=[
{"role": "system", "content": "Bain an fhaisnéis a iarradh amach."},
{"role": "user", "content": text}
],
response_format=schema,
temperature=0,
max_tokens=1024
)
parsed = response.choices[0].message.parsed
if parsed is None:
raise ValueError("Tá Parsed None – b'fhéidir go bhfuil an freagra gearrtha")
return parsed
except SDKError as e:
print(f"Earráid API (iarracht {attempt + 1}): {e}")
if attempt == max_retries:
raise
except ValidationError as e:
print(f"Earráid bailíochtaithe (iarracht {attempt + 1}): {e}")
if attempt == max_retries:
raise
# Úsáid
try:
book = extract_structured("'An Prionsa Beag' le Saint-Exupéry, 1943", BookInfo)
print(f"Eastósctha: {book.title} le {', '.join(book.authors)}")
except Exception as e:
print(f"Teip dheiridh: {e}")
Baineann an frithghníomh a fheictear le Mód JSON fós anseo: cruthaíonn freagra a ghearrtar ag max_tokens oibiacht neamhiomlán nó nialasach, agus insíonn finish_reason duit é seo sula bhfaigheann tú amach é níos faide síos sa phíblíne.
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"Rabhadh: finish_reason = {response.choices[0].finish_reason}")
# "length" = freagra gearrtha, méadaigh max_tokens
Príomhphointí
- Cuireann
client.chat.parse()in ionadclient.chat.complete()d’Aschuir Struchtúrtha Saincheaptha - Filleann
.parsedoibiacht Pydantic chlóscríofa; filleann.contentJSON amh - Cuirtear an scéima leis an leid córais go huathoibríoch – ní gá an fhormáid a chur síos
- Seiceáil
finish_reasoni gcónaí agus láimhseáil earráidíSDKErroragusValidationError - Úsáid
model_dump()chun an oibiacht pharsáilte a thiontú go foclóir Python