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

Premier appel et streaming en TypeScript

Lecția 9 din 14 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Envoyez votre première requête
  2. Streaming
  3. Conversations multi-tours
  4. Ajustement de la génération et gestion des erreurs
  5. Puncte cheie

Leçon mise à jour le 3 novembre 2026 après compilation des exemples en mode strict avec le SDK @mistralai/mistralai 3.5.0 et TypeScript 7.0.2. Le SDK typpe content comme string | ContentChunk[] : les conversations multi-tours et les boucles de streaming échouaient à la compilation sans une vérification typeof content === 'string'. L’exemple de configuration combinait précédemment temperature et topP, ce que la documentation de l’API déconseille de modifier simultanément. La gestion des erreurs utilise désormais la classe MistralError du SDK, et la route Express valide la question avant d’appeler l’API. Sources : Mistral TypeScript SDK (README) · paramètres de complétion de chat.

Envoyez votre première requête

Maintenant que le SDK est installé, passons à la pratique. La méthode chat.complete() du SDK TypeScript est l’équivalent exact de celle du SDK Python : mêmes paramètres, même structure de réponse, hormis les conventions de nommage. Si vous avez suivi les leçons Python, vous êtes en terrain connu ; seule la syntaxe asynchrone de JavaScript est nouvelle.

import 'dotenv/config';
import { Mistral } from '@mistralai/mistralai';

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

async function main() {
  const response = await client.chat.complete({
    model: 'mistral-small-latest',
    messages: [
      {
        role: 'user',
        content: 'Explain the concept of a closure in JavaScript in three sentences.',
      },
    ],
  });

  console.log(response.choices[0]?.message?.content);
}

main();

Les points d’interrogation dans response.choices[0]?.message?.content ne sont pas là pour faire joli : dans les types du SDK, message et content sont optionnels, et choices[0] n’existe pas si la liste revient vide. L’accès sécurisé renvoie undefined plutôt que de lever une exception. Notez également que content n’est pas toujours une chaîne : le SDK le type comme string | ContentChunk[] car une réponse peut arriver sous forme de liste de fragments (texte, raisonnement thinking, références, etc.).

Comprendre la réponse

La structure de la réponse est identique à celle du SDK Python. L’analyser vous aide à comprendre ce pour quoi vous payez et pourquoi une réponse s’est arrêtée. L’exemple suivant extrait le texte, la raison d’arrêt et le nombre de jetons un par un ; le taper montrera votre éditeur suggérant chaque champ, prouvant que le typage fait son travail.

async function analyserReponse() {
  const response = await client.chat.complete({
    model: 'mistral-small-latest',
    messages: [
      { role: 'user', content: 'What is the capital of France?' },
    ],
    maxTokens: 100,
  });

  // Texte de la réponse
  const texte = response.choices[0]?.message?.content;

  // Raison d'arrêt
  const finRaison = response.choices[0]?.finishReason;

  // Statistiques de jetons
  const tokensEntree = response.usage?.promptTokens;
  const tokensSortie = response.usage?.completionTokens;

  console.log(`Réponse : ${texte}`);
  console.log(`Jetons : ${tokensEntree} en entrée + ${tokensSortie} en sortie`);
  console.log(`Arrêt : ${finRaison}`);
}

Notez la casse : là où Python expose max_tokens, finish_reason et prompt_tokens, TypeScript utilise maxTokens, finishReason et promptTokens. C’est l’erreur numéro un lors du portage manuel d’un exemple Python — et le compilateur la signalera immédiatement.

Streaming

Le streaming est essentiel pour les interfaces web : sans lui, l’utilisateur fixe un écran figé pendant plusieurs secondes ; avec lui, le texte apparaît mot par mot et la latence perçue s’effondre. Le SDK TypeScript expose le flux comme un générateur asynchrone, que vous itérez avec for await...of :

async function streamReponse() {
  const stream = await client.chat.stream({
    model: 'mistral-small-latest',
    messages: [
      {
        role: 'user',
        content: 'Describe the five main design patterns in JavaScript.',
      },
    ],
  });

  for await (const chunk of stream) {
    const content = chunk.data.choices[0]?.delta.content;
    if (typeof content === 'string') {
      process.stdout.write(content);
    }
  }
  console.log();
}

Deux détails méritent votre attention. Le contenu réside dans chunk.data, et non directement dans chunk : c’est l’enveloppe d’événement du SDK depuis la version 1.0. Et la vérification typeof content === 'string' filtre à la fois les fragments sans contenu, qui encombreraient votre sortie de undefined, et le contenu sous forme de liste de fragments, que process.stdout.write n’accepte pas : sans elle, le mode strict refuse la compilation.

Exposer le flux via Express

Un flux qui ne quitte jamais le terminal ne sert à rien. Voici comment le relayer vers un navigateur en utilisant les Server-Sent Events depuis une API Express. La question est validée avant tout appel pour éviter d’envoyer une requête vide à l’API. Les trois en-têtes ouvrent ensuite le canal, chaque fragment est renvoyé sous forme JSON dans un événement data:, et un marqueur [DONE] signale au client de fermer la connexion.

import express from 'express';
import { Mistral } from '@mistralai/mistralai';

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

app.get('/api/chat', async (req, res) => {
  const question = typeof req.query.q === 'string' ? req.query.q : '';
  if (!question) {
    res.status(400).json({ error: 'Missing q parameter' });
    return;
  }

  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');

  const stream = await client.chat.stream({
    model: 'mistral-small-latest',
    messages: [{ role: 'user', content: question }],
  });

  for await (const chunk of stream) {
    const content = chunk.data.choices[0]?.delta.content;
    if (typeof content === 'string' && content) {
      res.write(`data: ${JSON.stringify({ text: content })}\n\n`);
    }
  }

  res.write('data: [DONE]\n\n');
  res.end();
});

app.listen(3000, () => console.log('Server on port 3000'));

Conversations multi-tours

La gestion de l’historique suit le même principe qu’en Python : le modèle n’a pas de mémoire, vous maintenez donc un tableau de messages et renvoyez le tout à chaque tour. En TypeScript, déclarer un type Message explicite empêche d’insérer un rôle inexistant ou un objet malformé — une erreur que l’API renverrait autrement sous forme de 400.

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

type Message = {
  role: 'system' | 'user' | 'assistant';
  content: string;
};

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

const historique: Message[] = [
  {
    role: 'system',
    content: 'You are an expert TypeScript assistant. Respond in English.',
  },
];

async function poserQuestion(question: string): Promise<string> {
  historique.push({ role: 'user', content: question });

  const response = await client.chat.complete({
    model: 'mistral-small-latest',
    messages: historique,
  });

  const contenu = response.choices[0]?.message?.content;
  const reponse = typeof contenu === 'string' ? contenu : '';
  historique.push({ role: 'assistant', content: reponse });

  return reponse;
}

async function main() {
  console.log(await poserQuestion('What is a generic type?'));
  console.log(await poserQuestion('Show me a concrete example.'));
  console.log(await poserQuestion('How do I add constraints?'));
}

main();

La vérification typeof contenu === 'string' n’est pas un luxe : le champ content de la réponse peut être une liste de fragments, alors que votre type Message attend une chaîne. Observez ensuite la troisième question : « How do I add constraints? » n’a de sens que parce que les deux échanges précédents sont toujours dans le tableau. Poussez l’exercice en supprimant la ligne qui ajoute la réponse de l’assistant à l’historique, et vous verrez le modèle perdre le fil dès le deuxième tour.

Ajustement de la génération et gestion des erreurs

Les paramètres avancés sont identiques à ceux du SDK Python — seule la casse change. Une temperature basse pour un livrable structuré et un maxTokens calibré sur la longueur attendue produisent des réponses plus prévisibles. Définissez temperature ou topP, pas les deux : c’est la recommandation de la documentation de l’API, qui conseille une temperature entre 0 et 0,7.

const response = await client.chat.complete({
  model: 'mistral-large-latest',
  messages: [
    { role: 'user', content: 'Propose an architecture for a B2B SaaS.' },
  ],
  temperature: 0.5,
  maxTokens: 1000,
});

Enfin, tout appel réseau peut échouer : clé invalide, quota dépassé, panne. Enveloppez toujours l’appel dans un try/catch et vérifiez le type d’erreur avant de lire ses propriétés, sinon TypeScript refusera la compilation. Toutes les erreurs HTTP renvoyées par l’API héritent de MistralError, qui expose statusCode et body ; les erreurs réseau (ConnectionError, RequestTimeoutError, etc.) n’en héritent pas mais restent des instances Error.

import * as errors from '@mistralai/mistralai/models/errors';

try {
  const response = await client.chat.complete({
    model: 'mistral-small-latest',
    messages: [{ role: 'user', content: 'Hello!' }],
  });
  console.log(response.choices[0]?.message?.content);
} catch (error) {
  if (error instanceof errors.MistralError) {
    // Réponse d'erreur API : clé refusée 401, limite atteinte 429...
    console.error(`Erreur API Mistral ${error.statusCode}: ${error.message}`);
  } else if (error instanceof Error) {
    // Pas de réponse API : réseau coupé, délai dépassé...
    console.error(`Erreur : ${error.message}`);
  }
}

Puncte cheie

  • client.chat.complete() est asynchrone — utilisez await
  • Le streaming utilise for await...of sur le résultat de client.chat.stream()
  • Le typage TypeScript détecte les erreurs de paramètres à la compilation
  • L’intégration SSE avec Express est simple pour les interfaces web en temps réel
  • L’historique de conversation se gère avec un tableau typé Message[]
  • content est soit une chaîne, soit une liste de fragments : testez typeof content === 'string' avant de l’utiliser comme texte
  • Les erreurs HTTP du SDK héritent de MistralError (statusCode, body)