Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Exemples pratiques du mode JSON

Les 5 van 12 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Mettre le mode JSON en pratique
  2. Extraire des entités d’un texte non structuré
  3. Classifier des tickets de support
  4. Convertir une description en fiche produit
  5. Traiter plusieurs éléments en un seul appel
  6. Belangrijkste punten

Mis à jour le 3 novembre 2026 : L’exemple TypeScript importait précédemment Mistral par défaut, mais le SDK ne fournit qu’un export nommé (import { Mistral } from "@mistralai/mistralai"). Il codait également la clé API en dur et forçait le type de content avec !, ce qui est insuffisant car ce champ peut aussi être une liste de fragments. Vérifié par compilation avec le SDK 3.5.0 et TypeScript 7.0.2. Source : Mistral TypeScript SDK.

Mettre le mode JSON en pratique

Vous savez maintenant activer le mode JSON ; examinons des exemples concrets. Trois scénarios reviennent constamment dans les projets réels et chacun illustre une façon différente d’exploiter ce mode. Le code est fourni en Python, avec des équivalents TypeScript lorsque la traduction n’est pas immédiate.

Extraire des entités d’un texte non structuré

L’extraction d’entités est le cas d’usage le plus fréquent et le plus rentable : un e-mail commercial contient toutes les coordonnées, mais elles sont noyées dans une signature et des formules de politesse. L’instruction clé dans l’exemple suivant se trouve à la dernière ligne de l’invite système : exiger null pour les informations manquantes empêche le modèle d’inventer un numéro de téléphone simplement pour remplir le champ.

from mistralai.client import Mistral
import json

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

email_text = """
Hello,
I am Marie Dupont, Sales Director at TechVision SAS.
You can reach me at 06 12 34 56 78 or by email at [email protected].
Our headquarters are at 42 rue de la Paix, 75002 Paris.
Best regards,
Marie
"""

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": """Extract contact information from the provided text.
Return a JSON with keys: name, title, company, phone, email, address.
If information is missing, use null."""
        },
        {"role": "user", "content": email_text}
    ],
    response_format={"type": "json_object"},
    temperature=0
)

contact = json.loads(response.choices[0].message.content)
print(f"Name: {contact['name']}")
print(f"Company: {contact['company']}")
print(f"Phone: {contact['phone']}")

Résultat attendu :

{
  "name": "Marie Dupont",
  "title": "Sales Director",
  "company": "TechVision SAS",
  "phone": "06 12 34 56 78",
  "email": "[email protected]",
  "address": "42 rue de la Paix, 75002 Paris"
}

Classifier des tickets de support

La classification nécessite une approche différente : au lieu de laisser le modèle choisir ses propres valeurs, vous énumérez les valeurs autorisées pour chaque champ directement dans l’invite. Cela rend les résultats comparables d’un ticket à l’autre et directement exploitables pour le routage. Notez le passage à mistral-small-latest : le tri des tickets ne justifie pas l’utilisation du modèle le plus puissant.

tickets = [
    "My payment was charged twice, I demand an immediate refund!",
    "How can I change my password?",
    "Your app crashes every time I open the settings tab.",
]

for ticket in tickets:
    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {
                "role": "system",
                "content": """Classify the support ticket.
Return a JSON with:
- category: "billing", "account", "technical", "feature_request", or "other"
- priority: "low", "medium", "high", or "critical"
- sentiment: "positive", "neutral", or "negative"
- summary: one-sentence summary"""
            },
            {"role": "user", "content": ticket}
        ],
        response_format={"type": "json_object"},
        temperature=0
    )

    result = json.loads(response.choices[0].message.content)
    print(f"Category: {result['category']} | Priority: {result['priority']} | Sentiment: {result['sentiment']}")

Voici le même classifieur en TypeScript. La vérification avant JSON.parse nous rappelle que le SDK typpe content comme optionnel et comme string | ContentChunk[] : seule une chaîne de caractères peut être analysée.

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

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

const ticket = "My payment was charged twice!";

const response = await client.chat.complete({
  model: "mistral-small-latest",
  messages: [
    {
      role: "system",
      content: `Classify the support ticket.
Return a JSON with: category, priority, sentiment, summary.`,
    },
    { role: "user", content: ticket },
  ],
  responseFormat: { type: "json_object" },
  temperature: 0,
});

const contenu = response.choices[0]?.message?.content;
if (typeof contenu !== "string") {
  throw new Error("The response does not contain JSON text.");
}
const result = JSON.parse(contenu);
console.log(`Category: ${result.category}`);
console.log(`Priority: ${result.priority}`);

Convertir une description en fiche produit

Troisième scénario : transformer un texte marketing en un enregistrement prêt pour une base de données. Cet exercice est plus délicat car les types comptent : un prix doit arriver sous forme de nombre, une durée de livraison sous forme de deux entiers, et la livraison gratuite sous forme de booléen. D’où les annotations précises dans l’invite.

product_text = """
The 16-inch MacBook Pro with M4 Pro chip is available starting at €2,799.
It features 24 GB of unified RAM, a 512 GB SSD, and a Liquid Retina XDR display.
Available in Space Black and Silver. Free delivery within 3-5 days.
"""

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": """Convert the product description into a structured sheet.
JSON with: name, brand, price_eur (number), specs (object with ram_gb, storage_gb, screen),
colors (list), delivery_days_min, delivery_days_max, free_shipping (boolean)."""
        },
        {"role": "user", "content": product_text}
    ],
    response_format={"type": "json_object"},
    temperature=0
)

product = json.loads(response.choices[0].message.content)
print(json.dumps(product, indent=2, ensure_ascii=False))

Résultat :

{
  "name": "MacBook Pro 16-inch",
  "brand": "Apple",
  "price_eur": 2799,
  "specs": {
    "ram_gb": 24,
    "storage_gb": 512,
    "screen": "Liquid Retina XDR"
  },
  "colors": ["Space Black", "Silver"],
  "delivery_days_min": 3,
  "delivery_days_max": 5,
  "free_shipping": true
}

Notez que la marque, Apple, n’apparaît nulle part dans le texte source : le modèle l’a déduite du nom du produit. C’est un atout pour l’enrichissement, mais un risque à surveiller si vous exigez une extraction strictement littérale.

Traiter plusieurs éléments en un seul appel

Rien ne vous oblige à faire un appel par élément. En demandant au modèle une liste sous une seule clé, vous réduisez le nombre de requêtes — et donc la latence cumulative — pour des tâches courtes comme l’analyse d’avis. La note demandée ici varie de -1,0 à 1,0, une convention utile pour agréger les résultats ultérieurement.

texts = [
    "Excellent product, I recommend it!",
    "Late delivery, damaged product.",
    "Decent for the price, nothing exceptional."
]

response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "system",
            "content": "Analyze the sentiment of each review. Return a JSON with a key 'reviews' containing a list of objects {text, sentiment, score}. The score ranges from -1.0 (very negative) to 1.0 (very positive)."
        },
        {"role": "user", "content": "\n---\n".join(texts)}
    ],
    response_format={"type": "json_object"},
    temperature=0
)

reviews = json.loads(response.choices[0].message.content)["reviews"]
for r in reviews:
    print(f"[{r['score']:+.1f}] {r['sentiment']} — {r['text'][:40]}...")

Un détail commun à tous ces exemples mérite d’être souligné : temperature=0 est systématique ici. Pour les tâches d’extraction et de classification, la créativité n’apporte rien et coûte en reproductibilité.

Belangrijkste punten

  • Le mode JSON excelle dans l’extraction de données, la classification et la conversion
  • Utilisez l’invite système pour définir la structure et les types attendus
  • temperature=0 garantit des résultats reproductibles
  • Le traitement par lots en une seule requête est possible en demandant une liste JSON
  • Analysez toujours la réponse avec json.loads() / JSON.parse() avant d’accéder aux données