Claude API : démarrer en 15 minutes avec Python

Ce que vous saurez faire à la fin

1. Créer votre clé API Anthropic et la sécuriser
2. Installer le SDK Python et faire votre premier appel
3. Gérer conversations multi-tours et streaming
4. Utiliser Tool Use pour connecter Claude à vos fonctions
5. Activer le prompt caching pour diviser vos coûts par 10

Durée : 1 heure. Pré-requis : Python 3.10+, carte de paiement pour la clé API, 5 USD de crédit Anthropic pour commencer.

Étape 1 — Créer un compte Anthropic et obtenir une clé

1. Allez sur console.anthropic.com. Créez un compte (email + mot de passe ou SSO Google).
2. Dans le menu latéral : API Keys > Create Key.
3. Nom : « dev-machine ». Copiez la clé immédiatement (affichée une seule fois). Format : sk-ant-api03-xxxxxxxxxxxxxxxxxxxx....
4. Ajoutez 5 USD de crédit : Billing > Add to balance.
5. Activez les alertes de consommation : Billing > Usage limits > définir un seuil mensuel à 10 USD pour commencer.

Étape 2 — Stocker la clé en variable d’environnement

JAMAIS dans le code source. JAMAIS commit dans Git.

1. Linux / Mac :

# Dans ~/.zshrc ou ~/.bashrc
export ANTHROPIC_API_KEY="sk-ant-api03-xxxxxxxxxxxxxxxxxxxx"

# Recharger
source ~/.zshrc

2. Windows PowerShell (persistant) :

[System.Environment]::SetEnvironmentVariable('ANTHROPIC_API_KEY', 'sk-ant-api03-...', 'User')
# Relancez PowerShell

3. Pour un projet : fichier .env à la racine (ajoutez dans .gitignore) :

ANTHROPIC_API_KEY=sk-ant-api03-xxxxxxxxxxxxxxxxxxxx

Étape 3 — Installer le SDK

pip install anthropic==0.42.0 python-dotenv

Étape 4 — Premier appel en 6 lignes

1. Créez premier_appel.py :

from anthropic import Anthropic
from dotenv import load_dotenv
load_dotenv()

client = Anthropic()

msg = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explique Bayes en 3 phrases."}]
)
print(msg.content[0].text)
print("Tokens:", msg.usage.input_tokens, "in /", msg.usage.output_tokens, "out")

2. Exécutez : python premier_appel.py.
3. Vous obtenez une réponse + le coût en tokens.
4. Coût : ~0,001 USD pour cet appel.

Étape 5 — Choisir le bon modèle

claude-opus-4-7       le plus intelligent, 15 USD in / 75 USD out / M tokens
claude-sonnet-4-6     équilibre recommandé, 3 USD / 15 USD
claude-haiku-4-5      ultra rapide, 0,25 USD / 1,25 USD

Choix:
- Tâche simple (classification, extraction): Haiku
- Raisonnement moyen (résumé, rédaction): Sonnet
- Code complexe, raisonnement profond: Opus

Étape 6 — Conversation multi-tours

historique = []

def demander(user_text):
    historique.append({"role": "user", "content": user_text})
    r = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2048,
        system="Tu es un assistant data science concis. Réponds en français.",
        messages=historique,
    )
    reponse = r.content[0].text
    historique.append({"role": "assistant", "content": reponse})
    return reponse

print(demander("Qu'est-ce qu'un intervalle de confiance à 95% ?"))
print(demander("Montre-moi un exemple Python avec scipy."))

Étape 7 — Streaming (token par token)

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Rédige une intro de 200 mots sur le Sahel."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    print()

Utile pour les chatbots où l’utilisateur voit la réponse apparaître au fur et à mesure.

Étape 8 — Tool Use : faire appeler vos fonctions

import json

tools = [{
    "name": "get_weather",
    "description": "Météo actuelle d'une ville",
    "input_schema": {
        "type": "object",
        "properties": {"ville": {"type": "string"}},
        "required": ["ville"],
    },
}]

def ma_fonction_meteo(ville):
    return {"temp_C": 28, "humidite": 75, "description": "Ensoleillé"}

def chat_avec_outils(question):
    messages = [{"role": "user", "content": question}]
    for _ in range(5):
        r = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            tools=tools,
            messages=messages,
        )
        messages.append({"role": "assistant", "content": r.content})
        
        if r.stop_reason == "end_turn":
            for bloc in r.content:
                if hasattr(bloc, "text"):
                    return bloc.text
        
        tool_results = []
        for bloc in r.content:
            if bloc.type == "tool_use":
                if bloc.name == "get_weather":
                    resultat = ma_fonction_meteo(**bloc.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": bloc.id,
                        "content": json.dumps(resultat),
                    })
        messages.append({"role": "user", "content": tool_results})

print(chat_avec_outils("Quelle météo à Dakar ?"))

Étape 9 — Prompt caching (90 % d’économies)

1. Cache ephemeral : valide 5 minutes, renouvelé à chaque usage.
2. Idéal pour : system prompt stable, contexte répété entre appels.

GROS_CONTEXTE = open("guidelines.txt").read()  # ex: 5000 tokens

r = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": GROS_CONTEXTE,
        "cache_control": {"type": "ephemeral"}
    }],
    messages=[{"role": "user", "content": "Résume en 3 points"}],
)

print("Cache read:", r.usage.cache_read_input_tokens)  # 0 au 1er appel, >0 après

3. Prix des tokens lus du cache : 10 % du prix normal. Sur gros system prompts répétés : économie immédiate.

Étape 10 — Gestion d’erreurs avec retry

from anthropic import APIConnectionError, RateLimitError, APIStatusError
import time

def call_avec_retry(prompt, max_retries=3):
    for essai in range(max_retries):
        try:
            r = client.messages.create(
                model="claude-sonnet-4-6",
                max_tokens=512,
                messages=[{"role": "user", "content": prompt}],
            )
            return r.content[0].text
        except RateLimitError:
            attente = 2 ** essai
            print(f"Rate limit, retry dans {attente}s")
            time.sleep(attente)
        except APIStatusError as e:
            print(f"Erreur API {e.status_code}: {e.message}")
            if e.status_code >= 500:
                time.sleep(2 ** essai)
            else:
                raise
    raise Exception("Max retries atteint")

Étape 11 — Vision (analyser une image)

import base64

with open("facture.jpg", "rb") as f:
    image_data = base64.b64encode(f.read()).decode("utf-8")

r = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/jpeg",
                    "data": image_data,
                },
            },
            {"type": "text", "text": "Extrait le montant TTC, la date et le nom du fournisseur en JSON."}
        ],
    }],
)
print(r.content[0].text)

Étape 12 — PDF (extraction de documents)

with open("contrat.pdf", "rb") as f:
    pdf_data = base64.b64encode(f.read()).decode("utf-8")

r = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "document",
                "source": {
                    "type": "base64",
                    "media_type": "application/pdf",
                    "data": pdf_data,
                },
            },
            {"type": "text", "text": "Résume ce contrat en 150 mots et liste 3 risques."}
        ],
    }],
)

Étape 13 — Contrôle de coût

def estimer_cout(usage, model="claude-sonnet-4-6"):
    prix = {
        "claude-opus-4-7": (15, 75),
        "claude-sonnet-4-6": (3, 15),
        "claude-haiku-4-5": (0.25, 1.25),
    }
    p_in, p_out = prix[model]
    cout_in = (usage.input_tokens / 1_000_000) * p_in
    cout_out = (usage.output_tokens / 1_000_000) * p_out
    return cout_in + cout_out

cout = estimer_cout(msg.usage)
print(f"Coût: ${cout:.4f} = {cout * 630:.1f} FCFA")

Étape 14 — Logging et observabilité

import logging
import json

logging.basicConfig(filename="claude.log", level=logging.INFO)

def tracer_appel(prompt, reponse, usage):
    logging.info(json.dumps({
        "ts": time.time(),
        "prompt_chars": len(prompt),
        "response_chars": len(reponse),
        "input_tokens": usage.input_tokens,
        "output_tokens": usage.output_tokens,
        "cache_read": usage.cache_read_input_tokens or 0,
        "cost_usd": estimer_cout(usage),
    }))

Étape 15 — Checklist de production

✓ Clé API en variable d'environnement, jamais dans le code
✓ Modèle choisi selon la tâche (Haiku pour simple, Sonnet/Opus pour complexe)
✓ System prompt avec cache_control sur parties stables
✓ Retry avec backoff exponentiel sur 429 et 5xx
✓ Gestion d'erreurs explicite (APIStatusError, RateLimitError)
✓ Logging JSON de chaque appel (tokens, coût, latence)
✓ Limite mensuelle de budget définie dans la console
✓ Monitoring des coûts (dashboard GA4/Superset/Metabase)
✓ Tests unitaires sur vos prompts (snapshot testing)