Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Úsáid a bhaint as client.chat.parse()

Ceacht 8 as 12 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. An Modh parse(): Croílár na nAschur Struchtúrtha Saincheaptha
  2. Glao Iomlán ó Thús go Deireadh
  3. An Leid Córais a Chuirtear leis go huathoibríoch
  4. .parsed vs .content: Dhá Úsáid Ar leith
  5. Cad is Féidir a Theip Fós
  6. Príomhphointí

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 ionad client.chat.complete() d’Aschuir Struchtúrtha Saincheaptha
  • Filleann .parsed oibiacht Pydantic chlóscríofa; filleann .content JSON 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_reason i gcónaí agus láimhseáil earráidí SDKError agus ValidationError
  • Úsáid model_dump() chun an oibiacht pharsáilte a thiontú go foclóir Python