Använda client.chat.parse()
På denna sida
Metoden parse(): Hjärtat i anpassade strukturerade utdata
client.chat.parse() är den strukturerade motsvarigheten till client.chat.complete(). Istället för att returnera fri text eller rå JSON som du måste parsa själv, returnerar den ett typat objekt som direkt matchar din Pydantic-modell. Förändringen kan se kosmetisk ut, men den eliminerar faktiskt ett helt kodlager.
Kontrasten blir tydligast sida vid sida. Med complete() hämtar du en sträng och transformerar den själv. Med parse() anländer objektet redo att användas, och den råa JSON:en finns fortfarande tillgänglig om du behöver den.
# JSON-läge — complete() returnerar JSON-text
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) # Manuell parsning
# Anpassat — parse() returnerar ett typat objekt
response = client.chat.parse(
model="mistral-large-latest",
messages=messages,
response_format=MonSchema
)
obj: MonSchema = response.choices[0].message.parsed # Pydantic-objekt
raw_json: str = response.choices[0].message.content # Rå JSON också tillgänglig
Skillnaden ligger i åtkomsten till .parsed: ett direkt användbart Pydantic-objekt med IDE-autokomplettering och typvalidering.
Ett komplett end-to-end-anrop
Följande exempel går igenom de fem stegen i en riktig extrahering: definiera schemat med tydliga beskrivningar, skapa klienten, anropa parse(), använd det returnerade objektet och hämta JSON-representationen vid behov.
from mistralai.client import Mistral
from pydantic import BaseModel, Field
from typing import Optional
# 1. Definiera schemat
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. Skapa klienten
client = Mistral(api_key="your-api-key")
# 3. Anropa 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. Använd det parsade objektet
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. Rå JSON är också tillgänglig
raw = response.choices[0].message.content
print(f"\nRaw JSON: {raw}")
Lägg märke till vad systemprompten inte innehåller: ingen beskrivning av det förväntade formatet.
Den automatiskt tillagda systemprompten
SDK:t hanterar detta. När du använder parse() lägger Mistral automatiskt till ett prefix till systemprompten:
Your output should be an instance of a JSON object following this schema: { ... }
Detta prefix innehåller JSON-schemat som genereras från din Pydantic-modell. Du behöver inte beskriva formatet i din prompt – SDK:t gör det åt dig. Detta frigör ditt systemmeddelande så att det kan göra det det är bäst på: tillhandahålla affärskontext och ställa kvalitetskrav, såsom precision för belopp eller hur saknade data ska hanteras.
response = client.chat.parse(
model="mistral-large-latest",
messages=[
{
"role": "system",
# Inget behov av att beskriva JSON-formatet – det sker automatiskt
# Fokusera på KONTEXT och KVALITET
"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 kontra .content: Två distinkta användningsområden
Det typade objektet, tillgängligt via .parsed, är det du manipulerar i din applikationslogik. Det exponerar attribut med sina typer, stöder iteration, konverterar till en ordlista med model_dump() och serialiserar med model_dump_json().
book = response.choices[0].message.parsed
# Typad åtkomst med IDE-autokomplettering
print(book.title) # str
print(book.authors) # list[str]
print(book.year) # Optional[int]
# Iterera över listor
for author in book.authors:
print(f" - {author}")
# Konvertera till ordlista
book_dict = book.model_dump()
# Serialisera till JSON
book_json = book.model_dump_json(indent=2)
Rå JSON är däremot fortfarande användbar vid systemgränser: för loggning, databaslagring eller för att skicka svaret oförändrat till ett annat API.
raw = response.choices[0].message.content
# Detta är en JSON-sträng, användbar för:
# - Loggning
# - Databaslagring
# - Sändning till ett annat API
import json
data = json.loads(raw)
Vad som fortfarande kan misslyckas
Ett garanterat schema gör inte din kod immun mot allt. API:t kan returnera ett nätverks- eller tjänstefel, och .parsed kan vara None om svaret avbröts. Mönstret nedan hanterar båda fallen separat – SDKError för API:t, ValidationError för schemat – och försöker endast ett begränsat antal gånger.
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):
"""Strukturerad extrahering med felhantering."""
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
# Användning
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}")
Reflexen som ses med JSON-läge gäller fortfarande här: ett svar som klipps av av max_tokens producerar ett ofullständigt eller null-objekt, och finish_reason berättar detta för dig innan du upptäcker det längre ner i pipelinen.
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" = trunkerat svar, öka max_tokens
Viktiga punkter
client.chat.parse()ersätterclient.chat.complete()för anpassade strukturerade utdata.parsedreturnerar ett typat Pydantic-objekt;.contentreturnerar rå JSON- Schemat läggs automatiskt till i systemprompten – inget behov av att beskriva formatet
- Kontrollera alltid
finish_reasonoch hantera felenSDKErrorochValidationError - Använd
model_dump()för att konvertera det parsade objektet till en Python-ordlista