Top 20 concepts IA dans les LLM : explications détaillées

1. Vue d’ensemble

Si vous êtes un développeur Java qui commence à intégrer des LLM (ChatGPT, Gemini, Claude…) dans votre système, vous allez rencontrer beaucoup de termes nouveaux : token, embedding, RAG, fine-tuning, hallucination… Cet article synthétise les 20 concepts IA les plus importants liés aux LLM, chacun avec une explication brève et des exemples illustratifs (principalement en Java/Spring AI). Après la lecture, vous aurez le vocabulaire nécessaire pour lire la documentation API d’OpenAI, Anthropic ou concevoir un système RAG de base.

2. Token et Tokenization

Les LLM ne lisent pas des « mots » mais des token — des unités plus petites qu’un mot, qui peuvent être un mot, une partie de mot, ou une ponctuation. La tokenization est l’étape qui découpe le texte en ces tokens avant de les envoyer au modèle.

Input:  "Spring Boot rất mạnh"
Tokens: ["Spring", " Boot", " rất", " mạnh"]  (4 tokens)

Le nombre de tokens détermine le coût de l’appel API (facturation par token) et la limite de longueur du input/output.

Note : Le vietnamien avec ses diacritiques est souvent divisé en plus de tokens que l’anglais pour la même phrase, donc le coût des appels API pour le contenu vietnamien est généralement plus élevé.

3. Embedding

Embedding consiste à transformer un morceau de texte en vecteur de nombres réels (par exemple, 1536 dimensions), de telle sorte que deux morceaux de texte ayant un sens proche aient des vecteurs proches. C’est le fondement de la recherche sémantique (semantic search).

EmbeddingModel embeddingModel = ...; // bean configuré automatiquement par Spring AI
EmbeddingResponse response = embeddingModel.embedForResponse(
        List.of("Khách hàng muốn hủy đơn hàng"));
float[] vector = response.getResult().getOutput();
System.out.println(vector.length); // 1536

embedForResponse appelle le modèle d’embedding et retourne le vecteur. Deux phrases « hủy đơn hàng » et « cancel order » auront des vecteurs proches malgré la différence de langue.

Pour comparer la proximité sémantique, on utilise la similarité cosinus :

double cosineSimilarity(float[] a, float[] b) {
    double dot = 0, normA = 0, normB = 0;
    for (int i = 0; i < a.length; i++) {
        dot += a[i] * b[i];
        normA += a[i] * a[i];
        normB += b[i] * b[i];
    }
    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
}

@Test
void similarVectorsShouldScoreHigh() {
    float[] a = {1f, 0f, 1f};
    float[] b = {1f, 0.1f, 0.9f};
    assertThat(cosineSimilarity(a, b)).isGreaterThan(0.95);
}

Une valeur proche de 1 signifie que les deux vecteurs (et donc les deux phrases) sont très proches sémantiquement.

4. Context Window

Context window est le nombre total maximum de tokens que le modèle « voit » dans un seul appel — incluant le prompt et la réponse. Dépasser cette limite, le modèle va tronquer la partie avant ou retourner une erreur.

GPT-4o:        128,000 tokens
Claude 3.5:    200,000 tokens
Gemini 1.5 Pro: 1,000,000 tokens

Pour une application de chatbot avec un long historique de conversation, vous devez activement découper/résumer l’ancien historique avant que le context window soit plein, sinon vous perdrez les informations du début de la conversation sans avertissement clair.

5. Prompt et Prompt Engineering

Prompt est le morceau de texte que vous envoyez à l’LLM pour lui demander de faire quelque chose. Prompt engineering est la technique de conception du prompt pour que le modèle réponde correctement, dans le format souhaité.

Tout d’abord, ajoutez la dépendance Spring AI :

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

@Service
class OrderSummaryService {
    private final ChatClient chatClient;

    OrderSummaryService(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    String summarize(String orderNote) {
        return chatClient.prompt()
                .user("Résumez la demande du client en 1 phrase: " + orderNote)
                .call()
                .content();
    }
}

ChatClient est un wrapper de Spring AI qui aide à appeler le modèle sans avoir à gérer HTTP manuellement. .user(...) définit le contenu du prompt, .call().content() retourne la chaîne de résultat.

6. System Prompt vs User Prompt

System prompt est les directives « implicites » qui définissent le rôle et les règles du modèle tout au long de la conversation ; user prompt est la question/demande spécifique de l’utilisateur.

chatClient.prompt()
        .system("Vous êtes un assistant de service client pour un magasin de chaussures. Répondez toujours brièvement et poliment.")
        .user("Quand ma commande #1023 sera-t-elle livrée ?")
        .call()
        .content();

System prompt ne doit être défini qu’une seule fois, user prompt change à chaque requête. Séparer ces deux types vous aide à contrôler la « personnalité » du modèle sans répéter les directives à chaque question.

7. Zero-shot, One-shot, Few-shot Learning

C’est la façon dont vous fournissez (ou ne fournissez pas) des exemples d’exemple dans le prompt pour que le modèle apprenne à répondre au format souhaité, sans avoir besoin de refaire le fine-tuning du modèle.

Zero-shot: Pas d'exemple, seulement la description de la demande.
Few-shot:  2-5 exemples input -> output modèle avant de poser la vraie question.

String fewShotPrompt = """
    Classez le sentiment de l'avis (positive/negative):
    Avis: "Livraison rapide, bonne qualité" -> positive
    Avis: "Produit défectueux, livraison retardée d'une semaine" -> negative
    Avis: "%s" ->
    """.formatted(userReview);

Few-shot donne généralement des résultats plus stables que zero-shot pour les tâches de classification/format spécifiques, mais en contrepartie consomme plus de tokens à chaque appel.

8. Chain-of-Thought (CoT)

CoT est une technique qui demande au modèle de « réfléchir étape par étape » avant de donner la réponse finale, ce qui augmente la précision pour les problèmes nécessitant du raisonnement (mathématiques, logique).

chatClient.prompt()
        .user("""
            Une commande a 3 produits au prix de 120k, 85k, 45k, réduction de 10%.
            Calculez étape par étape puis donnez le montant total final.
            """)
        .call()
        .content();

Quand on lui demande « étape par étape », le modèle a tendance à décomposer naturellement le problème en petits calculs, réduisant le risque d’erreur de calcul par rapport à une question directe « quel est le montant total ? ».

9. Temperature et Top-p

Temperature et top-p sont deux paramètres qui ajustent le degré « d’aléatoire » lors du choix du mot suivant par le modèle. Temperature basse → réponses cohérentes, répétitives ; élevée → plus créatif mais peut dévier du sujet.

ChatOptions options = OpenAiChatOptions.builder()
        .withTemperature(0.2)
        .withTopP(0.9)
        .build();

temperature = 0.0  -> approprié: extraction de données, réponses précises
temperature = 0.8  -> approprié: rédaction créative, brainstorming

Note : Pour les tâches nécessitant des résultats reproductibles (par exemple, les tests automatisés), définissez temperature = 0 pour réduire la variabilité entre les appels.

10. Attention Mechanism

Attention est le mécanisme qui permet au modèle, lors du traitement d’un mot, de « regarder » tous les autres mots de la phrase et de calculer automatiquement les poids pour voir quel mot est le plus pertinent. C’est pourquoi le modèle comprend le contexte distant, par exemple, le pronom « nó » (il) peut se rapporter à quel nom.

Phrase : « Đơn hàng bị hủy vì khách đổi ý, nó đã được hoàn tiền. »
Attention aide le modèle à lier « nó » -> « Đơn hàng », pas « khách ».

Vous n’écrivez pas directement le code de l’attention lors de l’utilisation d’une API, mais la comprendre aide à expliquer pourquoi le modèle « oublie » parfois le contexte à une distance lointaine ou très long.

11. Transformer Architecture

Transformer est l’architecture de réseau de neurones fondamentale de presque tous les LLM actuels, utilisant l’attention pour traiter la phrase entière en parallèle au lieu de séquentiellement comme les anciens RNN, permettant un entraînement plus rapide sur des données massives.

Input tokens -> Embedding -> [Attention + Feed-Forward] x N layers -> Output probabilities

Le nombre de layers (N) et le nombre de paramètres (parameters) détermine la « taille » du modèle — GPT-4, Claude, Llama sont tous des variantes de Transformer avec un nombre différent de layers et des approches d’entraînement différentes.

12. Fine-tuning

Fine-tuning consiste à entraîner davantage un modèle déjà formé (pretrained) sur vos propres données, afin qu’il se spécialise dans une tâche spécifique (par exemple, répondre au ton de marque correct).

{"messages": [
  {"role": "user", "content": "La commande #203 a-t-elle été livrée ?"},
  {"role": "assistant", "content": "Oui, la commande #203 est en cours de livraison, elle devrait arriver aujourd'hui."}
]}

Ce fichier JSONL est une ligne de données d’entraînement d’exemple pour le fine-tuning — chaque ligne est une paire de conversation d’exemple, en envoyant des milliers de lignes comme celle-ci à l’API de fine-tuning du provider.

Quand NE PAS utiliser : si vous avez seulement besoin que le modèle suive quelques règles simples, le prompt engineering ou RAG est bien moins cher et plus rapide que le fine-tuning.

13. LoRA (Low-Rank Adaptation)

LoRA est une technique de fine-tuning économe : au lieu de mettre à jour des dizaines de milliards de paramètres du modèle d’origine, LoRA n’entraîne que quelques petites matrices « insérées » dans les couches, en gardant le modèle d’origine inchangé.

Modèle d'origine : 7 milliards de paramètres (gelés, inchangés)
Adaptateur LoRA : ~10-50 millions de paramètres (entraînés)

Grâce à cela, LoRA permet de fine-tuner un grand modèle sur un GPU ordinaire, et on peut « retirer/attacher » plusieurs adaptateurs différents pour plusieurs cas d’usage sur le même modèle de base.

14. Quantization

Quantization consiste à réduire la précision numérique des paramètres du modèle (par exemple de float32 à int8/int4) pour réduire la taille et augmenter la vitesse d’inférence, en échange d’une légère perte de précision.

FP32: 7B params x 4 bytes = ~28 GB RAM
INT4: 7B params x 0.5 byte = ~3.5 GB RAM

Quantization est la raison pour laquelle vous pouvez exécuter un LLM de 7 milliards de paramètres sur un ordinateur portable ordinaire au lieu d’avoir besoin d’un serveur GPU dédié — en échange, la qualité des réponses diminue légèrement.

15. RAG (Retrieval-Augmented Generation)

RAG est une technique qui combine la recherche (retrieval) de données internes avec LLM : avant de répondre, le système trouve les passages de texte les plus pertinents (via embedding) et les ajoute au prompt comme « contexte », aidant le modèle à répondre en fonction de vos données propres sans avoir besoin de fine-tuning.

List<Document> relevantDocs = vectorStore.similaritySearch(
        SearchRequest.query("politique de retour et d'échange").withTopK(3));

String context = relevantDocs.stream()
        .map(Document::getContent)
        .collect(Collectors.joining("\n---\n"));

String answer = chatClient.prompt()
        .system("Répondez uniquement en fonction du contexte fourni.")
        .user("Contexte:\n" + context + "\n\nQuestion : Combien de jours pour retour et échange ?")
        .call()
        .content();

similaritySearch trouve les 3 passages de documents les plus pertinents sémantiquement avec la question, les fusionne dans le prompt puis l’envoie au modèle. Grâce à cela, la réponse colle à votre politique réelle, pas aux connaissances « générales » que le modèle a apprises lors du pretraining.

16. Vector Database

Vector database est l’endroit où sont stockés les embeddings avec les métadonnées, supportant une recherche rapide des « k plus proches voisins » (k-NN) sur des millions de vecteurs — un composant essentiel pour que RAG fonctionne à grande échelle (Pinecone, Milvus, PGVector…).

CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT,
    embedding VECTOR(1536)
);

SELECT content FROM documents
ORDER BY embedding <-> '[0.01, -0.02, ...]'
LIMIT 3;

L’opérateur <-> (fourni par l’extension pgvector) calcule la distance entre le vecteur de la question et les vecteurs stockés, retournant les enregistrements les plus proches — c’est exactement l’étape similaritySearch du point 15.

17. Function Calling / Tool Use

Function calling permet à l’LLM de « demander » à votre application d’appeler une fonction spécifique (rechercher un prix, rechercher la météo, interroger la DB) quand elle le juge nécessaire, au lieu de fabriquer les données.

@Tool(description = "Obtenir le statut de la commande par le numéro de commande")
String getOrderStatus(String orderId) {
    return orderRepository.findStatusById(orderId);
}

chatClient.prompt()
        .user("Quel est le statut de la commande #1023 ?")
        .tools(this)
        .call()
        .content();

Lors de l’envoi de la question, le modèle reconnaît automatiquement qu’il doit appeler getOrderStatus, Spring AI exécute la vraie fonction Java, récupère le résultat puis le renvoie au modèle pour composer la réponse finale — le modèle n’a plus besoin de « deviner » le statut de la commande.

18. AI Agent

Agent est un système qui utilise l’LLM comme « cerveau » pour planifier automatiquement, appeler plusieurs outils en séquence, observer les résultats et réitérer jusqu’à atteindre l’objectif — différent d’un chatbot qui répond une seule fois.

Utilisateur : "Vérifiez la commande #1023, si elle est en retard de plus de 3 jours, envoyez un email d'excuses au client."

L'agent exécute automatiquement :
1. Appeler l'outil getOrderStatus("1023")
2. Calculer le nombre de jours de retard
3. Si > 3 -> appeler l'outil sendEmail(...)
4. Retourner le rapport à l'utilisateur

Agent est généralement construit avec une boucle « penser → agir → observer » (modèle ReAct), combinant plusieurs function calling successifs pour gérer une tâche à plusieurs étapes.

19. Hallucination

Hallucination est quand le modèle répond avec confiance mais l’information est fausse ou complètement fabriquée — par exemple, citer une loi inexistante, ou confondre une API qui n’existe pas vraiment.

Utilisateur : "Comment fonctionne l'API `OrderService.cancelAndRefund()` ?"
Modèle : "Cette méthode rembourse automatiquement dans 24h..." (mais cette méthode n'existe pas dans la codebase)

Le moyen le plus courant de réduire les hallucinations est d’utiliser RAG (point 15) pour que le modèle se cram aux documents réels, et de demander au modèle de répondre « je ne sais pas » quand le contexte n’a pas assez d’informations, au lieu de simplement déduire.

20. Guardrails

Guardrails est un ensemble de couches de contrôle (filtrer input/output, valider le format, bloquer le contenu sensible) placées autour de l’LLM pour s’assurer que le système est sûr et conforme avant de retourner le résultat à l’utilisateur final.

String output = chatClient.prompt().user(userInput).call().content();

if (containsPersonalData(output) || !isValidJson(output)) {
    throw new UnsafeModelOutputException("La sortie ne respecte pas les normes guardrail");
}

Les guardrails peuvent être placés à l’input (bloquer prompt injection, contenu nuisible) ou à l’output (vérifier le format JSON, masquer les numéros de carte bancaire) — cette étape ne doit pas être ignorée quand déployer LLM en production, même si le modèle « semble » répondre correctement lors de la démo.

21. RLHF (Reinforcement Learning from Human Feedback)

RLHF est une technique d’entraînement du modèle basée sur les retours humains : les humains classent plusieurs réponses du modèle, puis entraînent un « modèle de récompense » pour continuer à optimiser le modèle d’origine afin qu’il réponde de manière plus utile et sûre.

Étape 1 : Le modèle génère 3-4 réponses pour la même question
Étape 2 : L'humain classe : le meilleur -> le pire
Étape 3 : Entraîner le modèle de récompense pour apprendre à « noter » comme les humains
Étape 4 : Utiliser le modèle de récompense pour fine-tuner l'LLM via l'apprentissage par renforcement

RLHF est la raison pour laquelle ChatGPT, Claude répondent avec un « ton » poli et refusent les demandes dangereuses — contrairement au modèle d’origine qui n’a été entraîné que pour simplement « prédire le mot suivant ».

22. Conclusion

Les 20 concepts ci-dessus constituent le vocabulaire minimal pour travailler sérieusement avec les LLM : des niveaux bas (token, embedding, attention) aux niveaux d’application (RAG, function calling, agent, guardrails). Vous n’avez pas besoin de comprendre profondément les mathématiques de Transformer pour intégrer LLM dans votre système Spring Boot, mais comprendre correctement ces concepts vous aide à choisir la bonne solution — par exemple, savoir quand utiliser RAG au lieu du fine-tuning, quand avoir besoin de guardrails au lieu de faire confiance aveuglément à la sortie du modèle.