LLM : définition, fonctionnement et usages des grands modèles

Un LLM est un modèle de langage de très grande taille : un réseau de neurones de plusieurs milliards de paramètres, entraîné sur une part considérable du texte disponible pour une seule tâche apparemment modeste, prédire le morceau de texte suivant. Ces morceaux, appelés tokens, sont des mots ou des fragments de mots. En apprenant à bien prédire le token suivant sur des milliers de milliards d'exemples, le modèle finit par capter la grammaire, le vocabulaire, des faits sur le monde, des styles d'écriture et une forme de raisonnement.

Techniquement, presque tous les LLM reposent sur l'architecture Transformer dans sa variante « décodeur seul ». Leur histoire récente est courte : OpenAI publie GPT en 2018, GPT-3 en 2020 montre qu'un modèle de 175 milliards de paramètres peut accomplir une tâche à partir de quelques exemples dans le prompt, et le lancement de ChatGPT en novembre 2022 fait découvrir le principe au grand public. Depuis, les fournisseurs se sont multipliés et les modèles sont devenus multimodaux, capables de lire des images ou des documents.

Un LLM est le cas le plus connu de modèle de fondation : un modèle généraliste, entraîné une fois à grand coût, que l'on adapte ensuite à des milliers d'usages. À l'autre bout du spectre, les SLM (Small Language Models) reprennent les mêmes principes dans un format compact, exécutable sur un poste de travail.

À retenir : un LLM ne consulte pas une base de faits. Il génère, token après token, la suite la plus probable compte tenu de ce qu'il a appris et du contexte que vous lui fournissez.

À l'inférence, un LLM ne voit que ce qui tient dans sa fenêtre de contexte : instructions système, historique de la conversation, documents ajoutés et réponse en cours de génération. Cette fenêtre se mesure en tokens. Elle varie de quelques milliers à plusieurs centaines de milliers de tokens selon les modèles, mais une fenêtre plus large ne garantit pas que le modèle exploite aussi bien toute l'information : les détails noyés au milieu d'un long contexte sont plus facilement ignorés. Choisir ce qui entre dans le contexte est devenu une discipline à part entière, le context engineering.

Quelques paramètres pilotent la génération :

• Température : proche de 0, le modèle choisit presque toujours le token le plus probable (réponses stables, adaptées à l'extraction) ; plus élevée, il explore davantage (utile pour la créativité).
• Nombre maximal de tokens : plafonne la longueur de la réponse, donc le coût et la latence.
• Message système : fixe le rôle, le ton, les règles et le format de sortie attendu.
• Sortie structurée : la plupart des API savent contraindre la réponse à un schéma JSON, ce qui fiabilise l'intégration dans un programme.

Le coût d'un appel suit directement le nombre de tokens en entrée et en sortie. Une application qui renvoie tout l'historique à chaque message voit donc sa facture croître avec la longueur des conversations.

La plupart des fournisseurs et des serveurs d'inférence exposent une interface compatible avec celle d'OpenAI, dite « chat completions ». Le même code peut ainsi interroger une API commerciale ou un modèle ouvert servi en local par Ollama ou en production par vLLM : seuls l'adresse, la clé et le nom du modèle changent.

import os
from openai import OpenAI

# Par défaut : un modèle ouvert servi en local par Ollama.
# Pour une API commerciale, renseignez LLM_BASE_URL, LLM_API_KEY et LLM_MODEL.
client = OpenAI(
    base_url=os.getenv("LLM_BASE_URL", "http://localhost:11434/v1"),
    api_key=os.getenv("LLM_API_KEY", "ollama"),
)
model = os.getenv("LLM_MODEL", "mistral")

response = client.chat.completions.create(
    model=model,
    temperature=0.2,
    max_tokens=300,
    messages=[
        {
            "role": "system",
            "content": "Tu es un assistant RH. Réponds en trois phrases maximum.",
        },
        {
            "role": "user",
            "content": "Comment poser un jour de télétravail exceptionnel ?",
        },
    ],
)

print(response.choices[0].message.content)
print("Tokens en entrée :", response.usage.prompt_tokens)
print("Tokens en sortie :", response.usage.completion_tokens)

Trois éléments sont à retenir. Le message système encadre le comportement du modèle. La température basse rend les réponses plus reproductibles. Enfin, l'objet usage renvoie le nombre de tokens consommés : c'est la donnée de base pour suivre les coûts. Sans document fourni, le modèle répond ici avec ses connaissances générales ; pour qu'il s'appuie sur la politique réelle de l'entreprise, il faut lui transmettre les bons passages, ce que fait un RAG.

Le marché évolue tous les trimestres, mais quelques acteurs structurent l'offre. Les noms de versions changent vite : mieux vaut raisonner par familles et vérifier les modèles disponibles au moment du choix.

D'autres éditeurs, notamment Alibaba avec Qwen ou DeepSeek, publient aussi des modèles à poids ouverts très suivis. Le bon choix ne se lit pas dans un classement public : il se mesure sur un jeu de questions représentatif de vos propres tâches, en comparant qualité, latence et coût.

Un modèle « ouvert » met ses poids à disposition : vous pouvez le télécharger, l'héberger et le modifier, dans les limites de sa licence. Un modèle propriétaire n'est accessible qu'à travers l'API ou l'application de son éditeur.

En pratique, de nombreuses équipes réservent les modèles propriétaires les plus puissants aux tâches difficiles et confient les tâches répétitives ou sensibles à un modèle ouvert, parfois un SLM, hébergé en interne.