Tutoriel API Claude Fable 5 : créez un assistant de tâches développeur en Python

Mise à jour (1 juillet 2026) : l'accès à Claude Fable 5 a été rétabli et est désormais disponible dans le monde entier sur Claude Platform, Claude.ai, Claude Code et Claude Cowork après la levée de l'ordre de contrôle des exportations. Mythos 5 reste limité aux partenaires approuvés du programme Project Glasswing.

Mise à jour (2 septembre 2026) : Anthropic a publié le successeur de Fable 5. Nous vous recommandons de lire notre guide Claude Fable 5.1 pour tous les détails.

Quand je teste un nouveau modèle via une API, je m'intéresse moins aux notes de lancement qu'aux parties à brancher dans le code : à quoi ressemble l'appel d'API, ce qui change par rapport au modèle précédent, combien cela va coûter et que se passe-t-il quand la couche de sécurité refuse la requête ?

Notre article de présentation de Claude Fable 5 couvrait le lancement, les benchmarks et la configuration de sécurité qui rend Fable 5 unique. Le code ci-dessous prend le relais. Concrètement, nous allons créer un assistant de tâches pour développeurs qui prend une demande de fonctionnalité logicielle et renvoie un plan d'implémentation structuré, puis nous ajouterons le streaming, l'usage d'outils, le suivi des coûts et un endpoint FastAPI.

Nous allons voir :

• Effectuer un appel à l'API Fable 5 et lire la réponse
• Guider le modèle avec un prompt système
• Retourner du JSON via des sorties structurées
• Diffuser des réponses longues vers un terminal ou un client web
• Connecter un outil simple et exécuter la boucle d'outils
• Estimer et suivre les coûts de jetons avant et après chaque requête
• Gérer les refus sans faire planter votre application
• Traiter des images en entrée pour revue d'UI ou analyse visuelle
• Servir l'ensemble du flux via un endpoint FastAPI

Qu'est-ce que Claude Fable 5 ?

Claude Fable 5 est un modèle Anthropic publié le 9 juin 2026, avec l'identifiant API claude-fable-5. Anthropic le présente comme partageant la même base que Claude Mythos 5, mais avec des classifieurs de sécurité appliqués pour une disponibilité générale. Mythos 5 reste limité à Project Glasswing, un programme restreint pour des organisations de sécurité de confiance.

Pour les développeurs, les détails API pertinents sont :

• Une fenêtre de contexte d'1 million de jetons et jusqu'à 128 k jetons en sortie par requête

• Prix : 10 $ par million de jetons en entrée et 50 $ par million de jetons en sortie, soit le double de Opus 4.8

• Le raisonnement adaptatif est toujours activé. Vous ne pouvez pas le désactiver. Le paramètre effort contrôle la profondeur ; le raisonnement interne du modèle est généré et facturé que vous l'affichiez ou non

• C'est un « Covered Model » : une rétention des données de 30 jours est obligatoire. Le mode Zero Data Retention n'est pas disponible pour ce modèle.

Je ne l'utiliserais pas pour chaque appel d'API. Il est plus pertinent pour des tâches qui exigent un raisonnement sur l'architecture, les cas limites et les détails d'implémentation. Pour des besoins plus simples, Sonnet 4.6 ou Haiku 4.5 suffira probablement.

Ce que nous allons construire avec Fable 5 : un assistant de tâches pour développeurs

L'assistant que nous allons créer prend une demande de fonctionnalité logicielle et renvoie un plan structuré : résumé technique, étapes d'implémentation ordonnées, fichiers susceptibles de changer, risques, et tests.

Je prends cet exemple car il force à traiter les détails d'API qui comptent en situation réelle : sortie structurée, streaming, appels d'outils, coûts et gestion des refus. C'est concis, mais ce n'est pas un simple Hello World.

Les sections ci-dessous assemblent ces éléments pas à pas.

D'une demande de fonctionnalité à un plan structuré. Image : l'auteur.

Le code principal se trouve dans task_assistant.py pour le script local et app.py pour l'endpoint FastAPI.

Prérequis

Pour suivre, vous aurez besoin :

• Python 3.9 ou plus récent (le tutoriel utilise des fonctionnalités 3.10+ comme les hints de type natifs dans les modèles Pydantic, mais le SDK prend en charge 3.9+)

• Une clé d'API Anthropic avec accès à claude-fable-5

• Bases sur les variables d'environnement, JSON et les API HTTP

• Un terminal et un éditeur de code

Configuration du projet

Commencez par créer un dossier de projet et un environnement virtuel.

mkdir task-assistant
cd task-assistant
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activatePropulsé par

Installez le SDK Anthropic, FastAPI et quelques utilitaires.

pip install anthropic fastapi uvicorn python-dotenv pydanticPropulsé par

Créez un fichier .env à la racine du projet avec votre clé d'API. Ne le validez jamais dans votre dépôt.

ANTHROPIC_API_KEY=sk-ant-...Propulsé par

Chargez-le en tête de script. Anthropic() lit ANTHROPIC_API_KEY depuis l'environnement automatiquement.

from dotenv import load_dotenv
from anthropic import Anthropic

load_dotenv()
client = Anthropic()Propulsé par

Initialisez le client une fois au niveau du module et réutilisez-le dans tout le tutoriel.

Premier appel à l'API Claude Fable 5 en Python

Avant d'ajouter la logique métier, j'aime envoyer une requête minimale pour vérifier que la configuration fonctionne. L'API Messages prend l'identifiant du modèle, un plafond max_tokens et un tableau messages. max_tokens est obligatoire ; le SDK lève un TypeError si vous l'omettez.

MODEL = "claude-fable-5"

def get_text(response):
    """Return the first text block, skipping thinking or tool blocks."""
    return next((b.text for b in response.content if b.type == "text"), "")

response = client.messages.create(
    model=MODEL,
    max_tokens=512,
    messages=[{"role": "user", "content": "Reply in one sentence to confirm the API connection is working."}]
)

print(get_text(response))
print(f"Model: {response.model}")
print(f"Input tokens: {response.usage.input_tokens}")
print(f"Output tokens: {response.usage.output_tokens}")Propulsé par

Réponse Fable 5 et jetons. Image : l'auteur.

response.content est une liste de blocs de contenu, pas une simple chaîne. En raison du raisonnement adaptatif, le premier bloc est souvent un bloc de pensée, et content[0].text peut lever un AttributeError. Le helper get_text filtre via block.type == "text" à la place.

L'objet usage fournit les comptes de jetons entrée/sortie après chaque requête. response.model indique quel modèle a répondu, utile quand des bascules automatiques sont configurées.

Contrôler la profondeur du raisonnement avec effort

Le paramètre effort passé dans output_config contrôle cette profondeur de raisonnement.

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    output_config={"effort": "high"},  # low | medium | high | xhigh | max
    messages=[{"role": "user", "content": feature_request}]
)Propulsé par

La valeur par défaut est "high". Je démarrerais là, puis "low" ou "medium" quand la latence prime, et "xhigh" ou "max" pour des problèmes plus longs. Effort influe sur le nombre de jetons de pensée générés, pas sur le fait d'en générer ou non.

Ajouter un prompt système pour le rôle assistant

Le paramètre system est un champ de haut niveau dans la requête, séparé du tableau messages . Ce que vous y placez s'applique à chaque tour, donc chaque mot y a plus d'impact que dans une instruction ponctuelle.

Pour l'assistant de tâches, je garde le prompt système ciblé : renvoyer un plan d'ingénierie concis plutôt qu'une analyse générale.

SYSTEM_PROMPT = """You are a senior software engineer who reviews feature requests and returns
implementation plans. For every request:
- Write a one sentence technical summary
- List the implementation steps in order
- Name the files or components most likely to change
- Call out at most three risks or edge cases
- Suggest concrete tests
Do not narrate options you won't pursue. Act on what you know; ask only when key details are missing."""Propulsé par

La dernière consigne compte. Fable 5 peut sur-préparer pour des demandes simples, donc le prompt borne la sortie avant qu'elle ne dérive.

Passez le prompt système à chaque appel.

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature_request}]
)Propulsé par

Le pré-remplissage du tour assistant n'est pas pris en charge sur Fable 5. Si vous avez un ancien code Claude qui commence le tour assistant par {"role": "assistant", "content": "{"} pour forcer du JSON, supprimez-le. Ce schéma renvoie un 400 sur Fable 5, piège classique lors d'une migration.

Construire le flux de planification de fonctionnalité

Planifier une fonctionnalité implique de suivre l'architecture, les modes d'échec et la stratégie de test en une seule réponse. C'est un bon premier flux : assez court pour être inspecté, mais pas un simple jouet.

feature = (
    "Add password reset to our Django app. "
    "Users should receive a token via email and land on a form to set a new password."
)

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    output_config={"effort": "high"},
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}]
)

print(get_text(response))Propulsé par

Une réponse type couvre la génération de jeton, l'envoi d'e-mail, le formulaire et le nettoyage à l'expiration en un seul passage.

Retourner des sorties JSON structurées avec Claude Fable 5

Le texte brut suffit au terminal. Dès que le plan doit devenir des données d'application, une sortie structurée est plus simple. L'API Claude prend en charge les sorties structurées via client.messages.parse() et un modèle Pydantic, y compris avec claude-fable-5.

Définissez la forme attendue comme un modèle Pydantic.

from pydantic import BaseModel

class FeaturePlan(BaseModel):
    summary: str
    steps: list[str]
    files: list[str]
    risks: list[str]
    tests: list[str]Propulsé par

Passez la classe via output_format. Le SDK la convertit en schéma JSON, lance un décodage contraint sur les serveurs d'Anthropic et renvoie un objet typé dans response.parsed_output.

response = client.messages.parse(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}],
    output_format=FeaturePlan
)

plan = response.parsed_output
if plan is not None:
    print(f"Summary: {plan.summary}")
    print(f"Steps: {plan.steps}")Propulsé par

Vérifiez que parsed_output n'est pas None avant usage. Un refus pendant le streaming ou un arrêt anticipé sur max_tokens peut le laisser vide. Ce chemin évite aussi le souci des blocs de pensée car vous lisez parsed_output au lieu de fouiller dans content.

Si vous avez besoin d'une sortie structurée sur un modèle qui ne la prend pas en charge nativement, demandez du JSON dans le prompt et validez-le avec FeaturePlan.model_validate_json(text), en retentant une fois en cas d'échec. N'associez pas sorties structurées et pré-remplissage du tour assistant ; Fable 5 renvoie un 400 avec ce schéma.

Diffuser des réponses depuis Claude Fable 5

Ce même raisonnement adaptatif peut augmenter l'attente avant le premier jeton sur des prompts complexes. Le streaming affiche les fragments dès leur arrivée.

Utilisez le gestionnaire de contexte client.messages.stream(). stream.text_stream fournit des fragments de texte et ignore automatiquement les blocs de pensée.

with client.messages.stream(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}]
) as stream:
    for chunk in stream.text_stream:
        print(chunk, end="", flush=True)

final = stream.get_final_message()
print(f"\nInput tokens: {final.usage.input_tokens}")
print(f"Output tokens: {final.usage.output_tokens}")Propulsé par

Appelez get_final_message() après la fermeture du bloc with, pas à l'intérieur. C'est là que se trouvent la raison d'arrêt et les compteurs d'usage.

Le streaming et les sorties structurées peuvent coexister, mais accumulez la réponse complète avant de la parser. Un JSON partiel n'est pas un JSON valide.

Ajouter l'usage d'outils (function calling)

L'usage d'outils permet au modèle de demander des informations au lieu de se contenter du prompt. Je garde un premier outil minimal : read_project_file. Le modèle demande à lire un fichier, votre code le lit, puis le modèle exploite le contenu.

La boucle d'outils suit un schéma fixe. Claude renvoie stop_reason: "tool_use" quand il souhaite appeler un outil, vous exécutez l'outil et renvoyez un bloc tool_result, et la boucle continue jusqu'à stop_reason valant "end_turn" ou "refusal".

Boucle d'outil, de la demande à la réponse. Image : l'auteur.

READ_FILE_TOOL = {
    "name": "read_project_file",
    "description": "Read the contents of a file in the project.",
    "input_schema": {
        "type": "object",
        "properties": {
            "path": {"type": "string", "description": "Relative path to the file"}
        },
        "required": ["path"]
    }
}

messages = [{"role": "user", "content": feature}]

while True:
    response = client.messages.create(
        model=MODEL,
        max_tokens=2048,
        system=SYSTEM_PROMPT,
        tools=[READ_FILE_TOOL],
        messages=messages
    )

    if response.stop_reason in ("end_turn", "refusal"):
        break

    if response.stop_reason == "tool_use":
        tool_block = next(b for b in response.content if b.type == "tool_use")

        # Execute the tool locally
        try:
            with open(tool_block.input["path"]) as f:
                result = f.read()[:2000]
        except FileNotFoundError:
            result = f"File not found: {tool_block.input['path']}"

        messages.append({"role": "assistant", "content": response.content})
        messages.append({
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_block.id,
                "content": result
            }]
        })

# Read the final answer
text_block = next((b for b in response.content if b.type == "text"), None)
print(text_block.text if text_block else "No text in final response")Propulsé par

Le modèle n'exécute jamais ce code. Il émet une demande structurée avec un nom d'outil et des entrées JSON ; votre application effectue la lecture. N'ajoutez pas de texte conversationnel dans la même requête utilisateur qu'un bloc tool_result, sinon le modèle peut s'arrêter au lieu de poursuivre le plan.

Estimer l'usage de jetons et le coût API de Claude Fable 5

Avant d'en faire une application, vérifiez la structure des coûts. Fable 5 coûte 10 $ par million de jetons en entrée et 50 $ par million de jetons en sortie. La sortie est généralement la plus grosse ligne : un plan de 2 000 jetons coûte déjà 0,10 $ en sortie.

Voici la grille tarifaire de la famille Anthropic.

La mise en cache des prompts peut réduire le coût répété du prompt système. Une fois le bloc système mis en cache, les lectures répétées coûtent 1 $ par million de jetons au lieu de 10 $. La taille minimale d'un bloc cachable est de 512 jetons sur l'API Claude.

# Count tokens before sending an expensive request
count = client.messages.count_tokens(
    model=MODEL,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}]
)
print(f"Estimated input tokens: {count.input_tokens}")

# Calculate actual cost after each request
INPUT_PRICE = 10.0 / 1_000_000
OUTPUT_PRICE = 50.0 / 1_000_000

response = client.messages.create(...)
cost = (
    response.usage.input_tokens * INPUT_PRICE +
    response.usage.output_tokens * OUTPUT_PRICE
)
print(f"Total cost: ${cost:.6f}")Propulsé par

count_tokens ne coûte rien et ne compte pas contre votre limite de jetons en sortie par minute. Utilisez-le pour filtrer les requêtes onéreuses. Pour les travaux sans interaction, l'API Batch divise par deux les prix d'entrée comme de sortie.

Fable 5 utilise le tokenizer introduit avec Opus 4.7, qui peut produire environ 30 % de jetons en plus sur le même texte que les anciens Claude. Tenez-en compte lors de migrations depuis Claude 4.6.

Gérer les refus et la bascule de modèle

Fable 5 exécute des classifieurs de sécurité pendant la génération. Quand l'un se déclenche, l'API renvoie un HTTP 200 réussi, pas une erreur, et l'unique signal est stop_reason: "refusal". Une gestion d'erreur qui ne capte que les exceptions passera à côté des refus, et votre app renverra silencieusement du vide.

Vérifiez toujours la raison d'arrêt.

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": user_input}]
)

if response.stop_reason == "refusal":
    category = (
        response.stop_details.category
        if response.stop_details else "policy"
    )
    print(f"Request declined ({category}). Please rephrase and try again.")
else:
    print(get_text(response))Propulsé par

Dans mes tests, Fable 5 refusait souvent des demandes limites en texte clair, en renvoyant un end_turn normal. Le refus dur du classifieur, avec stop_reason: "refusal" et content vide, est plus rare. Le contrôle ci-dessus gère ce cas pour éviter un retour silencieux de rien.

stop_details.category peut valoir "cyber", "bio" ou "reasoning_extraction". Le dernier se déclenche quand un prompt tente d'extraire la chaîne de pensée interne. Pour des outils développeurs qui inspectent des scanners sécurité réseau ou des pipelines bio, vous pouvez rencontrer des faux positifs. Reformuler en rendant la tâche clairement défensive résout souvent le problème.

En production, vous pouvez configurer une bascule automatique vers Opus 4.8 avec la bêta fallbacks côté serveur dans l'API Claude et Claude Platform sur AWS. Ce n'est pas la même chose que Amazon Bedrock : sur Bedrock, Vertex AI et Foundry, la logique de bascule se code dans votre application.

response = client.beta.messages.create(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": user_input}],
    fallbacks=[{"model": "claude-opus-4-8"}],
    betas=["server-side-fallback-2026-06-01"]
)Propulsé par

Une requête refusée qui ne génère aucune sortie n'est pas facturée. Un refus en cours de flux facture ce qui a été généré avant le déclenchement du classifieur.

Utiliser Claude Fable 5 avec des images (vision)

Si votre application ne traite que du texte, vous pouvez passer cette section. Elle est indépendante du flux de planification, mais réutilise la même forme de l'API Messages. Fable 5 accepte des images en blocs encodés base64 ou via URL. Un cas d'usage : la revue d'une capture d'écran d'UI au regard d'une exigence.

import base64

with open("login_form.png", "rb") as f:
    img_data = base64.standard_b64encode(f.read()).decode("utf-8")

response = client.messages.create(
    model=MODEL,
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": img_data
                }
            },
            {
                "type": "text",
                "text": "Review this UI against the requirement: add a 'Forgot password' link below the login button. Is it present? If not, describe what needs to change."
            }
        ]
    }]
)
print(get_text(response))Propulsé par

Une image en taille réelle coûte environ 4 784 jetons d'entrée quel que soit son contenu, donc redimensionnez ou compressez si vous n'avez pas besoin de la pleine définition. Fable 5 traite des images jusqu'à 2¥76 px de large et réduit toute image plus grande. Formats pris en charge : JPEG, PNG, GIF et WebP.

Transformer le flux en endpoint FastAPI

À ce stade, le script local couvre tout le flux. Emballez l'assistant dans une route FastAPI pour qu'un frontend ou un service puisse l'appeler. Utilisez AsyncAnthropic dans des routes async, car le client synchrone bloque la boucle d'événements. Initialisez-le une fois au démarrage, pas par requête.

from contextlib import asynccontextmanager
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from anthropic import AsyncAnthropic

client_instance: AsyncAnthropic | None = None

@asynccontextmanager
async def lifespan(app: FastAPI):
    global client_instance
    client_instance = AsyncAnthropic()
    yield
    await client_instance.close()

app = FastAPI(lifespan=lifespan)

class PlanRequest(BaseModel):
    feature_request: str

@app.post("/plan")
async def create_plan(body: PlanRequest):
    response = await client_instance.messages.create(
        model="claude-fable-5",
        max_tokens=2048,
        system=SYSTEM_PROMPT,
        messages=[{"role": "user", "content": body.feature_request}]
    )

    if response.stop_reason == "refusal":
        raise HTTPException(status_code=400, detail="Request declined by safety classifier.")

    return {
        "plan": get_text(response),
        "input_tokens": response.usage.input_tokens,
        "output_tokens": response.usage.output_tokens
    }Propulsé par

Lancez avec uvicorn app:app --reload et testez l'endpoint /plan via la doc FastAPI sur http://localhost:8000/docs.