Intégrer un LLM dans votre application : le guide pratique

Vous avez une application qui tourne, et vous aimeriez lui ajouter une touche d’intelligence : résumer des messages, classer des tickets de support, générer une description produit ou répondre aux clients en français comme en wolof. Bonne nouvelle : intégrer un modèle de langage (LLM) ne demande plus de doctorat en machine learning. Il suffit d’appeler une API, comme vous appelez déjà celle d’un service de paiement.

Dans cet article, nous allons construire ensemble une intégration propre et professionnelle. Objectif clair : passer d’un simple appel « qui marche » à une fonction prête pour la production, avec prompts structurés, streaming, maîtrise des coûts et gestion des erreurs.

Étape 1 : le premier appel à l’API

La plupart des fournisseurs (Anthropic, OpenAI, Mistral, Cohere) exposent une API REST très similaire. On envoie une liste de messages, on récupère du texte. Commençons par installer le SDK et stocker la clé dans une variable d’environnement — jamais en dur dans le code.

pip install anthropic
export ANTHROPIC_API_KEY="sk-votre-cle-secrete"

Voici un premier appel minimal en Python. Notez la séparation entre le system prompt (qui définit le rôle et le comportement) et le message de l’utilisateur.

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

reponse = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=300,
    system="Tu es un assistant support pour une fintech d'Afrique de l'Ouest. "
           "Réponds en français, de façon concise et polie.",
    messages=[
        {"role": "user", "content": "Mon transfert vers Abidjan est bloqué depuis hier."}
    ],
)

print(reponse.content[0].text)

Étape 2 : structurer ses prompts

Un prompt jeté à la va-vite produit des réponses incohérentes. La clé d’une intégration fiable, c’est un prompt structuré. Quelques principes qui font la différence :

• Donnez un rôle précis dans le system prompt : « Tu es un classificateur de tickets », pas « Sois utile ».
• Délimitez les données de l’utilisateur avec des balises (par exemple <ticket>...</ticket>) pour éviter les injections de prompt.
• Imposez le format de sortie : demandez explicitement du JSON si votre code doit parser la réponse.
• Montrez un ou deux exemples (few-shot) quand la tâche est subtile.

Forcer une sortie exploitable par le code

Si vous classez des tickets, vous voulez une donnée propre, pas une phrase. Demandez un JSON strict et parsez-le :

import json

reponse = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=100,
    system="Classe le ticket dans une catégorie. "
           'Réponds UNIQUEMENT par un JSON : {"categorie": "...", "urgence": "haute|moyenne|basse"}.',
    messages=[
        {"role": "user", "content": "<ticket>Carte bloquée, je voyage demain !</ticket>"}
    ],
)

donnees = json.loads(reponse.content[0].text)
print(donnees["urgence"])  # -> "haute"

Conseil clé : ne faites jamais confiance aveuglément à la sortie d’un LLM. Entourez chaque json.loads() d’un bloc d’erreur et prévoyez une valeur par défaut. Un modèle peut toujours, un jour, renvoyer une phrase au lieu du JSON attendu.

Étape 3 : le streaming pour une meilleure expérience

Quand la réponse est longue, attendre 8 secondes l’écran figé est frustrant. Le streaming affiche le texte mot à mot, comme dans une conversation réelle. Côté serveur, on consomme un flux ; côté interface, on pousse chaque morceau vers le navigateur.

with client.messages.stream(
    model="claude-sonnet-4-5",
    max_tokens=500,
    messages=[{"role": "user", "content": "Explique le mobile money en 5 phrases."}],
) as flux:
    for fragment in flux.text_stream:
        print(fragment, end="", flush=True)

Dans une API web (FastAPI, Express), vous relayez ces fragments via Server-Sent Events ou WebSocket. L’utilisateur voit la réponse se construire : la latence perçue chute, même si le temps total reste identique.

Étape 4 : maîtriser les coûts

Chaque appel se facture au token (environ 4 caractères). Une intégration mal pensée peut faire exploser la facture. Voici les leviers concrets :

• Choisissez le bon modèle : un petit modèle rapide suffit pour classer ou résumer ; gardez les gros modèles pour le raisonnement complexe.
• Limitez max_tokens : ne demandez pas 4000 tokens si une réponse de 200 suffit.
• Raccourcissez le contexte : n’envoyez pas tout l’historique d’une conversation à chaque tour, seulement ce qui est utile.
• Mettez en cache les réponses aux questions fréquentes, et activez le prompt caching pour les system prompts longs et répétés.

L’objet réponse contient le détail de consommation : surveillez-le et loguez-le pour suivre vos dépenses au plus près.

print(reponse.usage.input_tokens, reponse.usage.output_tokens)

Étape 5 : une gestion d’erreurs robuste

Une API distante peut être lente, saturée (erreur 429) ou momentanément indisponible. En production, votre code doit absorber ces aléas sans planter l’application.

import time
from anthropic import APIError, RateLimitError

def appel_robuste(messages, tentatives=3):
    for essai in range(tentatives):
        try:
            return client.messages.create(
                model="claude-sonnet-4-5",
                max_tokens=300,
                messages=messages,
            )
        except RateLimitError:
            time.sleep(2 ** essai)  # backoff exponentiel : 1s, 2s, 4s
        except APIError as e:
            print(f"Erreur API : {e}")
            break
    return None  # déclenche votre réponse de secours

Le piège fréquent à éviter

L’erreur classique du débutant : appeler le LLM de façon synchrone au cœur d’une requête web, sans timeout ni plan B. Le jour où l’API met 30 secondes à répondre, toute votre application se fige. Mettez toujours un timeout, prévoyez une réponse de repli (message générique, mise en file d’attente) et, pour les tâches lourdes, déportez l’appel dans une file asynchrone (Celery, queue de jobs).

Cas d’usage concrets

Avec ces briques, vous couvrez l’essentiel des besoins réels d’une équipe ouest-africaine :

• Support client : pré-rédaction de réponses, classement automatique des tickets par urgence.
• E-commerce : génération de fiches produit et de descriptions SEO à partir de quelques mots-clés.
• Productivité : résumé de longs e-mails ou de comptes rendus de réunion.
• Data : extraction d’informations structurées (nom, montant, date) depuis des messages bruts.

Récapitulatif

Intégrer un LLM se résume à cinq réflexes : appeler proprement l’API avec la clé en variable d’environnement, structurer ses prompts (rôle, balises, format de sortie), activer le streaming pour le confort, surveiller les tokens pour le budget, et blinder le tout avec des retries, un timeout et une réponse de secours. Commencez petit, sur un seul cas d’usage bien délimité, mesurez la qualité et le coût, puis élargissez. C’est ainsi qu’une simple démo devient une fonctionnalité fiable dont vos utilisateurs ne pourront plus se passer.

Pour aller plus loin

• Sécuriser une API REST — JWT, HTTPS et bonnes pratiques OWASP.
• Automatiser vos tâches répétitives avec Python — scripts utiles, scraping, emails et cron.