Skip to content
Learni
View all tutorials
Intelligence Artificielle

Comment débuter avec l'API Mistral en 2026

12 minBEGINNER
Node.jsAPI IAMistral AIChatGPT alternatif

Introduction

L'API Mistral, développée par Mistral AI, est une interface puissante pour accéder à des modèles de langage de pointe comme Mistral Nemo ou Mistral Large. En 2026, elle reste un choix privilégié pour les développeurs cherchant une alternative open-source performante à OpenAI, avec des coûts optimisés et une latence réduite. Ce tutoriel vous guide pas à pas pour l'intégrer dans une application Node.js, du premier appel API au streaming en temps réel.

Pourquoi Mistral ? Elle excelle en multilingue (français inclus), supporte le raisonnement complexe et propose des embeddings pour la recherche sémantique. Imaginez un chatbot conversationnel ou un assistant de code : en quelques lignes, vous générez des réponses intelligentes. Nous couvrons les bases pour débutants, avec du code 100% fonctionnel. À la fin, vous serez prêt à scaler vos projets IA sans friction.

Prérequis

  • Node.js 20+ installé
  • Un compte gratuit sur console.mistral.ai pour obtenir une clé API
  • Connaissances basiques en JavaScript (async/await)
  • Éditeur de code comme VS Code

Initialiser le projet et installer les dépendances

terminal
mkdir mistral-api-demo
cd mistral-api-demo
npm init -y
npm install @mistralai/mistralai dotenv
npm install -D nodemon

Cette commande crée un projet Node.js vide, installe le SDK officiel Mistral pour des appels simplifiés et dotenv pour gérer la clé API en sécurité. nodemon est optionnel pour le développement (redémarrage auto). Exécutez-la dans votre terminal pour un setup prêt en 30 secondes.

Configurer la clé API

Créez un fichier .env à la racine :

``
MISTRAL_API_KEY=votre_cle_api_ici
`

Remplacez votre_cle_api_ici par la clé obtenue sur console.mistral.ai. Ajoutez .env à .gitignore` pour éviter de la commiter. Le SDK charge automatiquement cette variable via dotenv.

Premier appel : Chat completion simple

chat-simple.js
require('dotenv').config();
const { Mistral } = require('@mistralai/mistralai');

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

async function chatSimple() {
  const response = await client.chat.completions.create({
    model: 'mistral-tiny',
    messages: [
      {
        role: 'user',
        content: 'Explique-moi l\'IA en 3 phrases simples.'
      }
    ]
  });

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

chatSimple().catch(console.error);

Ce script complet envoie un message utilisateur au modèle 'mistral-tiny' (rapide et économique) et affiche la réponse. Utilisez async/await pour gérer les promesses. Lancez avec node chat-simple.js. Piège : vérifiez que .env est chargé avant l'instanciation du client.

Ajouter un prompt système

chat-system.js
require('dotenv').config();
const { Mistral } = require('@mistralai/mistralai');

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

async function chatAvecSystem() {
  const response = await client.chat.completions.create({
    model: 'mistral-tiny',
    messages: [
      {
        role: 'system',
        content: 'Tu es un assistant expert en programmation. Réponds de manière concise et technique.'
      },
      {
        role: 'user',
        content: 'Comment optimiser une boucle for en JavaScript ?'
      }
    ],
    max_tokens: 200
  });

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

chatAvecSystem().catch(console.error);

Le rôle 'system' définit le comportement du modèle, comme un coach technique ici. Ajoutez 'max_tokens' pour limiter la réponse et contrôler les coûts. Analogie : c'est comme donner des instructions à un employé avant la tâche. Testez avec node chat-system.js.

Gérer l'historique de conversation

Pour un chatbot réaliste, passez un tableau de messages avec rôles alternés (system, user, assistant). Cela maintient le contexte, améliorant la cohérence des réponses.

Conversation avec historique

chat-historique.js
require('dotenv').config();
const { Mistral } = require('@mistralai/mistralai');

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

async function conversation() {
  const messages = [
    {
      role: 'system',
      content: 'Tu es un guide touristique français.'
    },
    {
      role: 'user',
      content: 'Quels sont les meilleurs sites à Paris ?'
    },
    {
      role: 'assistant',
      content: 'La Tour Eiffel, le Louvre et Notre-Dame sont incontournables.'
    },
    {
      role: 'user',
      content: 'Plus de détails sur le Louvre ?'
    }
  ];

  const response = await client.chat.completions.create({
    model: 'open-mistral-nemo',
    messages: messages
  });

  console.log('Assistant:', response.choices[0].message.content);
}

conversation().catch(console.error);

L'historique simule une vraie conversation : le modèle 'voit' les échanges précédents. Utilisez 'open-mistral-nemo' pour plus de puissance. Mettez à jour 'messages' dynamiquement dans une app réelle. Évitez les historiques trop longs (>10k tokens) pour ne pas dépasser les limites.

Streaming des réponses en temps réel

chat-stream.js
require('dotenv').config();
const { Mistral } = require('@mistralai/mistralai');

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

async function chatStream() {
  const stream = await client.chat.completions.create({
    model: 'mistral-tiny',
    messages: [{ role: 'user', content: 'Raconte une histoire courte et effrayante.' }],
    stream: true
  });

  for await (const chunk of stream) {
    process.stdout.write(chunk.choices[0]?.delta?.content || '');
  }
  console.log('\n');
}

chatStream().catch(console.error);

Activez 'stream: true' pour recevoir les tokens au fur et à mesure, idéal pour les UIs réactives. Utilisez une boucle 'for await' pour itérer. Analogie : comme regarder un film se charger token par token. Lancez node chat-stream.js et voyez la magie.

Générer des embeddings

embeddings.js
require('dotenv').config();
const { Mistral } = require('@mistralai/mistralai');

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

async function genererEmbedding() {
  const response = await client.embeddings.create({
    model: 'mistral-embed',
    input: 'Recherche sémantique pour IA en français.'
  });

  const embedding = response.embeddings[0].embedding;
  console.log('Embedding (premiers 10 dims):', embedding.slice(0, 10));
  console.log('Dimension totale:', embedding.length);
}

genererEmbedding().catch(console.error);

Les embeddings convertissent du texte en vecteurs pour la similarité (ex: recherche). 'mistral-embed' produit des vecteurs de 1024 dims. Utiles pour RAG ou clustering. Ne surchargez pas avec des inputs trop longs (>512 tokens).

Bonnes pratiques

  • Toujours utiliser des variables d'environnement pour la clé API : jamais en dur dans le code.
  • Limitez les tokens avec max_tokens et surveillez les quotas via la console Mistral.
  • Gérez les erreurs avec try/catch et retry pour les rate limits (ex: exponential backoff).
  • Choisissez le modèle adapté : 'mistral-tiny' pour tests rapides, 'mistral-large' pour précision.
  • Cachez les réponses répétitives avec Redis pour scaler.

Erreurs courantes à éviter

  • Oublier dotenv.config() : la clé API est undefined, erreur 401.
  • Historique trop volumineux : dépasse la fenêtre de contexte (128k tokens max), tronque la réponse.
  • Ignorer les rate limits : 100 req/min, implémentez des queues.
  • Ne pas streamer pour les apps interactives : latence perçue élevée.

Pour aller plus loin

Maîtrisez les fine-tunings et agents avec nos formations Learni. Consultez la doc officielle Mistral, playground Mistral pour tester, ou explorez LangChain pour des chains complexes.

Comment utiliser l'API Mistral en 2026 (Node.js) | Learni