Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

A JSON-mód engedélyezése

4. lecke 12 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Hogyan működik a JSON-mód
  2. Engedélyezés Pythonban
  3. Engedélyezés TypeScriptben
  4. A kifejezett utasítások nem opcionálisak
  5. A formátumra vonatkozó utasítások áthelyezése a rendszer-promptba
  6. A válasz elemzése
  7. Főbb megállapítások

Frissítve: 2026. november 3.: A korábbi TypeScript-példák a Mistral osztályt alapértelmezett exportként importálták (import Mistral from …), holott az SDK csak név szerinti exportot biztosít: import { Mistral } from "@mistralai/mistralai". Emellett a string | ContentChunk[] típusú tartalmat közvetlenül adták át a JSON.parse függvénynek, és a forráskódba keménykódolták az API-kulcsot. Ellenőrizve a 3.5.0-s SDK és a 7.0.2-es TypeScript fordításával. Forrás: Mistral TypeScript SDK.

Hogyan működik a JSON-mód

A JSON-mód a legegyszerűbb módszer arra, hogy strukturált kimenetet kapj a Mistral modelltől. Egyetlen paraméter bekapcsolásával garantálod, hogy a modell válasza érvényes JSON lesz. Nem kell sémát definiálnod, sem adatmodellt írnod – minden hívásnál szintaktikailag helyes JSON-t kapsz.

Engedélyezés Pythonban

Ezt a client.chat.complete() metódus response_format paraméterével aktiválhatod. Ne feledd: magának a promptnak is le kell írnia a várt struktúrát – hogy ez miért nem elhagyható, azt rövidesen kifejtjük.

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "user",
            "content": "Describe the 3 main advantages of cloud computing. Return the result as JSON with a key 'advantages' containing a list of objects with 'title' and 'description'."
        }
    ],
    response_format={"type": "json_object"}
)

print(response.choices[0].message.content)

A kimenet érvényes JSON lesz, amely azonnal használható:

{
  "advantages": [
    {
      "title": "Scalability",
      "description": "Dynamic adjustment of resources based on demand."
    },
    {
      "title": "Cost Reduction",
      "description": "No investment in physical infrastructure required."
    },
    {
      "title": "Accessibility",
      "description": "Access services from anywhere."
    }
  ]
}

Engedélyezés TypeScriptben

A TypeScript SDK pontosan ugyanazt a logikát követi, camelCase elnevezéssel: a paraméter neve responseFormat, az elemzéshez pedig a JSON.parse() függvényt használjuk. Egy extra óvintézkedés szükséges: az SDK a content mezőt string | ContentChunk[] típusként kezeli, így a JSON.parse csak akkor fogadja el az értéket, ha előtte ellenőrzöd, hogy valóban szöveg-e.

import { Mistral } from "@mistralai/mistralai";

const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

const response = await client.chat.complete({
  model: "mistral-large-latest",
  messages: [
    {
      role: "user",
      content: "List 3 popular JavaScript frameworks in JSON with 'name' and 'useCase'."
    }
  ],
  responseFormat: { type: "json_object" },
});

const contenu = response.choices[0]?.message?.content;
if (typeof contenu !== "string") {
  throw new Error("Response does not contain JSON text.");
}
const data = JSON.parse(contenu);
console.log(data);

A kifejezett utasítások nem opcionálisak

Íme egy pont, amit sok fejlesztő figyelmen kívül hagy, és ami a JSON-móddal kapcsolatos csalódások többségének oka: a paraméter bekapcsolása önmagában nem elég. A mód csak a szintaxist garantálja, a tartalmat nem. Kifejezetten utasítanod kell a modellt a prompton belül arról, milyen formátumot vársz.

Hasonlítsd össze az alábbi két hívást. Az elsőben nincs strukturális útmutatás: a modell JSON-t állít elő, de a kulcsok, azok nevei és a beágyazottság hívásról hívásra változni fog, így a downstream kódodnak nem lesznek stabil támpontjai.

# Rossz gyakorlat – nincs JSON-utasítás a promptban
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "What are the advantages of cloud?"}
    ],
    response_format={"type": "json_object"}
)
# A modell JSON-t állít elő, de a struktúra kiszámíthatatlan lesz

A második esetben egy strukturális vázat illesztünk közvetlenül a promptba. A modellnek így van egy célja, amit utánozhat, így a kimenet hívásról hívásra előre jelezhetővé válik.

# Jó gyakorlat – egyértelmű utasítás a promptban
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "user",
            "content": """What are the advantages of cloud computing?

Return your answer in JSON with the following structure:
{
  "topic": "string",
  "advantages": [
    {"title": "string", "description": "string"}
  ]
}"""
        }
    ],
    response_format={"type": "json_object"}
)

Ha strukturális példát adsz a promptban, azzal a kívánt formátum felé tereled a modellt. Ez nem olyan abszolút garancia, mint az egyedi strukturált kimenetek (Custom Structured Outputs), de a legtöbb használati esetben teljesen elegendő.

A formátumra vonatkozó utasítások áthelyezése a rendszer-promptba

Ha ugyanazt a feldolgozást száznyi bemeneten ismétled meg, a formátumra vonatkozó utasításokat a felhasználói üzenetben hagyni kezelhetetlenné válik: minden hívásnál másolnod kell őket, és összekeverednek a feldolgozandó tartalommal. Helyezd át őket inkább a rendszer-promptba.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "You are a data extraction assistant. You ALWAYS return your responses in JSON with the keys 'entities', 'confidence', and 'source'."
        },
        {
            "role": "user",
            "content": "Extract information from this text: 'Acme Corp, founded in 2019 in Lyon, employs 250 people.'"
        }
    ],
    response_format={"type": "json_object"}
)

Ez a szétválasztás – ahol a formátumra vonatkozó utasításokat a system szerepkör viszi, a feldolgozandó tartalmat pedig a user szerepkör – jelentősen karbantarthatóbbá teszi a kódodat: a formátum módosítása ezentúl csak egy helyen történik.

A válasz elemzése

Egy utolsó szokás, amit érdemes kialakítanod: a JSON-mód válasza mindig egy JSON-szöveg a message.content mezőben, sosem objektum. Az elemzés a te feladatod mindkét nyelven.

import json

raw = response.choices[0].message.content
data = json.loads(raw)

# Adatok hozzáférése
for advantage in data["advantages"]:
    print(f"- {advantage['title']}: {advantage['description']}")
const contenu = response.choices[0]?.message?.content;
if (typeof contenu !== "string") {
  throw new Error("Response does not contain JSON text.");
}
const data = JSON.parse(contenu);

data.advantages.forEach((adv: any) => {
  console.log(`- ${adv.title}: ${adv.description}`);
});

Főbb megállapítások

  • A JSON-módot a response_format: {"type": "json_object"} paraméterrel engedélyezed
  • Használd a client.chat.complete() metódust (ne a parse()-t)
  • Mindig utasítsd a modellt a promptban a várt JSON-struktúrára
  • A válasz egy JSON-szöveg – elemezd a json.loads() vagy a JSON.parse() függvénnyel
  • Ismétlődő folyamatoknál a formátumra vonatkozó utasításokat a rendszer-promptba helyezd