Loading...
    • Guide du développeur
    • Référence API
    • MCP
    • Ressources
    • Notes de version
    Search...
    ⌘K
    Premiers pas
    Introduction à ClaudeDémarrage rapide
    Modèles et tarification
    Aperçu des modèlesChoisir un modèleNouveautés dans Claude 4.5Migration vers Claude 4.5Dépréciation des modèlesTarification
    Créer avec Claude
    Aperçu des fonctionnalitésUtiliser l'API MessagesFenêtres de contexteMeilleures pratiques de prompting
    Capacités
    Mise en cache des promptsÉdition de contexteRéflexion étendueEffortStreaming de messagesTraitement par lotsCitationsSupport multilingueComptage de tokensEmbeddingsVisionSupport PDFAPI FilesRésultats de rechercheSorties structurées
    Outils
    AperçuComment implémenter l'utilisation d'outilsStreaming d'outils granulaireOutil BashOutil d'exécution de codeAppel d'outils programmatiqueOutil Computer useOutil Éditeur de texteOutil Web fetchOutil Web searchOutil MemoryOutil Tool search
    Agent Skills
    AperçuDémarrage rapideMeilleures pratiquesUtiliser Skills avec l'API
    Agent SDK
    AperçuDémarrage rapideSDK TypeScriptTypeScript V2 (aperçu)SDK PythonGuide de migration
    MCP dans l'API
    Connecteur MCPServeurs MCP distants
    Claude sur des plateformes tierces
    Amazon BedrockMicrosoft FoundryVertex AI
    Ingénierie des prompts
    AperçuGénérateur de promptsUtiliser des modèles de promptsAméliorateur de promptsÊtre clair et directUtiliser des exemples (prompting multi-shot)Laisser Claude réfléchir (CoT)Utiliser des balises XMLDonner un rôle à Claude (prompts système)Pré-remplir la réponse de ClaudeChaîner des prompts complexesConseils pour le contexte longConseils pour la réflexion étendue
    Tester et évaluer
    Définir les critères de succèsDévelopper des cas de testUtiliser l'outil d'évaluationRéduire la latence
    Renforcer les garde-fous
    Réduire les hallucinationsAugmenter la cohérence des résultatsAtténuer les jailbreaksRefus en streamingRéduire les fuites de promptsGarder Claude dans le rôle
    Administration et surveillance
    Aperçu de l'API AdminAPI Utilisation et coûtsAPI Claude Code Analytics
    Console
    Log in
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...

    Solutions

    • AI agents
    • Code modernization
    • Coding
    • Customer support
    • Education
    • Financial services
    • Government
    • Life sciences

    Partners

    • Amazon Bedrock
    • Google Cloud's Vertex AI

    Learn

    • Blog
    • Catalog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Company

    • Anthropic
    • Careers
    • Economic Futures
    • Research
    • News
    • Responsible Scaling Policy
    • Security and compliance
    • Transparency

    Learn

    • Blog
    • Catalog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Help and security

    • Availability
    • Status
    • Support
    • Discord

    Terms and policies

    • Privacy policy
    • Responsible disclosure policy
    • Terms of service: Commercial
    • Terms of service: Consumer
    • Usage policy
    Outils

    Comment implémenter l'utilisation d'outils

    Guide complet pour implémenter l'utilisation d'outils avec Claude, y compris la définition des outils, les meilleures pratiques et les exemples de code.
    • Choisir un modèle
    • Spécifier les outils clients
    • Invite système d'utilisation d'outils
    • Meilleures pratiques pour les définitions d'outils
    • Fournir des exemples d'utilisation d'outils
    • Utilisation de base
    • Exigences et limitations
    • Exécuteur d'outils (bêta)
    • Utilisation de base
    • Itération sur l'exécuteur d'outils
    • Utilisation avancée
    • Streaming
    • Utilisation de base
    • Itération sur l'exécuteur d'outils
    • Utilisation avancée
    • Streaming
    • Utilisation de base
    • Itération sur l'exécuteur d'outils
    • Utilisation avancée
    • Streaming
    • Utilisation de base
    • Itération sur l'exécuteur d'outils
    • Utilisation avancée
    • Streaming
    • Contrôler la sortie de Claude
    • Forcer l'utilisation d'outils
    • Sortie JSON
    • Réponses du modèle avec des outils
    • Utilisation parallèle d'outils
    • Gestion des blocs de contenu d'utilisation d'outils et de résultats d'outils
    • Gestion des résultats des outils clients
    • Gestion des résultats des outils serveur
    • Gestion de la raison d'arrêt max_tokens
    • Dépannage des erreurs

    Choisir un modèle

    Nous recommandons d'utiliser le dernier Claude Sonnet (4.5) ou Claude Opus (4.1) pour les outils complexes et les requêtes ambiguës ; ils gèrent mieux plusieurs outils et demandent des clarifications si nécessaire.

    Utilisez les modèles Claude Haiku pour les outils simples, mais notez qu'ils peuvent déduire les paramètres manquants.

    Si vous utilisez Claude avec l'utilisation d'outils et la réflexion étendue, consultez notre guide ici pour plus d'informations.

    Spécifier les outils clients

    Les outils clients (à la fois définis par Anthropic et définis par l'utilisateur) sont spécifiés dans le paramètre tools de niveau supérieur de la requête API. Chaque définition d'outil inclut :

    ParamètreDescription
    nameLe nom de l'outil. Doit correspondre à l'expression régulière ^[a-zA-Z0-9_-]{1,64}$.
    descriptionUne description détaillée en texte brut de ce que fait l'outil, quand il doit être utilisé et comment il se comporte.
    input_schemaUn objet JSON Schema définissant les paramètres attendus pour l'outil.
    input_examples(Optionnel, bêta) Un tableau d'objets d'entrée d'exemple pour aider Claude à comprendre comment utiliser l'outil. Voir Fournir des exemples d'utilisation d'outils.

    Invite système d'utilisation d'outils

    Lorsque vous appelez l'API Claude avec le paramètre tools, nous construisons une invite système spéciale à partir des définitions d'outils, de la configuration des outils et de toute invite système spécifiée par l'utilisateur. L'invite construite est conçue pour instruire le modèle d'utiliser les outils spécifiés et de fournir le contexte nécessaire pour que l'outil fonctionne correctement :

    In this environment you have access to a set of tools you can use to answer the user's question.
    {{ FORMATTING INSTRUCTIONS }}
    String and scalar parameters should be specified as is, while lists and objects should use JSON format. Note that spaces for string values are not stripped. The output is not expected to be valid XML and is parsed with regular expressions.
    Here are the functions available in JSONSchema format:
    {{ TOOL DEFINITIONS IN JSON SCHEMA }}
    {{ USER SYSTEM PROMPT }}
    {{ TOOL CONFIGURATION }}

    Meilleures pratiques pour les définitions d'outils

    Pour obtenir les meilleures performances de Claude lors de l'utilisation d'outils, suivez ces directives :

    • Fournir des descriptions extrêmement détaillées. C'est de loin le facteur le plus important pour les performances des outils. Vos descriptions doivent expliquer chaque détail de l'outil, y compris :
      • Ce que fait l'outil
      • Quand il doit être utilisé (et quand il ne doit pas l'être)
      • Ce que signifie chaque paramètre et comment il affecte le comportement de l'outil
      • Toutes les mises en garde ou limitations importantes, comme les informations que l'outil ne retourne pas si le nom de l'outil n'est pas clair. Plus vous pouvez donner de contexte à Claude sur vos outils, mieux il sera capable de décider quand et comment les utiliser. Visez au moins 3-4 phrases par description d'outil, plus si l'outil est complexe.
    • Prioriser les descriptions, mais envisager d'utiliser input_examples pour les outils complexes. Les descriptions claires sont les plus importantes, mais pour les outils avec des entrées complexes, des objets imbriqués ou des paramètres sensibles au format, vous pouvez utiliser le champ input_examples (bêta) pour fournir des exemples validés par le schéma. Voir Fournir des exemples d'utilisation d'outils pour plus de détails.

    La bonne description explique clairement ce que fait l'outil, quand l'utiliser, quelles données il retourne et ce que signifie le paramètre ticker. La mauvaise description est trop brève et laisse Claude avec de nombreuses questions ouvertes sur le comportement et l'utilisation de l'outil.

    Fournir des exemples d'utilisation d'outils

    Vous pouvez fournir des exemples concrets d'entrées d'outils valides pour aider Claude à comprendre comment utiliser vos outils plus efficacement. Ceci est particulièrement utile pour les outils complexes avec des objets imbriqués, des paramètres optionnels ou des entrées sensibles au format.

    Les exemples d'utilisation d'outils sont une fonctionnalité bêta. Incluez l'en-tête bêta approprié pour votre fournisseur :

    FournisseurEn-tête bêtaModèles supportés
    Claude API,
    Microsoft Foundry
    advanced-tool-use-2025-11-20Tous les modèles
    Vertex AI,
    Amazon Bedrock
    tool-examples-2025-10-29Claude Opus 4.5 uniquement

    Utilisation de base

    Ajoutez un champ optionnel input_examples à votre définition d'outil avec un tableau d'objets d'entrée d'exemple. Chaque exemple doit être valide selon le input_schema de l'outil :

    Les exemples sont inclus dans l'invite aux côtés de votre schéma d'outil, montrant à Claude des modèles concrets pour des appels d'outils bien formés. Cela aide Claude à comprendre quand inclure les paramètres optionnels, quels formats utiliser et comment structurer les entrées complexes.

    Exigences et limitations

    • Validation du schéma - Chaque exemple doit être valide selon le input_schema de l'outil. Les exemples invalides retournent une erreur 400
    • Non supporté pour les outils côté serveur - Seuls les outils définis par l'utilisateur peuvent avoir des exemples d'entrée
    • Coût en tokens - Les exemples s'ajoutent aux tokens d'invite : ~20-50 tokens pour les exemples simples, ~100-200 tokens pour les objets imbriqués complexes

    Exécuteur d'outils (bêta)

    L'exécuteur d'outils fournit une solution prête à l'emploi pour exécuter des outils avec Claude. Au lieu de gérer manuellement les appels d'outils, les résultats d'outils et la gestion des conversations, l'exécuteur d'outils exécute automatiquement :

    • Exécute les outils quand Claude les appelle
    • Gère le cycle de requête/réponse
    • Gère l'état de la conversation
    • Fournit la sécurité des types et la validation

    Nous recommandons d'utiliser l'exécuteur d'outils pour la plupart des implémentations d'utilisation d'outils.

    L'exécuteur d'outils est actuellement en bêta et disponible dans les SDK Python, TypeScript et Ruby.

    Gestion automatique du contexte avec compaction

    L'exécuteur d'outils supporte la compaction automatique, qui génère des résumés quand l'utilisation de tokens dépasse un seuil. Cela permet aux tâches agentiques longues de continuer au-delà des limites de la fenêtre de contexte.

    L'exécuteur d'outils du SDK est en bêta. Le reste de ce document couvre l'implémentation manuelle des outils.

    Contrôler la sortie de Claude

    Forcer l'utilisation d'outils

    Dans certains cas, vous pouvez vouloir que Claude utilise un outil spécifique pour répondre à la question de l'utilisateur, même si Claude pense pouvoir fournir une réponse sans utiliser un outil. Vous pouvez le faire en spécifiant l'outil dans le champ tool_choice comme suit :

    tool_choice = {"type": "tool", "name": "get_weather"}

    Lorsque vous travaillez avec le paramètre tool_choice, nous avons quatre options possibles :

    • auto permet à Claude de décider s'il doit appeler l'un des outils fournis ou non. C'est la valeur par défaut quand des tools sont fournis.
    • any indique à Claude qu'il doit utiliser l'un des outils fournis, mais ne force pas un outil particulier.
    • tool nous permet de forcer Claude à toujours utiliser un outil particulier.
    • none empêche Claude d'utiliser n'importe quel outil. C'est la valeur par défaut quand aucun tools n'est fourni.

    Lors de l'utilisation de la mise en cache des invites, les modifications du paramètre tool_choice invalideront les blocs de messages en cache. Les définitions d'outils et les invites système restent en cache, mais le contenu des messages doit être retraité.

    Ce diagramme illustre comment chaque option fonctionne :

    Notez que lorsque vous avez tool_choice comme any ou tool, nous préremplirons le message de l'assistant pour forcer l'utilisation d'un outil. Cela signifie que les modèles n'émettront pas de réponse en langage naturel ou d'explication avant les blocs de contenu tool_use, même s'ils sont explicitement demandés.

    Lors de l'utilisation de la réflexion étendue avec l'utilisation d'outils, tool_choice: {"type": "any"} et tool_choice: {"type": "tool", "name": "..."} ne sont pas supportés et entraîneront une erreur. Seuls tool_choice: {"type": "auto"} (par défaut) et tool_choice: {"type": "none"} sont compatibles avec la réflexion étendue.

    Nos tests ont montré que cela ne devrait pas réduire les performances. Si vous souhaitez que le modèle fournisse un contexte en langage naturel ou des explications tout en demandant au modèle d'utiliser un outil spécifique, vous pouvez utiliser {"type": "auto"} pour tool_choice (par défaut) et ajouter des instructions explicites dans un message user. Par exemple : What's the weather like in London? Use the get_weather tool in your response.

    Appels d'outils garantis avec des outils stricts

    Combinez tool_choice: {"type": "any"} avec l'utilisation d'outils stricts pour garantir à la fois qu'un de vos outils sera appelé ET que les entrées d'outils suivront strictement votre schéma. Définissez strict: true sur vos définitions d'outils pour activer la validation du schéma.

    Sortie JSON

    Les outils ne doivent pas nécessairement être des fonctions clients — vous pouvez utiliser des outils chaque fois que vous voulez que le modèle retourne une sortie JSON qui suit un schéma fourni. Par exemple, vous pourriez utiliser un outil record_summary avec un schéma particulier. Voir Utilisation d'outils avec Claude pour un exemple complet fonctionnant.

    Réponses du modèle avec des outils

    Lors de l'utilisation d'outils, Claude commentera souvent ce qu'il fait ou répondra naturellement à l'utilisateur avant d'invoquer les outils.

    Par exemple, étant donné l'invite « Quel temps fait-il à San Francisco en ce moment, et quelle heure est-il là-bas ? », Claude pourrait répondre avec :

    JSON
    {
      "role": "assistant",
      "content": [
        {
          "type": "text",
          "text": "I'll help you check the current weather and time in San Francisco."
        },
        {
          "type": "tool_use",
          "id": "toolu_01A09q90qw90lq917835lq9",
          "name": "get_weather",
          "input": {"location": "San Francisco, CA"}
        }
      ]
    }

    Ce style de réponse naturelle aide les utilisateurs à comprendre ce que Claude fait et crée une interaction plus conversationnelle. Vous pouvez guider le style et le contenu de ces réponses par le biais de vos invites système et en fournissant des <examples> dans vos invites.

    Il est important de noter que Claude peut utiliser diverses formulations et approches pour expliquer ses actions. Votre code doit traiter ces réponses comme n'importe quel autre texte généré par l'assistant, et ne pas s'appuyer sur des conventions de formatage spécifiques.

    Utilisation parallèle d'outils

    Par défaut, Claude peut utiliser plusieurs outils pour répondre à une requête utilisateur. Vous pouvez désactiver ce comportement en :

    • Définissant disable_parallel_tool_use=true lorsque le type tool_choice est auto, ce qui garantit que Claude utilise au maximum un outil
    • Définissant disable_parallel_tool_use=true lorsque le type tool_choice est any ou tool, ce qui garantit que Claude utilise exactement un outil

    Maximiser l'utilisation parallèle d'outils

    Bien que les modèles Claude 4 aient d'excellentes capacités d'utilisation parallèle d'outils par défaut, vous pouvez augmenter la probabilité d'exécution parallèle d'outils sur tous les modèles avec un invite ciblée :

    Utilisation parallèle d'outils avec Claude Sonnet 3.7

    Claude Sonnet 3.7 peut être moins susceptible de faire des appels d'outils parallèles dans une réponse, même si vous n'avez pas défini disable_parallel_tool_use. Nous recommandons de passer aux modèles Claude 4, qui ont une utilisation d'outils efficace en termes de jetons et un appel d'outils parallèles amélioré.

    Si vous utilisez toujours Claude Sonnet 3.7, vous pouvez activer l'en-tête bêta token-efficient-tools-2025-02-19 beta header, qui aide à encourager Claude à utiliser des outils parallèles. Vous pouvez également introduire un « outil batch » qui peut agir comme un méta-outil pour envelopper les invocations d'autres outils simultanément.

    Consultez cet exemple dans notre cookbook pour savoir comment utiliser cette solution de contournement.

    Gestion des blocs de contenu d'utilisation d'outils et de résultats d'outils

    Plus simple avec Tool runner : La gestion manuelle des outils décrite dans cette section est gérée automatiquement par tool runner. Utilisez cette section lorsque vous avez besoin d'un contrôle personnalisé sur l'exécution des outils.

    La réponse de Claude diffère selon qu'il utilise un outil client ou serveur.

    Gestion des résultats des outils clients

    La réponse aura une stop_reason de tool_use et un ou plusieurs blocs de contenu tool_use qui incluent :

    • id : Un identifiant unique pour ce bloc d'utilisation d'outil particulier. Ceci sera utilisé pour faire correspondre les résultats des outils plus tard.
    • name : Le nom de l'outil utilisé.
    • input : Un objet contenant l'entrée transmise à l'outil, conforme à l'input_schema de l'outil.

    Lorsque vous recevez une réponse d'utilisation d'outil pour un outil client, vous devez :

    1. Extraire le name, l'id et l'input du bloc tool_use.
    2. Exécuter l'outil réel dans votre base de code correspondant à ce nom d'outil, en transmettant l'input de l'outil.
    3. Continuer la conversation en envoyant un nouveau message avec le role de user, et un bloc content contenant le type tool_result et les informations suivantes :
      • tool_use_id : L'id de la demande d'utilisation d'outil pour laquelle ceci est un résultat.
      • content : Le résultat de l'outil, sous forme de chaîne (par exemple ), une liste de blocs de contenu imbriqués (par exemple ), ou une liste de blocs de documents (par exemple ). Ces blocs de contenu peuvent utiliser les types , ou .

    Exigences de formatage importantes :

    • Les blocs de résultats d'outils doivent immédiatement suivre leurs blocs d'utilisation d'outils correspondants dans l'historique des messages. Vous ne pouvez pas inclure de messages entre le message d'utilisation d'outil de l'assistant et le message de résultat d'outil de l'utilisateur.
    • Dans le message utilisateur contenant les résultats des outils, les blocs tool_result doivent venir EN PREMIER dans le tableau de contenu. Tout texte doit venir APRÈS tous les résultats des outils.

    Par exemple, ceci causera une erreur 400 :

    {"role": "user", "content": [
      {"type": "text", "text": "Here are the results:"},  // ❌ Text before tool_result
      {"type": "tool_result", "tool_use_id": "toolu_01", ...}
    ]}

    Après avoir reçu le résultat de l'outil, Claude utilisera ces informations pour continuer à générer une réponse à l'invite utilisateur d'origine.

    Gestion des résultats des outils serveur

    Claude exécute l'outil en interne et incorpore les résultats directement dans sa réponse sans nécessiter d'interaction utilisateur supplémentaire.

    Différences par rapport aux autres API

    Contrairement aux API qui séparent l'utilisation d'outils ou utilisent des rôles spéciaux comme tool ou function, l'API Claude intègre les outils directement dans la structure des messages user et assistant.

    Les messages contiennent des tableaux de blocs text, image, tool_use et tool_result. Les messages user incluent le contenu client et tool_result, tandis que les messages assistant contiennent le contenu généré par l'IA et tool_use.

    Gestion de la raison d'arrêt max_tokens

    Si la réponse de Claude est coupée en raison du dépassement de la limite max_tokens, et que la réponse tronquée contient un bloc tool_use incomplet, vous devrez relancer la demande avec une valeur max_tokens plus élevée pour obtenir l'utilisation d'outil complète.

    Gestion de la raison d'arrêt pause_turn

    Lors de l'utilisation d'outils serveur comme la recherche Web, l'API peut retourner une raison d'arrêt pause_turn, indiquant que l'API a mis en pause un tour de longue durée.

    Voici comment gérer la raison d'arrêt pause_turn :

    Lors de la gestion de pause_turn :

    • Continuer la conversation : Transmettez la réponse mise en pause telle quelle dans une demande ultérieure pour permettre à Claude de continuer son tour
    • Modifier si nécessaire : Vous pouvez éventuellement modifier le contenu avant de continuer si vous souhaitez interrompre ou rediriger la conversation
    • Préserver l'état des outils : Incluez les mêmes outils dans la demande de continuation pour maintenir la fonctionnalité

    Dépannage des erreurs

    Gestion d'erreur intégrée : Tool runner fournit une gestion d'erreur automatique pour la plupart des scénarios courants. Cette section couvre la gestion d'erreur manuelle pour les cas d'usage avancés.

    Il existe plusieurs types d'erreurs qui peuvent survenir lors de l'utilisation d'outils avec Claude :

    import anthropic
    
    client = anthropic.Anthropic()
    
    response = client.messages.create(
        model="claude-sonnet-4-5-20250929",
        max_tokens=1024,
        betas=["advanced-tool-use-2025-11-20"],
        tools=[
            {
                "name": "get_weather",
                "description": "Get the current weather in a given location",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city and state, e.g. San Francisco, CA"
                        },
                        "unit": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"],
                            "description": "The unit of temperature"
                        }
                    },
                    "required": ["location"]
                },
                "input_examples": [
                    {
                        "location": "San Francisco, CA",
                        "unit": "fahrenheit"
                    },
                    {
                        "location": "Tokyo, Japan",
                        "unit": "celsius"
                    },
                    {
                        "location": "New York, NY"  # 'unit' is optional
                    }
                ]
            }
        ],
        messages=[
            {"role": "user", "content": "What's the weather like in San Francisco?"}
        ]
    )

    "content": "15 degrees"
    "content": [{"type": "text", "text": "15 degrees"}]
    "content": ["type": "document", "source": {"type": "text", "media_type": "text/plain", "data": "15 degrees"}]
    text
    image
    document
  1. is_error (optionnel) : Définissez à true si l'exécution de l'outil a entraîné une erreur.
  2. Ceci est correct :

    {"role": "user", "content": [
      {"type": "tool_result", "tool_use_id": "toolu_01", ...},
      {"type": "text", "text": "What should I do next?"}  // ✅ Text after tool_result
    ]}

    Si vous recevez une erreur comme « tool_use ids were found without tool_result blocks immediately after », vérifiez que vos résultats d'outils sont formatés correctement.

    # Check if response was truncated during tool use
    if response.stop_reason == "max_tokens":
        # Check if the last content block is an incomplete tool_use
        last_block = response.content[-1]
        if last_block.type == "tool_use":
            # Send the request with higher max_tokens
            response = client.messages.create(
                model="claude-sonnet-4-5",
                max_tokens=4096,  # Increased limit
                messages=messages,
                tools=tools
            )
    import anthropic
    
    client = anthropic.Anthropic()
    
    # Initial request with web search
    response = client.messages.create(
        model="claude-3-7-sonnet-latest",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Search for comprehensive information about quantum computing breakthroughs in 2025"
            }
        ],
        tools=[{
            "type": "web_search_20250305",
            "name": "web_search",
            "max_uses": 10
        }]
    )
    
    # Check if the response has pause_turn stop reason
    if response.stop_reason == "pause_turn":
        # Continue the conversation with the paused content
        messages = [
            {"role": "user", "content": "Search for comprehensive information about quantum computing breakthroughs in 2025"},
            {"role": "assistant", "content": response.content}
        ]
    
        # Send the continuation request
        continuation = client.messages.create(
            model="claude-3-7-sonnet-latest",
            max_tokens=1024,
            messages=messages,
            tools=[{
                "type": "web_search_20250305",
                "name": "web_search",
                "max_uses": 10
            }]
        )
    
        print(continuation)
    else:
        print(response)