Salt la conținutul principal
Română— Alege o limbă
Meniu

Exemple pratique du mode JSON

Lecția 5 din 12 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Mettre le mode JSON en pratique
  2. Extraction d’entités depuis un texte non structuré
  3. Classification de tickets de support
  4. Conversion d’une description en fiche produit
  5. Traitement de plusieurs éléments en un seul appel
  6. Puncte cheie

Mis à jour le 3 novembre 2026 : L’exemple TypeScript importait précédemment Mistral comme export 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 le 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.

Extraction d’entités depuis 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"
}

Classification de 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 les types du SDK définissent content comme optionnel et de type 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}`);

Conversion d’une description en fiche produit

Troisième scénario : transformer un texte marketing en une fiche prête à être intégrée dans 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 des données, mais un risque à surveiller si vous exigez une extraction strictement littérale.

Traitement de 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 clé unique, 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é.

Puncte cheie

  • 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