Ollama : Comment interroger un LLM en JavaScript/NodeJS ?

Les modèles de langage de grande taille (LLM) transforment la manière dont nous interagissons avec l’intelligence artificielle. Jusqu’ici, exploiter ces modèles nécessitait souvent une connexion à des services cloud payants. Mais une solution open source change la donne : Ollama.

Avec Ollama, vous pouvez télécharger des modèles de langage (comme Llama de Meta ou Mistral), les exécuter localement sur votre ordinateur ou sur un serveur, et les interroger depuis vos propres programmes. Dans cet article, nous allons découvrir comment utiliser Ollama en TypeScript pour dialoguer avec un LLM, construire une petite API et même l’intégrer dans une application web.

Qu’est-ce que Ollama ?

Ollama en tant qu’application de bureau

L’application peut être installée sur votre ordinateur comme une app classique. Disponible pour macOS, Windows et Linux, il vous permet de :

• télécharger et gérer des modèles de langage,
• discuter avec eux directement en ligne de commande,
• créer un environnement local sans dépendre du cloud.

Son intérêt est double : vous gardez le contrôle de vos données (elles restent sur votre machine) et vous pouvez travailler gratuitement avec des modèles puissants.

Ollama en tant qu’application web sur serveur

Ollama peut aussi être déployé sur un serveur. Dans ce cas, il agit comme un service accessible en local ou à distance via API. Vous pouvez l’intégrer dans vos projets professionnels ou vos applications internes. Cela permet de créer des assistants personnalisés ou des outils métiers capables de dialoguer avec du texte.

En résumé, l’application peut être utilisé comme une app de bureau pour l’expérimentation personnelle ou comme une brique serveur pour des projets web.

Installation et commandes de base

Installation d’Ollama

Téléchargez Ollama depuis le site officiel, puis installez-le comme n’importe quel logiciel. Une fois installé, vous avez accès à la commande ollama dans votre terminal.

Gestion des modèles

Les modèles doivent être téléchargés avant de pouvoir être utilisés. Ollama propose une bibliothèque variée :

Lister les modèles installés :

ollama list

Télécharger un modèle :

ollama pull llama3.2

Lancer un modèle :

ollama run llama3.2

Arrêter un modèle :

ollama stop llama3.2

Supprimer un modèle :

ollama rm llama3.2

Vous pouvez préciser une version spécifique, par exemple ollama pull llama3.2:1b pour un modèle de 1 milliard de paramètres.

Interroger un modèle en TypeScript

Entrons dans la pratique. Nous allons créer un petit projet Node.js avec TypeScript pour interagir avec l’IA de Meta : llama 3.2.

Initialisation du projet

Créez un dossier, puis exécutez :

npm init -y
npm install ollama typescript ts-node @types/node
npx tsc --init

Exemple minimal avec TypeScript

Créons un fichier app.ts :

import ollama from "ollama";

async function main() {
  const response = await ollama.chat({
    model: "llama3.2",
    messages: [
      { role: "user", content: "Peux-tu expliquer ce qu’est un LLM en termes simples ?" }
    ],
  });

  console.log("Réponse du modèle :", response.message.content);
}

main();

Lancez ensuite :

npx ts-node app.ts

Le modèle vous répondra directement dans votre terminal.

Récupérer la réponse en streaming

Pour améliorer l’expérience, l’API peut envoyer sa réponse au fur et à mesure qu’elle est générée. Cela donne un effet de conversation en direct.

Exemple en TypeScript :

import ollama from "ollama";

async function main() {
  const message = { role: "user", content: "Donne-moi une brève histoire de l’intelligence artificielle." };
  const response = await ollama.chat({
    model: "llama3.2",
    messages: [message],
    stream: true
  });

  for await (const part of response) {
    process.stdout.write(part.message.content);
  }
}

main();

Cette approche est particulièrement intéressante pour des interfaces interactives comme des chatbots.

Construire une API avec Express et TypeScript

Pour aller plus loin, nous allons créer un serveur HTTP qui interroge Ollama et renvoie les réponses.

Installer Express

npm install express @types/express

Exemple de serveur TypeScript

Fichier server.ts :

import express, { Request, Response } from "express";
import ollama from "ollama";

const app = express();
const port = 3000;

app.use(express.json());

app.post("/chat", async (req: Request, res: Response) => {
  const message = { role: "user", content: req.body.content };
  const response = await ollama.chat({
    model: "llama3.2",
    messages: [message],
    stream: true,
  });

  res.writeHead(200, {
    "Content-Type": "text/event-stream",
    "Cache-Control": "no-cache",
    Connection: "keep-alive",
  });

  for await (const part of response) {
    res.write(`data: ${JSON.stringify(part.message)}\n\n`);
  }

  res.end();
});

app.listen(port, () => {
  console.log(`Serveur en cours d’exécution sur http://localhost:${port}`);
});

Vous pouvez maintenant lancer le serveur et l’interroger depuis une page web ou un client HTTP.

Créer une interface web

Pour tester rapidement, créez un fichier public/index.html :

<!doctype html>
<html lang="fr">
<head>
  <meta charset="UTF-8">
  <title>Chat IA avec Ollama</title>
</head>
<body>
  <h1>Dialogue avec Ollama</h1>
  <form>
    <input id="message" type="text" placeholder="Écrivez votre question...">
    <button type="submit">Envoyer</button>
  </form>
  <div id="reponse"></div>

  <script>
    const form = document.querySelector("form");
    const input = document.getElementById("message");
    const output = document.getElementById("reponse");

    form.addEventListener("submit", async (e) => {
      e.preventDefault();
      const content = input.value.trim();
      if (!content) return;
      output.textContent = "Réflexion en cours...";

      const response = await fetch("/chat", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ content }),
      });

      output.textContent = "";
      const reader = response.body.getReader();
      const decoder = new TextDecoder();

      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        const lines = decoder.decode(value).split("\n");
        for (const line of lines) {
          if (line.startsWith("data: ")) {
            const data = JSON.parse(line.slice(6));
            output.textContent += data.content;
          }
        }
      }
    });
  </script>
</body>
</html>

Démarrez ensuite le serveur et ouvrez votre navigateur. Vous pourrez taper des questions et voir les réponses s’afficher en direct.

Bonnes pratiques et perspectives

Optimisation des performances

• Utilisez des modèles adaptés à la puissance de votre machine. Un modèle léger (1B paramètres) répond plus vite qu’un modèle plus lourd.
• Sur serveur, assurez-vous de dimensionner la mémoire vive et le GPU si disponible.

Cas d’usage possibles

• Chatbots personnalisés pour sites web,
• Outils internes d’assistance (aide à la rédaction, FAQ, génération de code),
• Applications éducatives pour vulgariser des concepts,
• Expérimentations en recherche.

Vers le futur

Les navigateurs intègrent progressivement des technologies comme WebGPU permettant d’exécuter des LLM directement côté client. Ollama est donc une solution idéale pour expérimenter aujourd’hui et préparer les usages de demain.

Conclusion

Il est donc possible d’interroger un LLM en TypeScript de manière simple et efficace. Qu’il soit installé en tant qu’application de bureau ou déployé comme application web sur serveur, Ollama offre une grande souplesse.

Nous avons vu comment installer l’outil, gérer les modèles, écrire des scripts TypeScript, récupérer des réponses en streaming et construire une petite application web interactive. Cette approche ouvre la voie à de nombreux projets : assistants intelligents, applications éducatives, prototypes métiers et explorations personnelles.

Ollama démocratise l’accès aux modèles de langage locaux et permet à chacun d’expérimenter l’intelligence artificielle sans dépendre des grandes plateformes cloud.