Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Aktivér JSON-tilstand

Lektion 4 af 12 Opdateret 3. november 2026 Udvikler
På denne side
  1. Sådan fungerer JSON-tilstand
  2. Aktivering i Python
  3. Aktivering i TypeScript
  4. Eksplicitte instrukser er ikke valgfrie
  5. Flyt formatinstrukser til system-prompten
  6. Parsing af svaret
  7. Vigtige pointer

Opdateret 3. november 2026: TypeScript-eksemplerne importerede tidligere Mistral som en standard-eksport (import Mistral from …), men SDK’et leverer kun en navngiven eksport: import { Mistral } from "@mistralai/mistralai". De sendte også indhold med typen string | ContentChunk[] direkte til JSON.parse og hardcodede API-nøglen i kildekoden. Verificeret ved kompilering med SDK 3.5.0 og TypeScript 7.0.2. Kilde: Mistral TypeScript SDK.

Sådan fungerer JSON-tilstand

JSON-tilstand er den enkleste mekanisme til at opnå struktureret output fra Mistral. Ved at aktivere en enkelt parameter garanterer du, at modellens svar vil være gyldig JSON. Ingen skema der skal defineres, ingen datamodel der skal skrives – bare syntaktisk korrekt JSON ved hvert kald.

Aktivering i Python

Du aktiverer dette via parameteren response_format i metoden client.chat.complete(). Bemærk, at selve prompten skal beskrive den forventede struktur – vi forklarer snart, hvorfor dette ikke er valgfrit.

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)

Outputtet vil være gyldig JSON, klar til brug som det er:

{
  "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."
    }
  ]
}

Aktivering i TypeScript

TypeScript-SDK’et følger præcis samme logik, men med camelCase-navngivning: parameteren hedder responseFormat, og parsing sker med JSON.parse(). En ekstra forholdsregel gælder: SDK’et definerer typen for content som string | ContentChunk[], så JSON.parse accepterer kun værdien, efter du har verificeret, at det faktisk er en streng.

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);

Eksplicitte instrukser er ikke valgfrie

Her er det punkt, mange udviklere overser, og årsagen til størstedelen af skuffelsen over JSON-tilstand: det er ikke nok blot at aktivere parameteren. Tilstanden garanterer syntaksen, ikke indholdet. Du skal eksplicit instruere modellen i prompten om det format, du forventer.

Sammenlign følgende to kald. I det første gives ingen strukturel vejledning: modellen vil producere JSON, men nøglerne, deres navne og deres nesting vil variere fra kald til kald, hvilket efterlader din downstream-kode uden stabile ankerpunkter.

# Dårlig praksis — ingen JSON-instruks i prompten
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": "What are the advantages of cloud?"}
    ],
    response_format={"type": "json_object"}
)
# Modellen vil producere JSON, men strukturen vil være uforudsigelig

I det andet indsættes et strukturelt skelet direkte i prompten. Modellen har nu et mål at efterligne, hvilket gør outputtet forudsigeligt på tværs af kald.

# God praksis — klar instruktion i prompten
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"}
)

Ved at inkludere et struktureksempel i din prompt guider du modellen mod det ønskede format. Dette er ikke en absolut garanti som ved brugerdefinerede strukturerede outputs, men det er mere end tilstrækkeligt til de fleste brugstilfælde.

Flyt formatinstrukser til system-prompten

Når den samme behandling gentages over hundreder af input, bliver det uhåndterligt at have formatinstrukser i brugerbeskeden: du kopierer dem ved hvert kald, og de blandes med det indhold, der skal behandles. Flyt dem i stedet til system-prompten.

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"}
)

Denne adskillelse – hvor formatinstrukser bæres af rollen system, og indholdet der skal behandles bæres af rollen user – gør din kode væsentligt mere vedligeholdelig: ændring af formatet sker kun ét sted.

Parsing af svaret

Én sidste vane du skal opbygge: Svaret fra JSON-tilstand er altid en JSON-streng inde i message.content, aldrig et objekt. Parsing er dit ansvar på begge sprog.

import json

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

# Tilgå dataene
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}`);
});

Vigtige pointer

  • Aktivér JSON-tilstand med response_format: {"type": "json_object"}
  • Brug client.chat.complete() (ikke parse())
  • Instruér altid modellen i prompten om den forventede JSON-struktur
  • Svaret er en JSON-streng – pars den med json.loads() eller JSON.parse()
  • Placér formatinstrukser i system-prompten ved gentagne pipelines