---
title: Routage des tickets
url: https://platform.claude.com/docs/fr/about-claude/use-case-guides/ticket-routing
description: Ce guide explique comment exploiter les capacités avancées de compréhension du langage naturel de Claude pour classifier les tickets de support client à grande échelle en fonction de l'intention du client, de l'urgence, de la priorisation, du profil client, et plus encore.
---

## Prérequis

* Une clé API Claude et le SDK Claude installé
* Un accès à votre système de gestion de tickets de support existant, ainsi qu'une bonne connaissance de celui-ci
* Un échantillon de tickets de support historiques pour les tests

## Déterminer s'il convient d'utiliser Claude pour le routage des tickets

Voici quelques indicateurs clés montrant que vous devriez utiliser un « large language model » (grand modèle de langage), ou LLM, comme Claude plutôt que des approches de ML traditionnelles pour votre tâche de classification :

<AccordionGroup>
  <Accordion title="Vous disposez de peu de données d'entraînement étiquetées">
    Les processus de ML traditionnels nécessitent d'énormes jeux de données étiquetés. Le modèle préentraîné de Claude peut classifier efficacement les tickets avec seulement quelques dizaines d'exemples étiquetés, ce qui réduit considérablement le temps et les coûts de préparation des données.
  </Accordion>

  <Accordion title="Vos catégories de classification sont susceptibles de changer ou d'évoluer au fil du temps">
    Une fois qu'une approche de ML traditionnelle a été mise en place, la modifier est une entreprise laborieuse et gourmande en données. En revanche, à mesure que votre produit ou les besoins de vos clients évoluent, Claude peut facilement s'adapter aux changements de définitions de classes ou à de nouvelles classes sans réétiquetage massif des données d'entraînement.
  </Accordion>

  <Accordion title="Vous devez traiter des entrées textuelles complexes et non structurées">
    Les modèles de ML traditionnels ont souvent du mal avec les données non structurées et nécessitent une ingénierie des caractéristiques poussée. La compréhension avancée du langage de Claude permet une classification précise basée sur le contenu et le contexte, plutôt que de s'appuyer sur des structures ontologiques strictes.
  </Accordion>

  <Accordion title="Vos règles de classification reposent sur une compréhension sémantique">
    Les approches de ML traditionnelles s'appuient souvent sur des modèles de type sac de mots ou sur une simple correspondance de motifs. Claude excelle dans la compréhension et l'application de règles sous-jacentes lorsque les classes sont définies par des conditions plutôt que par des exemples.
  </Accordion>

  <Accordion title="Vous avez besoin d'un raisonnement interprétable pour les décisions de classification">
    De nombreux modèles de ML traditionnels offrent peu de visibilité sur leur processus de décision. Claude peut fournir des explications lisibles par un humain pour ses décisions de classification, ce qui renforce la confiance dans le système d'automatisation et facilite son adaptation si nécessaire.
  </Accordion>

  <Accordion title="Vous souhaitez gérer plus efficacement les cas limites et les tickets ambigus">
    Les systèmes de ML traditionnels ont souvent du mal avec les valeurs aberrantes et les entrées ambiguës, les classant fréquemment de manière erronée ou les reléguant par défaut dans une catégorie fourre-tout. Les capacités de traitement du langage naturel de Claude lui permettent de mieux interpréter le contexte et les nuances des tickets de support, réduisant potentiellement le nombre de tickets mal routés ou non classifiés qui nécessitent une intervention manuelle.
  </Accordion>

  <Accordion title="Vous avez besoin d'une prise en charge multilingue sans maintenir de modèles distincts">
    Les approches de ML traditionnelles nécessitent généralement des modèles distincts ou des processus de traduction lourds pour chaque langue prise en charge. Les capacités multilingues de Claude lui permettent de classifier des tickets dans diverses langues sans avoir besoin de modèles distincts ni de processus de traduction lourds, ce qui simplifie le support pour une clientèle internationale.
  </Accordion>
</AccordionGroup>

***

## Construire et déployer votre workflow de support basé sur un LLM

### Comprendre votre approche de support actuelle

Avant d'automatiser, il est essentiel de comprendre votre système de gestion de tickets existant. Commencez par examiner comment votre équipe de support gère actuellement le routage des tickets.

Posez-vous des questions telles que :

* Quels critères sont utilisés pour déterminer quel SLA/quelle offre de service est appliqué(e) ?
* Le routage des tickets sert-il à déterminer vers quel niveau de support ou quel spécialiste produit un ticket est dirigé ?
* Existe-t-il déjà des règles ou des workflows automatisés ? Dans quels cas échouent-ils ?
* Comment les cas limites ou les tickets ambigus sont-ils traités ?
* Comment l'équipe priorise-t-elle les tickets ?

Plus vous en savez sur la manière dont les humains traitent certains cas, mieux vous pourrez travailler avec Claude pour accomplir la tâche.

### Définir les catégories d'intention utilisateur

Une liste bien définie de catégories d'intention utilisateur est essentielle pour une classification précise des tickets de support avec Claude. La capacité de Claude à router efficacement les tickets au sein de votre système est directement proportionnelle à la qualité de définition des catégories de votre système.

Voici quelques exemples de catégories et sous-catégories d'intention utilisateur.

<AccordionGroup>
  <Accordion title="Problème technique">
    * Problème matériel
    * Bug logiciel
    * Problème de compatibilité
    * Problème de performance
  </Accordion>

  <Accordion title="Gestion de compte">
    * Réinitialisation de mot de passe
    * Problèmes d'accès au compte
    * Questions de facturation
    * Modifications d'abonnement
  </Accordion>

  <Accordion title="Informations sur le produit">
    * Questions sur les fonctionnalités
    * Questions de compatibilité produit
    * Informations tarifaires
    * Questions de disponibilité
  </Accordion>

  <Accordion title="Accompagnement utilisateur">
    * Questions pratiques
    * Aide à l'utilisation des fonctionnalités
    * Conseils sur les bonnes pratiques
    * Aide au dépannage
  </Accordion>

  <Accordion title="Retours">
    * Signalements de bugs
    * Demandes de fonctionnalités
    * Retours ou suggestions d'ordre général
    * Réclamations
  </Accordion>

  <Accordion title="Commandes">
    * Questions sur le statut de commande
    * Informations de livraison
    * Retours et échanges
    * Modifications de commande
  </Accordion>

  <Accordion title="Demande de service">
    * Aide à l'installation
    * Demandes de mise à niveau
    * Planification de maintenance
    * Résiliation de service
  </Accordion>

  <Accordion title="Préoccupations de sécurité">
    * Questions sur la confidentialité des données
    * Signalements d'activité suspecte
    * Aide sur les fonctionnalités de sécurité
  </Accordion>

  <Accordion title="Conformité et juridique">
    * Questions de conformité réglementaire
    * Questions sur les conditions d'utilisation
    * Demandes de documentation juridique
  </Accordion>

  <Accordion title="Support d'urgence">
    * Pannes système critiques
    * Problèmes de sécurité urgents
    * Problèmes sensibles au temps
  </Accordion>

  <Accordion title="Formation et éducation">
    * Demandes de formation produit
    * Questions sur la documentation
    * Informations sur les webinaires ou ateliers
  </Accordion>

  <Accordion title="Intégration et API">
    * Aide à l'intégration
    * Questions sur l'utilisation de l'API
    * Questions de compatibilité avec des tiers
  </Accordion>
</AccordionGroup>

Outre l'intention, le routage et la priorisation des tickets peuvent également être influencés par d'autres facteurs tels que l'urgence, le type de client, les SLA ou la langue. Veillez à prendre en compte d'autres critères de routage lors de la construction de votre système de routage automatisé.

### Établir des critères de réussite

Travaillez avec votre équipe de support pour [définir des critères de réussite clairs](https://platform.claude.com/docs/fr/test-and-evaluate/develop-tests) avec des références, des seuils et des objectifs mesurables.

Voici quelques critères et références standard lors de l'utilisation de LLM pour le routage des tickets de support :

<AccordionGroup>
  <Accordion title="Cohérence de la classification">
    Cette métrique évalue la cohérence avec laquelle Claude classifie des tickets similaires au fil du temps. Elle est essentielle pour maintenir la fiabilité du routage. Mesurez-la en testant périodiquement le modèle avec un ensemble d'entrées standardisées et en visant un taux de cohérence de 95 % ou plus.
  </Accordion>

  <Accordion title="Vitesse d'adaptation">
    Cette métrique mesure la rapidité avec laquelle Claude peut s'adapter à de nouvelles catégories ou à l'évolution des types de tickets. Testez-la en introduisant de nouveaux types de tickets et en mesurant le temps nécessaire au modèle pour atteindre une précision satisfaisante (par exemple, >90 %) sur ces nouvelles catégories. Visez une adaptation en 50 à 100 tickets d'exemple.
  </Accordion>

  <Accordion title="Gestion multilingue">
    Cette métrique évalue la capacité de Claude à router avec précision des tickets dans plusieurs langues. Mesurez la précision du routage dans différentes langues, en visant une baisse de précision ne dépassant pas 5 à 10 % pour les langues non principales.
  </Accordion>

  <Accordion title="Gestion des cas limites">
    Cette métrique évalue les performances de Claude sur des tickets inhabituels ou complexes. Créez un jeu de test de cas limites et mesurez la précision du routage, en visant au moins 80 % de précision sur ces entrées difficiles.
  </Accordion>

  <Accordion title="Atténuation des biais">
    Cette métrique mesure l'équité de Claude dans le routage entre différents profils démographiques de clients. Auditez régulièrement les décisions de routage pour détecter d'éventuels biais, en visant une précision de routage cohérente (à 2–3 % près) pour tous les groupes de clients.
  </Accordion>

  <Accordion title="Efficacité du prompt">
    Dans les situations où il est essentiel de minimiser le nombre de tokens, ce critère évalue les performances de Claude avec un contexte minimal. Mesurez la précision du routage avec différentes quantités de contexte fournies, en visant une précision de 90 % ou plus avec seulement le titre du ticket et une brève description.
  </Accordion>

  <Accordion title="Score d'explicabilité">
    Cette métrique évalue la qualité et la pertinence des explications de Claude pour ses décisions de routage. Des évaluateurs humains peuvent noter les explications sur une échelle (par exemple, de 1 à 5), l'objectif étant d'atteindre une note moyenne de 4 ou plus.
  </Accordion>
</AccordionGroup>

Voici quelques critères de réussite courants qui peuvent être utiles, qu'un LLM soit utilisé ou non :

<AccordionGroup>
  <Accordion title="Précision du routage">
    La précision du routage mesure la fréquence à laquelle les tickets sont correctement attribués à l'équipe ou à la personne appropriée dès la première tentative. Elle est généralement mesurée en pourcentage de tickets correctement routés par rapport au nombre total de tickets. Les références du secteur visent souvent une précision de 90 à 95 %, bien que cela puisse varier selon la complexité de la structure de support.
  </Accordion>

  <Accordion title="Délai d'attribution">
    Cette métrique suit la rapidité avec laquelle les tickets sont attribués après leur soumission. Des délais d'attribution plus courts conduisent généralement à des résolutions plus rapides et à une meilleure satisfaction client. Les meilleurs systèmes atteignent souvent des délais d'attribution moyens inférieurs à 5 minutes, beaucoup visant un routage quasi instantané (ce qui est possible avec des implémentations basées sur des LLM).
  </Accordion>

  <Accordion title="Taux de reroutage">
    Le taux de reroutage indique la fréquence à laquelle les tickets doivent être réattribués après le routage initial. Un taux plus faible suggère un routage initial plus précis. Visez un taux de reroutage inférieur à 10 %, les systèmes les plus performants atteignant des taux aussi bas que 5 % ou moins.
  </Accordion>

  <Accordion title="Taux de résolution au premier contact">
    Cette métrique mesure le pourcentage de tickets résolus lors de la première interaction avec le client. Des taux plus élevés indiquent un routage efficace et des équipes de support bien préparées. Les références du secteur se situent généralement entre 70 et 75 %, les plus performants atteignant des taux de 80 % ou plus.
  </Accordion>

  <Accordion title="Temps de traitement moyen">
    Le temps de traitement moyen mesure le temps nécessaire pour résoudre un ticket du début à la fin. Un routage efficace peut réduire considérablement ce temps. Les références varient largement selon le secteur et la complexité, mais de nombreuses organisations visent à maintenir le temps de traitement moyen sous 24 heures pour les problèmes non critiques.
  </Accordion>

  <Accordion title="Scores de satisfaction client">
    Souvent mesurés par des enquêtes post-interaction, ces scores reflètent la satisfaction globale des clients vis-à-vis du processus de support. Un routage efficace contribue à une satisfaction plus élevée. Visez des scores CSAT de 90 % ou plus, les plus performants atteignant souvent des taux de satisfaction de 95 % ou plus.
  </Accordion>

  <Accordion title="Taux d'escalade">
    Cette métrique mesure la fréquence à laquelle les tickets doivent être escaladés vers des niveaux de support supérieurs. Des taux d'escalade plus faibles indiquent souvent un routage initial plus précis. Efforcez-vous d'atteindre un taux d'escalade inférieur à 20 %, les meilleurs systèmes atteignant des taux de 10 % ou moins.
  </Accordion>

  <Accordion title="Productivité des agents">
    Cette métrique examine le nombre de tickets que les agents peuvent traiter efficacement après la mise en place de la solution de routage. Un routage amélioré devrait augmenter la productivité. Mesurez-la en suivant le nombre de tickets résolus par agent par jour ou par heure, en visant une amélioration de 10 à 20 % après la mise en place d'un nouveau système de routage.
  </Accordion>

  <Accordion title="Taux de déflexion en libre-service">
    Cette métrique mesure le pourcentage de tickets potentiels résolus via des options en libre-service avant d'entrer dans le système de routage. Des taux plus élevés indiquent un tri pré-routage efficace. Visez un taux de déflexion de 20 à 30 %, les plus performants atteignant des taux de 40 % ou plus.
  </Accordion>

  <Accordion title="Coût par ticket">
    Cette métrique calcule le coût moyen de résolution de chaque ticket de support. Un routage efficace devrait contribuer à réduire ce coût au fil du temps. Bien que les références varient largement, de nombreuses organisations visent à réduire le coût par ticket de 10 à 15 % après la mise en place d'un système de routage amélioré.
  </Accordion>
</AccordionGroup>

### Choisir le bon modèle Claude

Le choix du modèle dépend des compromis entre coût, précision et temps de réponse.

Claude Haiku 5.5 (`claude-haiku-5-5`) convient au routage des tickets : c'est le modèle actuel le plus rapide et le plus économique, et avec un effort `low`, il gère les requêtes simples et à volume élevé telles que la classification. Si votre problème de classification nécessite une expertise approfondie du domaine, un grand nombre de catégories d'intention ou un raisonnement complexe, vous pouvez opter pour le [modèle Sonnet, plus grand](https://platform.claude.com/docs/fr/models/overview).

### Construire un prompt solide

Le routage des tickets est un type de tâche de classification. Claude analyse le contenu d'un ticket de support et le classe dans des catégories prédéfinies en fonction du type de problème, de l'urgence, de l'expertise requise ou d'autres facteurs pertinents.

Rédigez un prompt de classification des tickets. Le prompt initial doit contenir le contenu de la demande de l'utilisateur et renvoyer à la fois le raisonnement et l'intention.

<Tip>
  Essayez la [recette de métaprompt du Claude Cookbook](https://colab.research.google.com/github/anthropics/claude-cookbooks/blob/main/misc/metaprompt.ipynb) pour que Claude rédige une première version à votre place.
</Tip>

Voici un exemple de prompt de classification pour le routage des tickets :

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Construisez le prompt dans le code.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Construisez le prompt dans le code.
  </CodeGroupItem>

  ```python Python
  def classify_support_request(ticket_contents):
      # Définir le prompt pour la tâche de classification.
      classification_prompt = f"""You will be acting as a customer support ticket classification system. Your task is to analyze customer support requests and output the appropriate classification intent for each request, along with your reasoning.

          Here is the customer support request you need to classify:

          <request>{ticket_contents}</request>

          Please carefully analyze the above request to determine the customer's core intent and needs. Consider what the customer is asking for has concerns about.

          First, write out your reasoning and analysis of how to classify this request inside <reasoning> tags.

          Then, output the appropriate classification label for the request inside a <intent> tag. The valid intents are:
          <intents>
          <intent>Support, Feedback, Complaint</intent>
          <intent>Order Tracking</intent>
          <intent>Refund/Exchange</intent>
          </intents>

          A request may have ONLY ONE applicable intent. Only include the intent that is most applicable to the request.

          As an example, consider the following request:
          <request>Hello! I had high-speed fiber internet installed on Saturday and my installer, Kevin, was absolutely fantastic! Where can I send my positive review? Thanks for your help!</request>

          Here is an example of how your output should be formatted (for the above example request):
          <reasoning>The user seeks information in order to leave positive feedback.</reasoning>
          <intent>Support, Feedback, Complaint</intent>

          Here are a few more examples:
          <examples>
          <example 2>
          Example 2 Input:
          <request>I wanted to write and personally thank you for the compassion you showed towards my family during my father's funeral this past weekend. Your staff was so considerate and helpful throughout this whole process; it really took a load off our shoulders. The visitation brochures were beautiful. We'll never forget the kindness you showed us and we are so appreciative of how smoothly the proceedings went. Thank you, again, Amarantha Hill on behalf of the Hill Family.</request>

          Example 2 Output:
          <reasoning>User leaves a positive review of their experience.</reasoning>
          <intent>Support, Feedback, Complaint</intent>
          </example 2>
          <example 3>

          […]

          </example 8>
          <example 9>
          Example 9 Input:
          <request>Your website keeps sending ad-popups that block the entire screen. It took me twenty minutes just to finally find the phone number to call and complain. How can I possibly access my account information with all of these popups? Can you access my account for me, since your website is broken? I need to know what the address is on file.</request>

          Example 9 Output:
          <reasoning>The user requests help accessing their web account information.</reasoning>
          <intent>Support, Feedback, Complaint</intent>
          </example 9>

          Remember to always include your classification reasoning before your actual intent output. The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          """
  ```

  ```typescript TypeScript
  function classifySupportRequest(ticketContents: string) {
    // Définir le prompt pour la tâche de classification.
    const classificationPrompt = `You will be acting as a customer support ticket classification system. Your task is to analyze customer support requests and output the appropriate classification intent for each request, along with your reasoning.

      Here is the customer support request you need to classify:

      <request>${ticketContents}</request>

      Please carefully analyze the above request to determine the customer's core intent and needs. Consider what the customer is asking for has concerns about.

      First, write out your reasoning and analysis of how to classify this request inside <reasoning> tags.

      Then, output the appropriate classification label for the request inside a <intent> tag. The valid intents are:
      <intents>
      <intent>Support, Feedback, Complaint</intent>
      <intent>Order Tracking</intent>
      <intent>Refund/Exchange</intent>
      </intents>

      A request may have ONLY ONE applicable intent. Only include the intent that is most applicable to the request.

      As an example, consider the following request:
      <request>Hello! I had high-speed fiber internet installed on Saturday and my installer, Kevin, was absolutely fantastic! Where can I send my positive review? Thanks for your help!</request>

      Here is an example of how your output should be formatted (for the above example request):
      <reasoning>The user seeks information in order to leave positive feedback.</reasoning>
      <intent>Support, Feedback, Complaint</intent>

      Here are a few more examples:
      <examples>
      <example 2>
      Example 2 Input:
      <request>I wanted to write and personally thank you for the compassion you showed towards my family during my father's funeral this past weekend. Your staff was so considerate and helpful throughout this whole process; it really took a load off our shoulders. The visitation brochures were beautiful. We'll never forget the kindness you showed us and we are so appreciative of how smoothly the proceedings went. Thank you, again, Amarantha Hill on behalf of the Hill Family.</request>

      Example 2 Output:
      <reasoning>User leaves a positive review of their experience.</reasoning>
      <intent>Support, Feedback, Complaint</intent>
      </example 2>
      <example 3>

      […]

      </example 8>
      <example 9>
      Example 9 Input:
      <request>Your website keeps sending ad-popups that block the entire screen. It took me twenty minutes just to finally find the phone number to call and complain. How can I possibly access my account information with all of these popups? Can you access my account for me, since your website is broken? I need to know what the address is on file.</request>

      Example 9 Output:
      <reasoning>The user requests help accessing their web account information.</reasoning>
      <intent>Support, Feedback, Complaint</intent>
      </example 9>

      Remember to always include your classification reasoning before your actual intent output. The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
      `;
  }
  ```

  ```csharp C#
  void ClassifySupportRequest(string ticketContents)
  {
      // Définir le prompt pour la tâche de classification.
      var classificationPrompt = $"""
          You will be acting as a customer support ticket classification system. Your task is to analyze customer support requests and output the appropriate classification intent for each request, along with your reasoning.

          Here is the customer support request you need to classify:

          <request>{ticketContents}</request>

          Please carefully analyze the above request to determine the customer's core intent and needs. Consider what the customer is asking for has concerns about.

          First, write out your reasoning and analysis of how to classify this request inside <reasoning> tags.

          Then, output the appropriate classification label for the request inside a <intent> tag. The valid intents are:
          <intents>
          <intent>Support, Feedback, Complaint</intent>
          <intent>Order Tracking</intent>
          <intent>Refund/Exchange</intent>
          </intents>

          A request may have ONLY ONE applicable intent. Only include the intent that is most applicable to the request.

          As an example, consider the following request:
          <request>Hello! I had high-speed fiber internet installed on Saturday and my installer, Kevin, was absolutely fantastic! Where can I send my positive review? Thanks for your help!</request>

          Here is an example of how your output should be formatted (for the above example request):
          <reasoning>The user seeks information in order to leave positive feedback.</reasoning>
          <intent>Support, Feedback, Complaint</intent>

          Here are a few more examples:
          <examples>
          <example 2>
          Example 2 Input:
          <request>I wanted to write and personally thank you for the compassion you showed towards my family during my father's funeral this past weekend. Your staff was so considerate and helpful throughout this whole process; it really took a load off our shoulders. The visitation brochures were beautiful. We'll never forget the kindness you showed us and we are so appreciative of how smoothly the proceedings went. Thank you, again, Amarantha Hill on behalf of the Hill Family.</request>

          Example 2 Output:
          <reasoning>User leaves a positive review of their experience.</reasoning>
          <intent>Support, Feedback, Complaint</intent>
          </example 2>
          <example 3>

          […]

          </example 8>
          <example 9>
          Example 9 Input:
          <request>Your website keeps sending ad-popups that block the entire screen. It took me twenty minutes just to finally find the phone number to call and complain. How can I possibly access my account information with all of these popups? Can you access my account for me, since your website is broken? I need to know what the address is on file.</request>

          Example 9 Output:
          <reasoning>The user requests help accessing their web account information.</reasoning>
          <intent>Support, Feedback, Complaint</intent>
          </example 9>

          Remember to always include your classification reasoning before your actual intent output. The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          """;
  }
  ```

  ```go Go
  func classifySupportRequest(ticketContents string) {
  	// Définir le prompt pour la tâche de classification.
  	classificationPrompt := `You will be acting as a customer support ticket classification system. Your task is to analyze customer support requests and output the appropriate classification intent for each request, along with your reasoning.

  		Here is the customer support request you need to classify:

  		<request>` + ticketContents + `</request>

  		Please carefully analyze the above request to determine the customer's core intent and needs. Consider what the customer is asking for has concerns about.

  		First, write out your reasoning and analysis of how to classify this request inside <reasoning> tags.

  		Then, output the appropriate classification label for the request inside a <intent> tag. The valid intents are:
  		<intents>
  		<intent>Support, Feedback, Complaint</intent>
  		<intent>Order Tracking</intent>
  		<intent>Refund/Exchange</intent>
  		</intents>

  		A request may have ONLY ONE applicable intent. Only include the intent that is most applicable to the request.

  		As an example, consider the following request:
  		<request>Hello! I had high-speed fiber internet installed on Saturday and my installer, Kevin, was absolutely fantastic! Where can I send my positive review? Thanks for your help!</request>

  		Here is an example of how your output should be formatted (for the above example request):
  		<reasoning>The user seeks information in order to leave positive feedback.</reasoning>
  		<intent>Support, Feedback, Complaint</intent>

  		Here are a few more examples:
  		<examples>
  		<example 2>
  		Example 2 Input:
  		<request>I wanted to write and personally thank you for the compassion you showed towards my family during my father's funeral this past weekend. Your staff was so considerate and helpful throughout this whole process; it really took a load off our shoulders. The visitation brochures were beautiful. We'll never forget the kindness you showed us and we are so appreciative of how smoothly the proceedings went. Thank you, again, Amarantha Hill on behalf of the Hill Family.</request>

  		Example 2 Output:
  		<reasoning>User leaves a positive review of their experience.</reasoning>
  		<intent>Support, Feedback, Complaint</intent>
  		</example 2>
  		<example 3>

  		[…]

  		</example 8>
  		<example 9>
  		Example 9 Input:
  		<request>Your website keeps sending ad-popups that block the entire screen. It took me twenty minutes just to finally find the phone number to call and complain. How can I possibly access my account information with all of these popups? Can you access my account for me, since your website is broken? I need to know what the address is on file.</request>

  		Example 9 Output:
  		<reasoning>The user requests help accessing their web account information.</reasoning>
  		<intent>Support, Feedback, Complaint</intent>
  		</example 9>

  		Remember to always include your classification reasoning before your actual intent output. The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
  		`
  // ...
  }
  ```

  ```java Java
  void classifySupportRequest(String ticketContents) {
      // Définir le prompt pour la tâche de classification.
      String classificationPrompt = """
          You will be acting as a customer support ticket classification system. Your task is to analyze customer support requests and output the appropriate classification intent for each request, along with your reasoning.

          Here is the customer support request you need to classify:

          <request>%s</request>

          Please carefully analyze the above request to determine the customer's core intent and needs. Consider what the customer is asking for has concerns about.

          First, write out your reasoning and analysis of how to classify this request inside <reasoning> tags.

          Then, output the appropriate classification label for the request inside a <intent> tag. The valid intents are:
          <intents>
          <intent>Support, Feedback, Complaint</intent>
          <intent>Order Tracking</intent>
          <intent>Refund/Exchange</intent>
          </intents>

          A request may have ONLY ONE applicable intent. Only include the intent that is most applicable to the request.

          As an example, consider the following request:
          <request>Hello! I had high-speed fiber internet installed on Saturday and my installer, Kevin, was absolutely fantastic! Where can I send my positive review? Thanks for your help!</request>

          Here is an example of how your output should be formatted (for the above example request):
          <reasoning>The user seeks information in order to leave positive feedback.</reasoning>
          <intent>Support, Feedback, Complaint</intent>

          Here are a few more examples:
          <examples>
          <example 2>
          Example 2 Input:
          <request>I wanted to write and personally thank you for the compassion you showed towards my family during my father's funeral this past weekend. Your staff was so considerate and helpful throughout this whole process; it really took a load off our shoulders. The visitation brochures were beautiful. We'll never forget the kindness you showed us and we are so appreciative of how smoothly the proceedings went. Thank you, again, Amarantha Hill on behalf of the Hill Family.</request>

          Example 2 Output:
          <reasoning>User leaves a positive review of their experience.</reasoning>
          <intent>Support, Feedback, Complaint</intent>
          </example 2>
          <example 3>

          […]

          </example 8>
          <example 9>
          Example 9 Input:
          <request>Your website keeps sending ad-popups that block the entire screen. It took me twenty minutes just to finally find the phone number to call and complain. How can I possibly access my account information with all of these popups? Can you access my account for me, since your website is broken? I need to know what the address is on file.</request>

          Example 9 Output:
          <reasoning>The user requests help accessing their web account information.</reasoning>
          <intent>Support, Feedback, Complaint</intent>
          </example 9>

          Remember to always include your classification reasoning before your actual intent output. The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          """.formatted(ticketContents);
  }
  ```

  ```php PHP
  function classifySupportRequest(string $ticketContents): void
  {
      // Définir le prompt pour la tâche de classification
      $classificationPrompt = <<<PROMPT
          You will be acting as a customer support ticket classification system. Your task is to analyze customer support requests and output the appropriate classification intent for each request, along with your reasoning.

          Here is the customer support request you need to classify:

          <request>{$ticketContents}</request>

          Please carefully analyze the above request to determine the customer's core intent and needs. Consider what the customer is asking for has concerns about.

          First, write out your reasoning and analysis of how to classify this request inside <reasoning> tags.

          Then, output the appropriate classification label for the request inside a <intent> tag. The valid intents are:
          <intents>
          <intent>Support, Feedback, Complaint</intent>
          <intent>Order Tracking</intent>
          <intent>Refund/Exchange</intent>
          </intents>

          A request may have ONLY ONE applicable intent. Only include the intent that is most applicable to the request.

          As an example, consider the following request:
          <request>Hello! I had high-speed fiber internet installed on Saturday and my installer, Kevin, was absolutely fantastic! Where can I send my positive review? Thanks for your help!</request>

          Here is an example of how your output should be formatted (for the above example request):
          <reasoning>The user seeks information in order to leave positive feedback.</reasoning>
          <intent>Support, Feedback, Complaint</intent>

          Here are a few more examples:
          <examples>
          <example 2>
          Example 2 Input:
          <request>I wanted to write and personally thank you for the compassion you showed towards my family during my father's funeral this past weekend. Your staff was so considerate and helpful throughout this whole process; it really took a load off our shoulders. The visitation brochures were beautiful. We'll never forget the kindness you showed us and we are so appreciative of how smoothly the proceedings went. Thank you, again, Amarantha Hill on behalf of the Hill Family.</request>

          Example 2 Output:
          <reasoning>User leaves a positive review of their experience.</reasoning>
          <intent>Support, Feedback, Complaint</intent>
          </example 2>
          <example 3>

          […]

          </example 8>
          <example 9>
          Example 9 Input:
          <request>Your website keeps sending ad-popups that block the entire screen. It took me twenty minutes just to finally find the phone number to call and complain. How can I possibly access my account information with all of these popups? Can you access my account for me, since your website is broken? I need to know what the address is on file.</request>

          Example 9 Output:
          <reasoning>The user requests help accessing their web account information.</reasoning>
          <intent>Support, Feedback, Complaint</intent>
          </example 9>

          Remember to always include your classification reasoning before your actual intent output. The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          PROMPT;
  }
  ```

  ```ruby Ruby
  def classify_support_request(ticket_contents)
    # Définir le prompt pour la tâche de classification.
    classification_prompt = <<~PROMPT
      You will be acting as a customer support ticket classification system. Your task is to analyze customer support requests and output the appropriate classification intent for each request, along with your reasoning.

      Here is the customer support request you need to classify:

      <request>#{ticket_contents}</request>

      Please carefully analyze the above request to determine the customer's core intent and needs. Consider what the customer is asking for has concerns about.

      First, write out your reasoning and analysis of how to classify this request inside <reasoning> tags.

      Then, output the appropriate classification label for the request inside a <intent> tag. The valid intents are:
      <intents>
      <intent>Support, Feedback, Complaint</intent>
      <intent>Order Tracking</intent>
      <intent>Refund/Exchange</intent>
      </intents>

      A request may have ONLY ONE applicable intent. Only include the intent that is most applicable to the request.

      As an example, consider the following request:
      <request>Hello! I had high-speed fiber internet installed on Saturday and my installer, Kevin, was absolutely fantastic! Where can I send my positive review? Thanks for your help!</request>

      Here is an example of how your output should be formatted (for the above example request):
      <reasoning>The user seeks information in order to leave positive feedback.</reasoning>
      <intent>Support, Feedback, Complaint</intent>

      Here are a few more examples:
      <examples>
      <example 2>
      Example 2 Input:
      <request>I wanted to write and personally thank you for the compassion you showed towards my family during my father's funeral this past weekend. Your staff was so considerate and helpful throughout this whole process; it really took a load off our shoulders. The visitation brochures were beautiful. We'll never forget the kindness you showed us and we are so appreciative of how smoothly the proceedings went. Thank you, again, Amarantha Hill on behalf of the Hill Family.</request>

      Example 2 Output:
      <reasoning>User leaves a positive review of their experience.</reasoning>
      <intent>Support, Feedback, Complaint</intent>
      </example 2>
      <example 3>

      […]

      </example 8>
      <example 9>
      Example 9 Input:
      <request>Your website keeps sending ad-popups that block the entire screen. It took me twenty minutes just to finally find the phone number to call and complain. How can I possibly access my account information with all of these popups? Can you access my account for me, since your website is broken? I need to know what the address is on file.</request>

      Example 9 Output:
      <reasoning>The user requests help accessing their web account information.</reasoning>
      <intent>Support, Feedback, Complaint</intent>
      </example 9>

      Remember to always include your classification reasoning before your actual intent output. The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
    PROMPT
  end
  ```
</CodeGroup>

<Note>
  Ce prompt est écrit pour Claude Haiku 5.5, qui s'exécute ici avec un effort `low`. Sur Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5 et Claude Sonnet 5.5, demandez plutôt l'intention et un résumé de la demande en une phrase. Consultez [Conserver le raisonnement dans les blocs de réflexion](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks).
</Note>

Voici les composants clés de ce prompt :

* Le modèle de prompt insère `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`) dans les balises `<request>`.
* Le prompt attribue à Claude un rôle clairement défini de système de classification qui analyse soigneusement le contenu du ticket pour déterminer l'intention et les besoins fondamentaux du client.
* Le prompt indique à Claude le formatage de sortie approprié, en l'occurrence fournir son raisonnement et son analyse dans des balises `<reasoning>`, suivis de l'étiquette de classification appropriée dans des balises `<intent>`.
* Le prompt précise les catégories d'intention valides : « Support, Feedback, Complaint », « Order Tracking » et « Refund/Exchange ».
* Le prompt inclut quelques exemples (c'est-à-dire du « few-shot prompting », ou prompting à quelques exemples) pour illustrer la manière dont la sortie doit être formatée, ce qui améliore la précision et la cohérence.

Demander à Claude de diviser sa réponse en sections distinctes délimitées par des balises XML vous permet d'utiliser des expressions régulières pour extraire indépendamment le raisonnement et l'intention de la sortie. Cela vous permet de créer des étapes suivantes ciblées dans le workflow de routage des tickets, par exemple en utilisant uniquement l'intention pour décider à quelle personne router le ticket.

### Déployer votre prompt

Il est difficile de savoir si votre prompt fonctionne bien sans le déployer dans un environnement de production de test et sans [exécuter des évaluations](https://platform.claude.com/docs/fr/test-and-evaluate/develop-tests).

Construisez la structure de déploiement. Commencez par définir la signature de la méthode qui encapsule l'appel à Claude. Étendez la méthode que vous avez commencé à écrire précédemment, qui prend `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`) en entrée, afin qu'elle renvoie désormais le raisonnement et l'intention en sortie. Si vous disposez d'une automatisation existante utilisant du ML traditionnel, vous devrez plutôt suivre la signature de cette méthode.

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Ce flux de travail nécessite plus de logique qu'une seule commande shell. Utilisez le SDK Claude pour l'exécuter.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Ce flux de travail nécessite plus de logique qu'une seule commande shell. Utilisez le SDK Claude pour l'exécuter.
  </CodeGroupItem>

  ```python Python
  import re

  # Créer une instance du client de l'API Claude
  client = anthropic.Anthropic()

  # Définir le modèle par défaut
  DEFAULT_MODEL = "claude-haiku-5-5"


  def classify_support_request(ticket_contents):
      # Définir le prompt pour la tâche de classification
      classification_prompt = f"""You will be acting as a customer support ticket classification system.
          […]
          ... The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          """
      # Envoyer le prompt à l'API pour classifier la demande d'assistance.
      message = client.messages.create(
          model=DEFAULT_MODEL,
          max_tokens=2048,
          output_config={"effort": "low"},
          messages=[{"role": "user", "content": classification_prompt}],
          stream=False,
      )
      reasoning_and_intent = next(
          (block.text for block in message.content if block.type == "text"), ""
      )

      # Utiliser la bibliothèque d'expressions régulières de Python pour extraire `reasoning`.
      reasoning_match = re.search(
          r"<reasoning>(.*?)</reasoning>", reasoning_and_intent, re.DOTALL
      )
      reasoning = reasoning_match.group(1).strip() if reasoning_match else ""

      # De même, extraire également `intent`.
      intent_match = re.search(r"<intent>(.*?)</intent>", reasoning_and_intent, re.DOTALL)
      intent = intent_match.group(1).strip() if intent_match else ""

      return reasoning, intent
  ```

  ```typescript TypeScript
  // Créer une instance du client de l'API Claude
  const client = new Anthropic();

  // Définir le modèle par défaut
  const DEFAULT_MODEL = "claude-haiku-5-5";

  async function classifySupportRequest(
    ticketContents: string
  ): Promise<{ reasoning: string; intent: string }> {
    // Définir le prompt pour la tâche de classification
    const classificationPrompt = `You will be acting as a customer support ticket classification system.
      […]
      ... The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
      `;
    // Envoyer le prompt à l'API pour classifier la demande d'assistance.
    const message = await client.messages.create({
      model: DEFAULT_MODEL,
      max_tokens: 2048,
      output_config: { effort: "low" },
      messages: [{ role: "user", content: classificationPrompt }]
    });
    const textBlock = message.content.find(
      (block): block is Anthropic.TextBlock => block.type === "text"
    );
    const reasoningAndIntent = textBlock?.text ?? "";

    // Utiliser une expression régulière pour extraire `reasoning`.
    const reasoningMatch = /<reasoning>(.*?)<\/reasoning>/s.exec(reasoningAndIntent);
    const reasoning = reasoningMatch?.[1].trim() ?? "";

    // De même, extraire également `intent`.
    const intentMatch = /<intent>(.*?)<\/intent>/s.exec(reasoningAndIntent);
    const intent = intentMatch?.[1].trim() ?? "";

    return { reasoning, intent };
  }
  ```

  ```csharp C#
  using System.Text.RegularExpressions;
  // ...

  // Créer une instance du client de l'API Claude.
  AnthropicClient client = new();

  // Définir le modèle par défaut.
  const Model DefaultModel = Model.ClaudeHaiku5_5;

  async Task<(string Reasoning, string Intent)> ClassifySupportRequest(string ticketContents)
  {
      // Définir le prompt pour la tâche de classification.
      var classificationPrompt = """
          You will be acting as a customer support ticket classification system.
          […]
          ... The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          """;
      // Envoyer le prompt à l'API pour classifier la demande d'assistance.
      var message = await client.Messages.Create(new MessageCreateParams
      {
          Model = DefaultModel,
          MaxTokens = 2048,
          OutputConfig = new OutputConfig { Effort = Effort.Low },
          Messages = [new() { Role = Role.User, Content = classificationPrompt }],
      });
      var reasoningAndIntent = "";
      foreach (var block in message.Content)
      {
          if (block.TryPickText(out var textBlock))
          {
              reasoningAndIntent = textBlock.Text;
              break;
          }
      }

      // Utiliser une expression régulière pour extraire `reasoning`.
      var reasoningMatch = Regex.Match(reasoningAndIntent, "<reasoning>(.*?)</reasoning>", RegexOptions.Singleline);
      var reasoning = reasoningMatch.Success ? reasoningMatch.Groups[1].Value.Trim() : "";

      // De même, extraire également l'`intent`.
      var intentMatch = Regex.Match(reasoningAndIntent, "<intent>(.*?)</intent>", RegexOptions.Singleline);
      var intent = intentMatch.Success ? intentMatch.Groups[1].Value.Trim() : "";

      return (reasoning, intent);
  }
  ```

  ```go Go
  import (
  	"context"
  	"regexp"
  	"strings"
  // ...
  )

  // Créer une instance du client de l'API Claude
  var client = anthropic.NewClient()

  // Définir le modèle par défaut
  const defaultModel = anthropic.ModelClaudeHaiku5_5

  func classifySupportRequest(ctx context.Context, ticketContents string) (reasoning, intent string, err error) {
  	// Définir le prompt pour la tâche de classification
  	classificationPrompt := `You will be acting as a customer support ticket classification system.
  		[…]
  		... The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
  		`
  	// Envoyer le prompt à l'API pour classifier la demande d'assistance.
  	message, err := client.Messages.New(ctx, anthropic.MessageNewParams{
  		Model:        defaultModel,
  		MaxTokens:    2048,
  		OutputConfig: anthropic.OutputConfigParam{Effort: anthropic.OutputConfigEffortLow},
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock(classificationPrompt)),
  		},
  	})
  	if err != nil {
  		return "", "", err
  	}
  	var reasoningAndIntent string
  	for _, block := range message.Content {
  		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  			reasoningAndIntent = textBlock.Text
  			break
  		}
  	}

  	// Utiliser une expression régulière pour extraire `reasoning`.
  	reasoningMatch := regexp.MustCompile(`(?s)<reasoning>(.*?)</reasoning>`).FindStringSubmatch(reasoningAndIntent)
  	if reasoningMatch != nil {
  		reasoning = strings.TrimSpace(reasoningMatch[1])
  	}

  	// De même, extraire également `intent`.
  	intentMatch := regexp.MustCompile(`(?s)<intent>(.*?)</intent>`).FindStringSubmatch(reasoningAndIntent)
  	if intentMatch != nil {
  		intent = strings.TrimSpace(intentMatch[1])
  	}

  	return reasoning, intent, nil
  }
  ```

  ```java Java
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;

  // Créer une instance du client de l'API Claude
  final AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Définir le modèle par défaut
  static final Model DEFAULT_MODEL = Model.CLAUDE_HAIKU_5_5;

  record Classification(String reasoning, String intent) {}

  Classification classifySupportRequest(String ticketContents) {
      // Définir le prompt pour la tâche de classification
      String classificationPrompt = """
          You will be acting as a customer support ticket classification system.
          […]
          ... The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          """;
      // Envoyer le prompt à l'API pour classifier la demande d'assistance.
      Message message = client.messages().create(MessageCreateParams.builder()
          .model(DEFAULT_MODEL)
          .maxTokens(2048L)
          .outputConfig(OutputConfig.builder().effort(OutputConfig.Effort.LOW).build())
          .addUserMessage(classificationPrompt)
          .build());
      String reasoningAndIntent = message.content().stream()
          .flatMap(block -> block.text().stream())
          .map(textBlock -> textBlock.text())
          .findFirst()
          .orElse("");

      // Utiliser une expression régulière pour extraire `reasoning`.
      Matcher reasoningMatch = Pattern.compile("<reasoning>(.*?)</reasoning>", Pattern.DOTALL)
          .matcher(reasoningAndIntent);
      String reasoning = reasoningMatch.find() ? reasoningMatch.group(1).strip() : "";

      // De même, extraire également `intent`.
      Matcher intentMatch = Pattern.compile("<intent>(.*?)</intent>", Pattern.DOTALL)
          .matcher(reasoningAndIntent);
      String intent = intentMatch.find() ? intentMatch.group(1).strip() : "";

      return new Classification(reasoning, intent);
  }
  ```

  ```php PHP
  // Créer une instance du client de l'API Claude
  $client = new Client();

  // Définir le modèle par défaut
  const DEFAULT_MODEL = Model::CLAUDE_HAIKU_5_5;

  /**
   * @return array{string, string} the reasoning and the intent
   */
  function classifySupportRequest(Client $client, string $ticketContents): array
  {
      // Définir le prompt pour la tâche de classification
      $classificationPrompt = <<<PROMPT
          You will be acting as a customer support ticket classification system.
          […]
          ... The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          PROMPT;
      // Envoyer le prompt à l'API pour classifier la demande d'assistance.
      $message = $client->messages->create(
          model: DEFAULT_MODEL,
          maxTokens: 2048,
          outputConfig: ['effort' => 'low'],
          messages: [['role' => 'user', 'content' => $classificationPrompt]],
      );
      $reasoningAndIntent = '';
      foreach ($message->content as $block) {
          if ($block instanceof \Anthropic\Messages\TextBlock) {
              $reasoningAndIntent = $block->text;
              break;
          }
      }

      // Utiliser une expression régulière pour extraire `reasoning`.
      $reasoning = preg_match('/<reasoning>(.*?)<\/reasoning>/s', $reasoningAndIntent, $reasoningMatch)
          ? trim($reasoningMatch[1])
          : '';

      // De même, extraire également `intent`.
      $intent = preg_match('/<intent>(.*?)<\/intent>/s', $reasoningAndIntent, $intentMatch)
          ? trim($intentMatch[1])
          : '';

      return [$reasoning, $intent];
  }
  ```

  ```ruby Ruby
  # Créer une instance du client de l'API Claude.
  client = Anthropic::Client.new

  # Définir le modèle par défaut.
  DEFAULT_MODEL = Anthropic::Model::CLAUDE_HAIKU_5_5

  def classify_support_request(client, ticket_contents)
    # Définir le prompt pour la tâche de classification.
    classification_prompt = <<~PROMPT
      You will be acting as a customer support ticket classification system.
      […]
      ... The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
    PROMPT
    # Envoyer le prompt à l'API pour classifier la demande d'assistance.
    message = client.messages.create(
      model: DEFAULT_MODEL,
      max_tokens: 2048,
      output_config: { effort: "low" },
      messages: [{ role: "user", content: classification_prompt }]
    )
    reasoning_and_intent = message.content.grep(Anthropic::Models::TextBlock).first&.text || ""

    # Utiliser une expression régulière pour extraire `reasoning`.
    reasoning = reasoning_and_intent[%r{<reasoning>(.*?)</reasoning>}m, 1]&.strip || ""

    # De même, extraire également `intent`.
    intent = reasoning_and_intent[%r{<intent>(.*?)</intent>}m, 1]&.strip || ""

    [reasoning, intent]
  end
  ```
</CodeGroup>

Ce code :

* Crée une instance de client à l'aide de votre clé API.
* Définit une fonction `classify_support_request` (typescript, go, java, php: `classifySupportRequest`; csharp: `ClassifySupportRequest`) qui prend une chaîne `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`).
* Envoie `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`) à Claude pour classification à l'aide de `classification_prompt` (typescript, csharp, go, java: `classificationPrompt`; php: `$classificationPrompt`).
* Renvoie le raisonnement et l'intention du modèle extraits de la réponse.

Comme l'intégralité du texte du raisonnement et de l'intention doit être générée avant l'analyse, l'exemple n'utilise pas le streaming pour la réponse.

***

## Évaluer votre prompt

Le prompting nécessite souvent des tests et une optimisation pour être prêt pour la production. Pour déterminer si votre solution est prête, évaluez ses performances en fonction des critères de réussite et des seuils que vous avez établis précédemment.

Pour exécuter votre évaluation, vous avez besoin de cas de test sur lesquels l'exécuter. Le reste de ce guide suppose que vous avez déjà [développé vos cas de test](https://platform.claude.com/docs/fr/test-and-evaluate/develop-tests).

### Créer une fonction d'évaluation

L'exemple d'évaluation de ce guide mesure les performances de Claude selon trois métriques clés :

* Précision
* Coût par classification

Vous devrez peut-être évaluer Claude selon d'autres axes en fonction des facteurs qui sont importants pour vous.

Pour ce faire, modifiez d'abord le script pour ajouter une fonction qui compare l'intention prédite à l'intention réelle et calcule le pourcentage de prédictions correctes. Ajoutez ensuite des fonctionnalités de calcul des coûts et de mesure du temps.

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Ce flux de travail nécessite plus de logique qu'une seule commande shell. Utilisez le SDK Claude pour l'exécuter.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Ce flux de travail nécessite plus de logique qu'une seule commande shell. Utilisez le SDK Claude pour l'exécuter.
  </CodeGroupItem>

  ```python Python
  import re

  # Créer une instance du client de l'API Claude.
  client = anthropic.Anthropic()

  # Définir le modèle par défaut.
  DEFAULT_MODEL = "claude-haiku-5-5"


  def classify_support_request(request, actual_intent):
      # Définir le prompt pour la tâche de classification.
      classification_prompt = f"""You will be acting as a customer support ticket classification system.
          […]
          ...The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          """

      message = client.messages.create(
          model=DEFAULT_MODEL,
          max_tokens=2048,
          output_config={"effort": "low"},
          messages=[{"role": "user", "content": classification_prompt}],
      )
      usage = message.usage  # Get the usage statistics for the API call for how many input and output tokens were used.
      reasoning_and_intent = next(
          (block.text for block in message.content if block.type == "text"), ""
      )

      # Utiliser la bibliothèque d'expressions régulières de Python pour extraire `reasoning`.
      reasoning_match = re.search(
          r"<reasoning>(.*?)</reasoning>", reasoning_and_intent, re.DOTALL
      )
      reasoning = reasoning_match.group(1).strip() if reasoning_match else ""

      # De même, extraire également `intent`.
      intent_match = re.search(r"<intent>(.*?)</intent>", reasoning_and_intent, re.DOTALL)
      intent = intent_match.group(1).strip() if intent_match else ""

      # Vérifier si la prédiction du modèle est correcte.
      correct = actual_intent.strip() == intent.strip()

      # Renvoyer le raisonnement, l'intention, l'exactitude et l'utilisation.
      return reasoning, intent, correct, usage
  ```

  ```typescript TypeScript
  // Créer une instance du client de l'API Claude
  const client = new Anthropic();

  // Définir le modèle par défaut
  const DEFAULT_MODEL = "claude-haiku-5-5";

  async function classifySupportRequest(
    request: string,
    actualIntent: string
  ): Promise<{ reasoning: string; intent: string; correct: boolean; usage: Anthropic.Usage }> {
    // Définir le prompt pour la tâche de classification
    const classificationPrompt = `You will be acting as a customer support ticket classification system.
      […]
      ...The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
      `;

    const message = await client.messages.create({
      model: DEFAULT_MODEL,
      max_tokens: 2048,
      output_config: { effort: "low" },
      messages: [{ role: "user", content: classificationPrompt }]
    });
    // Obtenir les statistiques d'utilisation de l'appel API : nombre de tokens d'entrée et de sortie utilisés.
    const usage = message.usage;
    const textBlock = message.content.find(
      (block): block is Anthropic.TextBlock => block.type === "text"
    );
    const reasoningAndIntent = textBlock?.text ?? "";

    // Utiliser une expression régulière pour extraire `reasoning`.
    const reasoningMatch = /<reasoning>(.*?)<\/reasoning>/s.exec(reasoningAndIntent);
    const reasoning = reasoningMatch?.[1].trim() ?? "";

    // De même, extraire également `intent`.
    const intentMatch = /<intent>(.*?)<\/intent>/s.exec(reasoningAndIntent);
    const intent = intentMatch?.[1].trim() ?? "";

    // Vérifier si la prédiction du modèle est correcte.
    const correct = actualIntent.trim() === intent.trim();

    // Renvoyer le raisonnement, l'intention, l'exactitude et l'utilisation.
    return { reasoning, intent, correct, usage };
  }
  ```

  ```csharp C#
  using System.Text.RegularExpressions;
  // ...

  // Créer une instance du client de l'API Claude.
  AnthropicClient client = new();

  // Définir le modèle par défaut.
  const Model DefaultModel = Model.ClaudeHaiku5_5;

  async Task<(string Reasoning, string Intent, bool Correct, Usage Usage)> ClassifySupportRequest(string request, string actualIntent)
  {
      // Définir le prompt pour la tâche de classification.
      var classificationPrompt = """
          You will be acting as a customer support ticket classification system.
          […]
          ...The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          """;

      var message = await client.Messages.Create(new MessageCreateParams
      {
          Model = DefaultModel,
          MaxTokens = 2048,
          OutputConfig = new OutputConfig { Effort = Effort.Low },
          Messages = [new() { Role = Role.User, Content = classificationPrompt }],
      });
      // Obtenir les statistiques d'utilisation de l'appel API, soit le nombre de tokens d'entrée et de tokens de sortie utilisés.
      var usage = message.Usage;
      var reasoningAndIntent = "";
      foreach (var block in message.Content)
      {
          if (block.TryPickText(out var textBlock))
          {
              reasoningAndIntent = textBlock.Text;
              break;
          }
      }

      // Utiliser une expression régulière pour extraire `reasoning`.
      var reasoningMatch = Regex.Match(reasoningAndIntent, "<reasoning>(.*?)</reasoning>", RegexOptions.Singleline);
      var reasoning = reasoningMatch.Success ? reasoningMatch.Groups[1].Value.Trim() : "";

      // De même, extraire également `intent`.
      var intentMatch = Regex.Match(reasoningAndIntent, "<intent>(.*?)</intent>", RegexOptions.Singleline);
      var intent = intentMatch.Success ? intentMatch.Groups[1].Value.Trim() : "";

      // Vérifier si la prédiction du modèle est correcte.
      var correct = actualIntent.Trim() == intent.Trim();

      // Renvoyer le raisonnement, l'intention, l'exactitude et l'utilisation.
      return (reasoning, intent, correct, usage);
  }
  ```

  ```go Go
  import (
  	"context"
  	"regexp"
  	"strings"
  // ...
  )

  // Créer une instance du client de l'API Claude
  var client = anthropic.NewClient()

  // Définir le modèle par défaut
  const defaultModel = anthropic.ModelClaudeHaiku5_5

  func classifySupportRequest(ctx context.Context, request, actualIntent string) (reasoning, intent string, correct bool, usage anthropic.Usage, err error) {
  	// Définir le prompt pour la tâche de classification
  	classificationPrompt := `You will be acting as a customer support ticket classification system.
  		[…]
  		...The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
  		`
  	message, err := client.Messages.New(ctx, anthropic.MessageNewParams{
  		Model:        defaultModel,
  		MaxTokens:    2048,
  		OutputConfig: anthropic.OutputConfigParam{Effort: anthropic.OutputConfigEffortLow},
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock(classificationPrompt)),
  		},
  	})
  	if err != nil {
  		return "", "", false, anthropic.Usage{}, err
  	}
  	// Obtenir les statistiques d'utilisation de l'appel API, soit le nombre de tokens d'entrée et de tokens de sortie utilisés.
  	usage = message.Usage
  	var reasoningAndIntent string
  	for _, block := range message.Content {
  		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  			reasoningAndIntent = textBlock.Text
  			break
  		}
  	}

  	// Utiliser une expression régulière pour extraire `reasoning`.
  	reasoningMatch := regexp.MustCompile(`(?s)<reasoning>(.*?)</reasoning>`).FindStringSubmatch(reasoningAndIntent)
  	if reasoningMatch != nil {
  		reasoning = strings.TrimSpace(reasoningMatch[1])
  	}

  	// De même, extraire également `intent`.
  	intentMatch := regexp.MustCompile(`(?s)<intent>(.*?)</intent>`).FindStringSubmatch(reasoningAndIntent)
  	if intentMatch != nil {
  		intent = strings.TrimSpace(intentMatch[1])
  	}

  	// Vérifier si la prédiction du modèle est correcte.
  	correct = strings.TrimSpace(actualIntent) == strings.TrimSpace(intent)

  	// Renvoyer le raisonnement, l'intention, l'exactitude et l'utilisation.
  	return reasoning, intent, correct, usage, nil
  }
  ```

  ```java Java
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;

  // Créer une instance du client de l'API Claude
  final AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Définir le modèle par défaut
  static final Model DEFAULT_MODEL = Model.CLAUDE_HAIKU_5_5;

  record Classification(String reasoning, String intent, boolean correct, Usage usage) {}

  Classification classifySupportRequest(String request, String actualIntent) {
      // Définir le prompt pour la tâche de classification
      String classificationPrompt = """
          You will be acting as a customer support ticket classification system.
          […]
          ...The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          """;

      Message message = client.messages().create(MessageCreateParams.builder()
          .model(DEFAULT_MODEL)
          .maxTokens(2048L)
          .outputConfig(OutputConfig.builder().effort(OutputConfig.Effort.LOW).build())
          .addUserMessage(classificationPrompt)
          .build());
      // Obtenir les statistiques d'utilisation de l'appel API : nombre de tokens d'entrée et de sortie utilisés.
      Usage usage = message.usage();
      String reasoningAndIntent = message.content().stream()
          .flatMap(block -> block.text().stream())
          .map(textBlock -> textBlock.text())
          .findFirst()
          .orElse("");

      // Utiliser une expression régulière pour extraire `reasoning`.
      Matcher reasoningMatch = Pattern.compile("<reasoning>(.*?)</reasoning>", Pattern.DOTALL)
          .matcher(reasoningAndIntent);
      String reasoning = reasoningMatch.find() ? reasoningMatch.group(1).strip() : "";

      // De même, extraire également `intent`.
      Matcher intentMatch = Pattern.compile("<intent>(.*?)</intent>", Pattern.DOTALL)
          .matcher(reasoningAndIntent);
      String intent = intentMatch.find() ? intentMatch.group(1).strip() : "";

      // Vérifier si la prédiction du modèle est correcte.
      boolean correct = actualIntent.strip().equals(intent.strip());

      // Renvoyer le raisonnement, l'intention, l'exactitude et l'utilisation.
      return new Classification(reasoning, intent, correct, usage);
  }
  ```

  ```php PHP
  // Créer une instance du client de l'API Claude
  $client = new Client();

  // Définir le modèle par défaut
  const DEFAULT_MODEL = Model::CLAUDE_HAIKU_5_5;

  /**
   * @return array{string, string, bool, Usage} the reasoning, the intent, whether the intent is correct, and the usage
   */
  function classifySupportRequest(Client $client, string $request, string $actualIntent): array
  {
      // Définir le prompt pour la tâche de classification
      $classificationPrompt = <<<PROMPT
          You will be acting as a customer support ticket classification system.
          […]
          ...The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
          PROMPT;

      $message = $client->messages->create(
          model: DEFAULT_MODEL,
          maxTokens: 2048,
          outputConfig: ['effort' => 'low'],
          messages: [['role' => 'user', 'content' => $classificationPrompt]],
      );
      // Obtenir les statistiques d'utilisation de l'appel API : nombre de tokens d'entrée et de sortie utilisés.
      $usage = $message->usage;
      $reasoningAndIntent = '';
      foreach ($message->content as $block) {
          if ($block instanceof \Anthropic\Messages\TextBlock) {
              $reasoningAndIntent = $block->text;
              break;
          }
      }

      // Utiliser une expression régulière pour extraire `reasoning`.
      $reasoning = preg_match('/<reasoning>(.*?)<\/reasoning>/s', $reasoningAndIntent, $reasoningMatch)
          ? trim($reasoningMatch[1])
          : '';

      // De même, extraire également `intent`.
      $intent = preg_match('/<intent>(.*?)<\/intent>/s', $reasoningAndIntent, $intentMatch)
          ? trim($intentMatch[1])
          : '';

      // Vérifier si la prédiction du modèle est correcte.
      $correct = trim($actualIntent) === trim($intent);

      // Renvoyer le raisonnement, l'intention, l'exactitude et l'utilisation.
      return [$reasoning, $intent, $correct, $usage];
  }
  ```

  ```ruby Ruby
  # Créer une instance du client de l'API Claude
  client = Anthropic::Client.new

  # Définir le modèle par défaut
  DEFAULT_MODEL = Anthropic::Model::CLAUDE_HAIKU_5_5

  def classify_support_request(client, request, actual_intent)
    # Définir le prompt pour la tâche de classification
    classification_prompt = <<~PROMPT
      You will be acting as a customer support ticket classification system.
      […]
      ...The reasoning should be enclosed in <reasoning> tags and the intent in <intent> tags. Return only the reasoning and the intent.
    PROMPT

    message = client.messages.create(
      model: DEFAULT_MODEL,
      max_tokens: 2048,
      output_config: { effort: "low" },
      messages: [{ role: "user", content: classification_prompt }]
    )
    # Obtenir les statistiques d'utilisation de l'appel API : nombre de tokens d'entrée et de sortie utilisés.
    usage = message.usage
    reasoning_and_intent = message.content.grep(Anthropic::Models::TextBlock).first&.text || ""

    # Utiliser une expression régulière pour extraire `reasoning`.
    reasoning = reasoning_and_intent[%r{<reasoning>(.*?)</reasoning>}m, 1]&.strip || ""

    # De même, extraire également `intent`.
    intent = reasoning_and_intent[%r{<intent>(.*?)</intent>}m, 1]&.strip || ""

    # Vérifier si la prédiction du modèle est correcte.
    correct = actual_intent.strip == intent.strip

    # Renvoyer le raisonnement, l'intention, l'exactitude et l'utilisation.
    [reasoning, intent, correct, usage]
  end
  ```
</CodeGroup>

Voici le détail des modifications :

* La méthode `classify_support_request` (typescript, go, java, php: `classifySupportRequest`; csharp: `ClassifySupportRequest`) prend désormais `actual_intent` (typescript, csharp, go, java: `actualIntent`; php: `$actualIntent`) issu des cas de test et le compare à la classification d'intention de Claude pour déterminer s'ils correspondent.
* La méthode extrait les statistiques d'utilisation de l'appel API pour calculer le coût en fonction des tokens d'entrée et des tokens de sortie utilisés.

### Exécuter votre évaluation

Une évaluation correcte nécessite des seuils et des références clairs pour déterminer ce qui constitue un bon résultat. Le script précédent renvoie les valeurs d'exécution pour la précision, le temps de réponse et le coût par classification, mais vous avez toujours besoin de seuils clairement établis. Par exemple :

* **Précision :** 95 % (sur 100 tests)
* **Coût par classification :** réduction de 50 % en moyenne (sur 100 tests) par rapport à la méthode de routage actuelle

Disposer de ces seuils vous permet de déterminer rapidement et facilement, à grande échelle et avec un empirisme impartial, quelle méthode vous convient le mieux et quels changements pourraient être nécessaires pour mieux répondre à vos exigences.

***

## Améliorer les performances

Dans des scénarios complexes, il peut être utile d'envisager des stratégies supplémentaires pour améliorer les performances au-delà des [techniques de prompt engineering](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/overview) standard et des [stratégies de mise en place de garde-fous](https://platform.claude.com/docs/fr/test-and-evaluate/strengthen-guardrails/reduce-hallucinations). Voici quelques scénarios courants :

### Utiliser une hiérarchie taxonomique pour les cas comportant plus de 20 catégories d'intention

À mesure que le nombre de classes augmente, le nombre d'exemples requis augmente également, ce qui peut rendre le prompt difficile à gérer. Comme alternative, vous pouvez envisager de mettre en œuvre un système de classification hiérarchique utilisant une combinaison de classificateurs.

1. Organisez vos intentions dans une structure arborescente taxonomique.
2. Créez une série de classificateurs à chaque niveau de l'arbre, permettant une approche de routage en cascade.

Par exemple, vous pourriez avoir un classificateur de premier niveau qui catégorise globalement les tickets en « Technical Issues » (problèmes techniques), « Billing Questions » (questions de facturation) et « General Inquiries » (demandes générales). Chacune de ces catégories peut ensuite disposer de son propre sous-classificateur pour affiner davantage la classification.

```mermaid
---
config:
  flowchart:
    nodeSpacing: 10
    rankSpacing: 60
    padding: 8
    wrappingWidth: 300
---
flowchart LR
  accTitle: Hierarchy of ticket classifiers
  accDescr: Classifier hierarchy routing tickets to Technical Issues, Billing Questions, or General Inquiries, each with a sub-classifier
  tickets[Support Tickets] --> technical[Technical Issues]
  tickets --> billing[Billing Questions]
  tickets --> general[General Inquiries]
  technical --> software[Software Installation]
  technical --> hardware[Hardware Troubleshooting]
  technical --> network[Network Connectivity]
  technical --> technicalMore[...]
  billing --> invoice[Invoice Clarification]
  billing --> payment[Payment Processing]
  billing --> refund[Refund Requests]
  general --> product[Product Information]
  general --> order[Order Status]
  general --> partnership[Partnership Opportunities]
  general --> generalMore[...]
```

* **Avantages - plus de nuance et de précision :** vous pouvez créer des prompts différents pour chaque chemin parent, ce qui permet une classification plus ciblée et adaptée au contexte. Cela peut conduire à une meilleure précision et à un traitement plus nuancé des demandes des clients.

* **Inconvénients - latence accrue :** sachez que l'utilisation de plusieurs classificateurs peut entraîner une « latency » (latence) accrue, et Anthropic recommande de mettre en œuvre cette approche avec le modèle le plus rapide, Haiku.

### Utiliser des bases de données vectorielles et la recherche par similarité pour gérer des tickets très variables

Bien que fournir des exemples soit le moyen le plus efficace d'améliorer les performances, si les demandes de support sont très variables, il peut être difficile d'inclure suffisamment d'exemples dans un seul prompt.

Dans ce scénario, vous pourriez utiliser une base de données vectorielle pour effectuer des recherches par similarité à partir d'un jeu de données d'exemples et récupérer les exemples les plus pertinents pour une requête donnée.

Cette approche, décrite en détail dans la [recette de classification](https://platform.claude.com/cookbook/capabilities-classification-guide), a permis d'améliorer les performances de 71 % à 93 % de précision.

### Tenir compte spécifiquement des cas limites attendus

Voici quelques scénarios dans lesquels Claude peut mal classifier des tickets (il peut en exister d'autres propres à votre situation). Dans ces scénarios, envisagez de fournir dans le prompt des instructions explicites ou des exemples sur la manière dont Claude doit gérer le cas limite :

<AccordionGroup>
  <Accordion title="Les clients formulent des demandes implicites">
    Les clients expriment souvent leurs besoins de manière indirecte. Par exemple, « J'attends mon colis depuis plus de deux semaines maintenant » peut être une demande indirecte de statut de commande.

    * **Solution :** fournissez à Claude quelques exemples réels de clients pour ce type de demandes, accompagnés de l'intention sous-jacente. Vous pouvez obtenir des résultats encore meilleurs si vous incluez une justification de classification pour les intentions de tickets particulièrement nuancées, afin que Claude puisse mieux généraliser la logique à d'autres tickets.
  </Accordion>

  <Accordion title="Claude privilégie l'émotion plutôt que l'intention">
    Lorsque les clients expriment leur mécontentement, Claude peut privilégier la prise en compte de l'émotion plutôt que la résolution du problème sous-jacent.

    * **Solution :** donnez à Claude des indications sur les moments où il doit ou non privilégier le sentiment du client. Cela peut être aussi simple que « Ignore toutes les émotions du client. Concentre-toi uniquement sur l'analyse de l'intention de la demande du client et sur les informations que le client pourrait rechercher. »
  </Accordion>

  <Accordion title="Plusieurs problèmes créent une confusion dans la priorisation">
    Lorsque les clients présentent plusieurs problèmes au cours d'une même interaction, Claude peut avoir du mal à identifier la préoccupation principale.

    * **Solution :** clarifiez la priorisation des intentions afin que Claude puisse mieux hiérarchiser les intentions extraites et identifier la préoccupation principale.
  </Accordion>
</AccordionGroup>

***

## Intégrer Claude dans votre workflow de support global

Une intégration correcte nécessite que vous preniez certaines décisions concernant la manière dont votre script de routage de tickets basé sur Claude s'intègre dans l'architecture de votre système de routage de tickets global. Il existe deux façons de procéder :

* **Mode push :** le système de tickets de support que vous utilisez (par exemple, Zendesk) déclenche votre code en envoyant un événement webhook à votre service de routage, qui classifie ensuite l'intention et route le ticket.
  * Cette approche est plus évolutive à l'échelle du web, mais nécessite que vous exposiez un point de terminaison public.
* **Mode pull :** votre code récupère les derniers tickets selon un calendrier donné et les route au moment de la récupération.
  * Cette approche est plus facile à mettre en œuvre, mais peut effectuer des appels inutiles au système de tickets de support lorsque la fréquence de récupération est trop élevée, ou être excessivement lente lorsque la fréquence de récupération est trop faible.

Pour chacune de ces approches, vous devez encapsuler votre script dans un service. Le choix de l'approche dépend des API fournies par votre système de gestion de tickets de support.

***

<CardGroup cols={2}>
  <Card title="Cookbook de classification" icon="link" href="https://platform.claude.com/cookbook/capabilities-classification-guide">
    Consultez le cookbook de classification pour plus d'exemples de code et des conseils détaillés sur les évaluations.
  </Card>

  <Card title="Claude Console" icon="link" href="https://platform.claude.com/dashboard">
    Commencez à construire et à évaluer votre workflow sur la Claude Console.
  </Card>
</CardGroup>