Ces quinze définitions suffisent à comprendre tout le reste du guide. Prenez le temps de les lire : la plupart des difficultés rencontrées ensuite viennent d’un mot mal compris ici.

Intelligence artificielle générative

Un programme qui produit du contenu nouveau (texte, image, code) au lieu de simplement chercher une information existante. Il ne copie pas une réponse dans une base de données : il la compose mot après mot.

Modèle de langage (LLM)

Le moteur derrière la conversation. Il a été entraîné à prédire, à partir d’un texte donné, quelle suite est la plus plausible. Répétée des milliers de fois, cette prédiction produit des phrases, des raisonnements et du code.

LLM = « Large Language Model », grand modèle de langage.

Claude

La famille de modèles de langage développée par la société Anthropic. « Claude » désigne aussi bien le modèle que l’application dans laquelle on discute avec lui.

Prompt

Le message que vous écrivez. C’est le mot technique pour « la consigne » ou « la demande ». La qualité de la réponse dépend directement de la qualité du prompt — c’est le sujet de la section 05.

Conversation (ou thread)

Une suite de messages entre vous et Claude. Dans une même conversation, Claude se souvient de tout ce qui a été dit. Dans une nouvelle conversation, il repart de zéro.

Contexte

L’ensemble de ce que Claude « a sous les yeux » au moment de répondre : votre message, les messages précédents, les fichiers joints, les instructions du projet. Hors du contexte, il ne sait rien.

Token

L’unité de découpage du texte. Un token ≈ 4 caractères ≈ trois quarts d’un mot français. « Bonjour tout le monde » ≈ 6 tokens. Une page A4 ≈ 600 à 800 tokens.

Pourquoi c’est important : tout se compte et se facture en tokens.

Fenêtre de contexte

La quantité maximale de tokens que le modèle peut prendre en compte d’un coup — mémoire de travail comprise. Les modèles Claude 5 acceptent 1 million de tokens, soit environ 2 500 pages. Au-delà, il faut découper.

Modèle / version

Claude existe en plusieurs tailles : Haiku (rapide et économique), Sonnet (équilibré), Opus et Fable (les plus capables, pour les tâches complexes). Le nom est suivi d’un numéro de génération.

Hallucination

Une réponse fausse énoncée avec assurance : une référence juridique inventée, un chiffre plausible mais inexact. C’est le défaut structurel des modèles de langage. Toute donnée factuelle sensible doit être vérifiée.

Date de connaissance

Le modèle a été entraîné sur des données arrêtées à une certaine date. Il ignore ce qui s’est passé après, sauf si on lui donne l’information ou s’il peut chercher sur le web.

API

« Application Programming Interface » : une porte d’entrée technique qui permet à un programme (et non un humain) de dialoguer avec Claude. C’est ce qui permet d’automatiser et de traiter des volumes.

Clé API

Un mot de passe technique, long et unique, qui identifie votre compte lorsqu’un programme appelle l’API. Elle est strictement personnelle et ne doit jamais être partagée ni publiée.

SDK

Une bibliothèque de code prête à l’emploi qui simplifie l’usage de l’API. Le SDK Python d’Anthropic s’appelle anthropic et s’installe en une commande.

Python

Un langage de programmation réputé lisible, très utilisé pour l’automatisation et l’analyse de données. C’est la voie la plus courte pour piloter Claude par programme — voir sections 09 à 12.

Elles ne s’adressent pas au même profil et ne se paient pas de la même manière. Identifier la bonne voie évite beaucoup de temps perdu.

L’application se trouve sur claude.com dans un navigateur, et existe aussi en application Windows, macOS, iOS et Android. La connexion se fait par adresse e-mail ou compte Google.

Anatomie de l’écran

1. La zone de saisie, en bas

   C’est là que vous écrivez. Entrée envoie le message ; Maj + Entrée passe à la ligne sans envoyer. Le bouton « + » à gauche (ou un simple glisser-déposer) joint un fichier : PDF, Word, Excel, images, CSV, code.

2. Le sélecteur de modèle

   Près de la zone de saisie, un menu permet de choisir la version de Claude. En cas de doute, gardez le modèle proposé par défaut : il convient à la grande majorité des usages. Passez à un modèle plus puissant pour l’analyse longue ou le raisonnement complexe, à un modèle rapide pour des tâches simples et répétitives.

3. La barre latérale gauche

   Elle contient le bouton Nouvelle conversation, l’historique de vos échanges (recherchable), et vos Projets. On peut renommer, épingler ou supprimer une conversation via le menu « … » à côté de son titre.

4. La réponse

   Sous chaque réponse : copier, régénérer, et un pouce pour signaler la qualité. Vous pouvez aussi modifier votre propre message et le renvoyer — Claude repartira de cette version corrigée plutôt que d’empiler une correction.

5. Le panneau latéral droit

   Quand Claude produit un document, un tableau, une page web ou un visuel, celui-ci s’ouvre dans un panneau à part : c’est un artefact. Il reste modifiable, téléchargeable et partageable, sans polluer le fil de la discussion.

Les fonctions qui changent tout

L’application fonctionne par abonnement forfaitaire. L’API, elle, se paie à la consommation : ce sont deux porte-monnaie différents, et un abonnement ne donne pas de crédits API.

Tarifs hors taxes, exprimés en dollars, susceptibles d’évoluer — à confirmer sur la page tarifs officielle avant tout engagement.

Comprendre les limites d’usage

Il n’y a pas de « nombre de messages » fixe. La limite dépend du volume de tokens consommés sur une fenêtre glissante de quelques heures : dix questions courtes coûtent bien moins qu’une seule analyse de rapport de 80 pages. Trois leviers pour tenir dans son forfait :

• Ouvrir une nouvelle conversation plutôt que de prolonger un fil très long.
• Ne joindre que les pages ou les extraits vraiment utiles d’un document.
• Réserver les modèles les plus puissants aux tâches qui les justifient.

C’est la compétence qui sépare un usage décevant d’un usage réellement productif. Elle s’apprend en quelques minutes et se résume à cinq ingrédients.

Les cinq ingrédients d’un bon prompt

Avant / après

Quatre techniques qui font la différence

1. Itérer plutôt que tout viser du premier coup

   Demandez d’abord un plan, validez-le, puis demandez la rédaction. Trois échanges courts donnent presque toujours un meilleur résultat qu’un seul prompt monumental.

2. Découper les tâches complexes

   « Analyse ces 40 réponses, puis synthétise, puis fais une présentation » est trop d’un coup. Faites-en trois demandes successives, chacune vérifiable.

3. Séparer visuellement les données de la consigne

   Encadrez le texte à traiter par des balises simples, par exemple <texte>…</texte>. Claude distingue alors sans ambiguïté ce qu’il doit lire de ce qu’il doit faire.

4. Demander le raisonnement avant la conclusion

   « Explique d’abord ton analyse, puis donne ta recommandation. » La qualité de la conclusion augmente nettement lorsque le raisonnement la précède.

Six erreurs fréquentes

• Rester vague — « améliore ce texte » : améliorer dans quel sens ? Plus court, plus formel, plus percutant ?
• Ne pas donner la matière — poser une question sur un document sans le joindre.
• Empiler les sujets dans une même conversation.
• Accepter la première réponse au lieu de demander une variante ou une critique.
• Attendre des chiffres exacts sans source : demandez plutôt à Claude de chercher et de citer ses sources.
• Oublier de dire à qui l’on s’adresse — un même contenu ne s’écrit pas pareil pour un client, un stagiaire ou un dirigeant.

Un usage professionnel sérieux suppose deux réflexes : contrôler les faits, et maîtriser ce que l’on transmet.

Toujours vérifier

• Les chiffres, dates, montants et pourcentages.
• Les références : articles de loi, normes, publications, citations attribuées à quelqu’un.
• Les liens : une URL peut être plausible et pourtant ne pas exister.
• Les calculs présentés dans un texte, surtout s’ils sont enchaînés.

Ce que Claude fait bien, et moins bien

Deuxième partie du guide. Elle s’adresse à qui veut automatiser. Elle reste lisible sans expérience de la programmation : chaque ligne de code est expliquée.

Une analogie

L’application, c’est un restaurant : vous vous asseyez, vous commandez, on vous sert. L’API, c’est la cuisine ouverte aux professionnels : vous passez commande par un programme, dans un format précis, et vous récupérez le plat brut — à vous de le présenter. En échange, vous pouvez commander mille plats par heure sans vous asseoir.

Les modèles disponibles et leur coût

Le prix s’exprime en dollars par million de tokens (MTok), séparément pour ce que vous envoyez (entrée) et ce que Claude produit (sortie). La sortie coûte toujours plus cher que l’entrée.

Commencez par Sonnet : c’est le meilleur compromis vitesse / capacité / prix. Passez à Haiku pour du tri ou de la classification en masse, à Opus ou Fable pour du raisonnement long et complexe.

Combien ça coûte, concrètement

Résumer un document de 10 pages (≈ 7 000 tokens en entrée) et produire une synthèse d’une page (≈ 700 tokens en sortie) avec Sonnet :

Soit environ 2 centimes par document, ou 20 $ pour mille documents. C’est ce calcul qui décide si un traitement automatisé vaut la peine.

Étape obligatoire avant la moindre ligne de code. Comptez cinq minutes.

1. Créer un compte sur la Console

   Rendez-vous sur platform.claude.com et créez un compte. C’est un compte distinct de l’abonnement à l’application, même si l’adresse e-mail est la même.

2. Créditer le compte

   L’API fonctionne par prépaiement. Ajoutez un petit crédit initial (quelques dollars suffisent largement pour apprendre) dans la section facturation.

3. Générer la clé

   Dans Settings → API keys, cliquez sur « Create key ». La clé commence par sk-ant-.

4. La copier immédiatement

   Elle ne s’affiche qu’une seule fois. Si vous la perdez, il faut en créer une autre et révoquer l’ancienne.

5. La stocker hors du code

   Une clé écrite en dur dans un fichier finit tôt ou tard publiée par erreur. On la met dans une variable d’environnement — voir ci-dessous.

export ANTHROPIC_API_KEY="sk-ant-votre-cle-ici"

# Pour la conserver d'une session à l'autre, ajoutez cette ligne
# à la fin du fichier ~/.zshrc (ou ~/.bashrc), puis rouvrez le terminal.

setx ANTHROPIC_API_KEY "sk-ant-votre-cle-ici"

REM setx enregistre la variable de façon permanente.
REM Fermez puis rouvrez la fenêtre pour qu'elle soit prise en compte.

De l’installation de Python au premier appel réussi. Chaque commande est à taper telle quelle.

Préparer l’environnement

1. Vérifier que Python est installé

   Ouvrez un terminal et tapez la commande ci-dessous. Si un numéro de version 3.8 ou supérieur s’affiche, tout va bien ; sinon, installez Python depuis python.org.

   TerminalCopier

   python3 --version

2. Créer un dossier de travail isolé

   Un « environnement virtuel » évite que les bibliothèques d’un projet perturbent les autres. Ce n’est pas obligatoire, mais c’est une bonne habitude.

   TerminalCopier

   mkdir mon-projet-claude
   cd mon-projet-claude
   python3 -m venv .venv
   
   # Activation — macOS / Linux :
   source .venv/bin/activate
   # Activation — Windows :
   .venv\Scripts\activate

3. Installer le SDK

   Une seule bibliothèque à installer. pip est le gestionnaire de paquets de Python.

   TerminalCopier

   pip install anthropic

Le programme minimal

Créez un fichier premier_appel.py avec ce contenu, puis lancez-le par python3 premier_appel.py.

import os
from anthropic import Anthropic

# 1. On crée le "client" : l'objet qui sait parler à l'API.
#    La clé est lue dans la variable d'environnement, jamais écrite ici.
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

# 2. On envoie une demande et on attend la réponse.
message = client.messages.create(
    model="claude-sonnet-5",      # quel modèle répond
    max_tokens=1000,              # longueur maximale de la réponse
    messages=[                    # la conversation, ici un seul message
        {"role": "user", "content": "Explique en trois phrases ce qu'est une facture d'acompte."}
    ],
)

# 3. On affiche le texte produit.
print(message.content[0].text)

Décoder ces lignes

Cinq réglages suffisent à couvrir la quasi-totalité des besoins.

question = "Notre client conteste un devis signé il y a trois mois. Quelles pièces réunir ?"

message = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1500,
    temperature=0.2,
    system=(
        "Tu es assistant juridique dans un cabinet de conseil français. "
        "Tu réponds en français, de façon factuelle et concise. "
        "Tu signales explicitement lorsqu'une vérification par un avocat est nécessaire."
    ),
    messages=[{"role": "user", "content": question}],
)

print(message.content[0].text)

Trois besoins qui reviennent immédiatement dès le deuxième programme.

Tenir une conversation suivie

L’API ne mémorise rien. Pour que Claude comprenne « en quelle année ? » après « qui a écrit Les Misérables ? », c’est votre programme qui conserve et renvoie l’historique.

historique = []

def demander(question):
    # On ajoute la question de l'utilisateur à l'historique...
    historique.append({"role": "user", "content": question})

    reponse = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=1000,
        messages=historique,   # ...et on renvoie TOUT l'historique
    )

    texte = reponse.content[0].text
    # ...puis on mémorise aussi la réponse, pour le tour suivant.
    historique.append({"role": "assistant", "content": texte})
    return texte

print(demander("Qui a écrit Les Misérables ?"))
print(demander("En quelle année ?"))   # Claude comprend grâce à l'historique

Afficher la réponse au fil de l’eau (streaming)

Par défaut, le programme attend la réponse entière. Le streaming affiche le texte à mesure qu’il est produit — c’est ce qui donne l’effet « machine à écrire » de l’application.

with client.messages.stream(
    model="claude-sonnet-5",
    max_tokens=1000,
    messages=[{"role": "user", "content": "Écris un court paragraphe sur la Provence."}],
) as stream:
    for morceau in stream.text_stream:
        print(morceau, end="", flush=True)
print()

Faire lire une image ou un document scanné

Claude sait lire des images. L’image doit être encodée en base64 — une conversion en texte que Python fait en une ligne.

import base64
import pathlib

image_b64 = base64.standard_b64encode(
    pathlib.Path("facture.png").read_bytes()
).decode("utf-8")

message = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1000,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/png",   # ou "image/jpeg"
                    "data": image_b64,
                },
            },
            {"type": "text", "text": "Extrais le numéro de facture, la date et le montant TTC."},
        ],
    }],
)

print(message.content[0].text)

Notez la forme du content : ce n’est plus une simple chaîne de caractères mais une liste de blocs, ici une image suivie d’une consigne. C’est la structure à utiliser dès qu’un message mélange plusieurs types de contenus.

Traiter un lot de fichiers

Le vrai intérêt de l’API : appliquer la même consigne à cent documents sans intervention humaine.

import pathlib
import csv

CONSIGNE = (
    "Classe ce message client dans une seule catégorie parmi : "
    "DEVIS, RECLAMATION, TECHNIQUE, AUTRE. Réponds par le mot seul."
)

resultats = []
for fichier in sorted(pathlib.Path("messages").glob("*.txt")):
    contenu = fichier.read_text(encoding="utf-8")

    reponse = client.messages.create(
        model="claude-haiku-4-5-20251001",   # modèle rapide et économique
        max_tokens=10,
        temperature=0,
        system=CONSIGNE,
        messages=[{"role": "user", "content": contenu}],
    )

    categorie = reponse.content[0].text.strip()
    resultats.append([fichier.name, categorie])
    print(fichier.name, "->", categorie)

with open("classement.csv", "w", newline="", encoding="utf-8") as f:
    csv.writer(f).writerows([["fichier", "categorie"]] + resultats)

Un programme qui appelle un service en ligne doit prévoir que le service réponde mal. Quinze lignes suffisent.

Gérer les erreurs proprement

import anthropic

try:
    message = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=1000,
        messages=[{"role": "user", "content": "Bonjour"}],
    )
    print(message.content[0].text)

except anthropic.AuthenticationError:
    print("Clé API invalide ou absente : vérifiez ANTHROPIC_API_KEY.")

except anthropic.RateLimitError:
    print("Trop de requêtes envoyées : attendez quelques secondes puis réessayez.")

except anthropic.APIStatusError as e:
    print(f"Erreur {e.status_code} renvoyée par l'API : {e.message}")

except anthropic.APIConnectionError:
    print("Impossible de joindre l'API : vérifiez la connexion Internet.")

Le SDK réessaie déjà automatiquement les erreurs passagères. Inutile d’écrire votre propre boucle de reprise avant d’en avoir constaté le besoin.

Mesurer ce que chaque appel a coûté

Chaque réponse contient le décompte exact des tokens consommés. C’est la seule façon fiable de suivre son budget.

# Prix en dollars par million de tokens : (entrée, sortie)
PRIX = {
    "claude-sonnet-5": (2.0, 10.0),
    "claude-opus-5": (5.0, 25.0),
    "claude-haiku-4-5-20251001": (1.0, 5.0),
}

MODELE = "claude-sonnet-5"
prix_entree, prix_sortie = PRIX[MODELE]

cout = (
    message.usage.input_tokens / 1_000_000 * prix_entree
    + message.usage.output_tokens / 1_000_000 * prix_sortie
)

print(f"Entrée : {message.usage.input_tokens} tokens")
print(f"Sortie : {message.usage.output_tokens} tokens")
print(f"Coût de cet appel : {cout:.5f} $")

Tableau de dépannage

À garder sous la main.

Les commandes à connaître

python3 --version                 # vérifier l'installation de Python
python3 -m venv .venv              # créer un environnement isolé
source .venv/bin/activate          # l'activer (macOS / Linux)
.venv\Scripts\activate             # l'activer (Windows)
pip install anthropic              # installer le SDK
pip install --upgrade anthropic    # le mettre à jour
python3 mon_script.py              # exécuter un programme

Pour aller plus loin

• Documentation officielle en français — référence complète et à jour.
• Guides de cas d’usage — routage de tickets, agent de support, modération de contenu, synthèse juridique.
• Guide de rédaction de prompts — techniques avancées : exemples, balises XML, chaînage.
• Console — gestion des clés API.