Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Använda client.chat.parse()

Lektion 8 av 12 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Metoden parse(): Hjärtat i anpassade strukturerade utdata
  2. Ett komplett end-to-end-anrop
  3. Den automatiskt tillagda systemprompten
  4. .parsed kontra .content: Två distinkta användningsområden
  5. Vad som fortfarande kan misslyckas
  6. Viktiga punkter

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ätter client.chat.complete() för anpassade strukturerade utdata
  • .parsed returnerar ett typat Pydantic-objekt; .content returnerar rå JSON
  • Schemat läggs automatiskt till i systemprompten – inget behov av att beskriva formatet
  • Kontrollera alltid finish_reason och hantera felen SDKError och ValidationError
  • Använd model_dump() för att konvertera det parsade objektet till en Python-ordlista