---
title: Roteamento de tickets
url: https://platform.claude.com/docs/pt-BR/about-claude/use-case-guides/ticket-routing
description: Este guia explica como aproveitar as capacidades avançadas de compreensão de linguagem natural do Claude para classificar tickets de suporte ao cliente em escala com base na intenção do cliente, urgência, priorização, perfil do cliente e muito mais.
---

## Pré-requisitos

* Uma chave de API do Claude e o Claude SDK instalado
* Acesso e familiaridade com seu sistema de tickets de suporte existente
* Um conjunto de amostra de tickets de suporte históricos para testes

## Defina se deve usar o Claude para roteamento de tickets

Aqui estão alguns indicadores-chave de que você deve usar um "large language model" (modelo de linguagem grande), ou LLM, como o Claude em vez de abordagens tradicionais de ML para sua tarefa de classificação:

<AccordionGroup>
  <Accordion title="Você tem dados de treinamento rotulados limitados disponíveis">
    Processos tradicionais de ML exigem conjuntos de dados rotulados massivos. O modelo pré-treinado do Claude pode classificar tickets de forma eficaz com apenas algumas dezenas de exemplos rotulados, reduzindo significativamente o tempo e os custos de preparação de dados.
  </Accordion>

  <Accordion title="Suas categorias de classificação provavelmente mudarão ou evoluirão ao longo do tempo">
    Uma vez que uma abordagem tradicional de ML foi estabelecida, alterá-la é uma tarefa trabalhosa e intensiva em dados. Por outro lado, à medida que seu produto ou as necessidades dos clientes evoluem, o Claude pode se adaptar facilmente a mudanças nas definições de classes ou a novas classes sem uma extensa rerrotulagem dos dados de treinamento.
  </Accordion>

  <Accordion title="Você precisa lidar com entradas de texto complexas e não estruturadas">
    Modelos tradicionais de ML frequentemente têm dificuldade com dados não estruturados e exigem extensa engenharia de features. A compreensão avançada de linguagem do Claude permite uma classificação precisa com base no conteúdo e no contexto, em vez de depender de estruturas ontológicas rígidas.
  </Accordion>

  <Accordion title="Suas regras de classificação são baseadas em compreensão semântica">
    Abordagens tradicionais de ML frequentemente dependem de modelos bag-of-words ou de correspondência simples de padrões. O Claude se destaca em compreender e aplicar regras subjacentes quando as classes são definidas por condições em vez de exemplos.
  </Accordion>

  <Accordion title="Você precisa de raciocínio interpretável para decisões de classificação">
    Muitos modelos tradicionais de ML fornecem pouca visibilidade sobre seu processo de tomada de decisão. O Claude pode fornecer explicações legíveis por humanos para suas decisões de classificação, construindo confiança no sistema de automação e facilitando a adaptação quando necessário.
  </Accordion>

  <Accordion title="Você quer lidar com casos extremos e tickets ambíguos de forma mais eficaz">
    Sistemas tradicionais de ML frequentemente têm dificuldade com outliers e entradas ambíguas, muitas vezes classificando-os incorretamente ou recorrendo a uma categoria genérica. As capacidades de processamento de linguagem natural do Claude permitem que ele interprete melhor o contexto e as nuances nos tickets de suporte, potencialmente reduzindo o número de tickets mal roteados ou não classificados que exigem intervenção manual.
  </Accordion>

  <Accordion title="Você precisa de suporte multilíngue sem manter modelos separados">
    Abordagens tradicionais de ML normalmente exigem modelos separados ou extensos processos de tradução para cada idioma suportado. As capacidades multilíngues do Claude permitem que ele classifique tickets em vários idiomas sem a necessidade de modelos separados ou extensos processos de tradução, simplificando o suporte para bases de clientes globais.
  </Accordion>
</AccordionGroup>

***

## Construa e implante seu fluxo de trabalho de suporte com LLM

### Entenda sua abordagem de suporte atual

Antes de automatizar, é crucial entender seu sistema de tickets existente. Comece investigando como sua equipe de suporte atualmente lida com o roteamento de tickets.

Considere perguntas como:

* Quais critérios são usados para determinar qual SLA/oferta de serviço é aplicada?
* O roteamento de tickets é usado para determinar para qual nível de suporte ou especialista de produto um ticket vai?
* Já existem regras ou fluxos de trabalho automatizados em vigor? Em quais casos eles falham?
* Como são tratados os casos extremos ou tickets ambíguos?
* Como a equipe prioriza os tickets?

Quanto mais você souber sobre como os humanos lidam com determinados casos, melhor você poderá trabalhar com o Claude para realizar a tarefa.

### Defina categorias de intenção do usuário

Uma lista bem definida de categorias de intenção do usuário é crucial para uma classificação precisa de tickets de suporte com o Claude. A capacidade do Claude de rotear tickets de forma eficaz dentro do seu sistema é diretamente proporcional a quão bem definidas são as categorias do seu sistema.

Aqui estão alguns exemplos de categorias e subcategorias de intenção do usuário.

<AccordionGroup>
  <Accordion title="Problema técnico">
    * Problema de hardware
    * Bug de software
    * Problema de compatibilidade
    * Problema de desempenho
  </Accordion>

  <Accordion title="Gerenciamento de conta">
    * Redefinição de senha
    * Problemas de acesso à conta
    * Consultas sobre cobrança
    * Alterações de assinatura
  </Accordion>

  <Accordion title="Informações sobre o produto">
    * Consultas sobre funcionalidades
    * Perguntas sobre compatibilidade do produto
    * Informações de preços
    * Consultas sobre disponibilidade
  </Accordion>

  <Accordion title="Orientação ao usuário">
    * Perguntas de como fazer
    * Assistência no uso de funcionalidades
    * Conselhos sobre melhores práticas
    * Orientação para solução de problemas
  </Accordion>

  <Accordion title="Feedback">
    * Relatos de bugs
    * Solicitações de funcionalidades
    * Feedback geral ou sugestões
    * Reclamações
  </Accordion>

  <Accordion title="Relacionado a pedidos">
    * Consultas sobre status do pedido
    * Informações de envio
    * Devoluções e trocas
    * Modificações de pedidos
  </Accordion>

  <Accordion title="Solicitação de serviço">
    * Assistência na instalação
    * Solicitações de upgrade
    * Agendamento de manutenção
    * Cancelamento de serviço
  </Accordion>

  <Accordion title="Preocupações de segurança">
    * Consultas sobre privacidade de dados
    * Relatos de atividade suspeita
    * Assistência com funcionalidades de segurança
  </Accordion>

  <Accordion title="Conformidade e jurídico">
    * Perguntas sobre conformidade regulatória
    * Consultas sobre termos de serviço
    * Solicitações de documentação jurídica
  </Accordion>

  <Accordion title="Suporte de emergência">
    * Falhas críticas de sistema
    * Problemas urgentes de segurança
    * Problemas sensíveis ao tempo
  </Accordion>

  <Accordion title="Treinamento e educação">
    * Solicitações de treinamento sobre o produto
    * Consultas sobre documentação
    * Informações sobre webinars ou workshops
  </Accordion>

  <Accordion title="Integração e API">
    * Assistência com integração
    * Perguntas sobre uso da API
    * Consultas sobre compatibilidade com terceiros
  </Accordion>
</AccordionGroup>

Além da intenção, o roteamento e a priorização de tickets também podem ser influenciados por outros fatores, como urgência, tipo de cliente, SLAs ou idioma. Certifique-se de considerar outros critérios de roteamento ao construir seu sistema de roteamento automatizado.

### Estabeleça critérios de sucesso

Trabalhe com sua equipe de suporte para [definir critérios de sucesso claros](https://platform.claude.com/docs/pt-BR/test-and-evaluate/develop-tests) com benchmarks, limites e metas mensuráveis.

Aqui estão alguns critérios e benchmarks padrão ao usar LLMs para roteamento de tickets de suporte:

<AccordionGroup>
  <Accordion title="Consistência de classificação">
    Esta métrica avalia quão consistentemente o Claude classifica tickets semelhantes ao longo do tempo. É crucial para manter a confiabilidade do roteamento. Meça isso testando periodicamente o modelo com um conjunto de entradas padronizadas e buscando uma taxa de consistência de 95% ou superior.
  </Accordion>

  <Accordion title="Velocidade de adaptação">
    Isso mede quão rapidamente o Claude pode se adaptar a novas categorias ou a padrões de tickets em mudança. Teste isso introduzindo novos tipos de tickets e medindo o tempo que o modelo leva para atingir uma precisão satisfatória (por exemplo, >90%) nessas novas categorias. Busque uma adaptação dentro de 50–100 tickets de amostra.
  </Accordion>

  <Accordion title="Tratamento multilíngue">
    Isso avalia a capacidade do Claude de rotear com precisão tickets em vários idiomas. Meça a precisão do roteamento em diferentes idiomas, buscando uma queda de no máximo 5–10% na precisão para idiomas não primários.
  </Accordion>

  <Accordion title="Tratamento de casos extremos">
    Isso avalia o desempenho do Claude em tickets incomuns ou complexos. Crie um conjunto de testes de casos extremos e meça a precisão do roteamento, buscando pelo menos 80% de precisão nessas entradas desafiadoras.
  </Accordion>

  <Accordion title="Mitigação de viés">
    Isso mede a imparcialidade do Claude no roteamento entre diferentes perfis demográficos de clientes. Audite regularmente as decisões de roteamento em busca de possíveis vieses, buscando uma precisão de roteamento consistente (dentro de 2–3%) em todos os grupos de clientes.
  </Accordion>

  <Accordion title="Eficiência do prompt">
    Em situações em que minimizar a contagem de tokens é crucial, este critério avalia quão bem o Claude se sai com contexto mínimo. Meça a precisão do roteamento com quantidades variadas de contexto fornecido, buscando 90%+ de precisão com apenas o título do ticket e uma breve descrição.
  </Accordion>

  <Accordion title="Pontuação de explicabilidade">
    Isso avalia a qualidade e a relevância das explicações do Claude para suas decisões de roteamento. Avaliadores humanos podem pontuar as explicações em uma escala (por exemplo, 1–5), com o objetivo de atingir uma pontuação média de 4 ou superior.
  </Accordion>
</AccordionGroup>

Aqui estão alguns critérios de sucesso comuns que podem ser úteis independentemente de um LLM ser usado ou não:

<AccordionGroup>
  <Accordion title="Precisão do roteamento">
    A precisão do roteamento mede com que frequência os tickets são atribuídos corretamente à equipe ou pessoa apropriada na primeira tentativa. Isso normalmente é medido como uma porcentagem de tickets roteados corretamente em relação ao total de tickets. Os benchmarks do setor frequentemente buscam 90–95% de precisão, embora isso possa variar com base na complexidade da estrutura de suporte.
  </Accordion>

  <Accordion title="Tempo até a atribuição">
    Esta métrica acompanha quão rapidamente os tickets são atribuídos após serem enviados. Tempos de atribuição mais rápidos geralmente levam a resoluções mais rápidas e maior satisfação do cliente. Os melhores sistemas frequentemente alcançam tempos médios de atribuição inferiores a 5 minutos, com muitos buscando um roteamento quase instantâneo (o que é possível com implementações de LLM).
  </Accordion>

  <Accordion title="Taxa de rerroteamento">
    A taxa de rerroteamento indica com que frequência os tickets precisam ser reatribuídos após o roteamento inicial. Uma taxa mais baixa sugere um roteamento inicial mais preciso. Busque uma taxa de rerroteamento abaixo de 10%, com os sistemas de melhor desempenho alcançando taxas tão baixas quanto 5% ou menos.
  </Accordion>

  <Accordion title="Taxa de resolução no primeiro contato">
    Isso mede a porcentagem de tickets resolvidos durante a primeira interação com o cliente. Taxas mais altas indicam roteamento eficiente e equipes de suporte bem preparadas. Os benchmarks do setor normalmente variam de 70–75%, com os melhores desempenhos alcançando taxas de 80% ou superiores.
  </Accordion>

  <Accordion title="Tempo médio de atendimento">
    O tempo médio de atendimento mede quanto tempo leva para resolver um ticket do início ao fim. Um roteamento eficiente pode reduzir significativamente esse tempo. Os benchmarks variam amplamente por setor e complexidade, mas muitas organizações buscam manter o tempo médio de atendimento abaixo de 24 horas para problemas não críticos.
  </Accordion>

  <Accordion title="Pontuações de satisfação do cliente">
    Frequentemente medidas por meio de pesquisas pós-interação, essas pontuações refletem a satisfação geral do cliente com o processo de suporte. Um roteamento eficaz contribui para uma maior satisfação. Busque pontuações de CSAT de 90% ou superiores, com os melhores desempenhos frequentemente alcançando taxas de satisfação de 95%+.
  </Accordion>

  <Accordion title="Taxa de escalonamento">
    Isso mede com que frequência os tickets precisam ser escalonados para níveis superiores de suporte. Taxas de escalonamento mais baixas frequentemente indicam um roteamento inicial mais preciso. Busque uma taxa de escalonamento abaixo de 20%, com os melhores sistemas alcançando taxas de 10% ou menos.
  </Accordion>

  <Accordion title="Produtividade dos agentes">
    Esta métrica analisa quantos tickets os agentes conseguem atender de forma eficaz após a implementação da solução de roteamento. Um roteamento aprimorado deve aumentar a produtividade. Meça isso acompanhando os tickets resolvidos por agente por dia ou hora, buscando uma melhoria de 10–20% após a implementação de um novo sistema de roteamento.
  </Accordion>

  <Accordion title="Taxa de deflexão por autoatendimento">
    Isso mede a porcentagem de tickets potenciais resolvidos por meio de opções de autoatendimento antes de entrar no sistema de roteamento. Taxas mais altas indicam uma triagem pré-roteamento eficaz. Busque uma taxa de deflexão de 20–30%, com os melhores desempenhos alcançando taxas de 40% ou superiores.
  </Accordion>

  <Accordion title="Custo por ticket">
    Esta métrica calcula o custo médio para resolver cada ticket de suporte. Um roteamento eficiente deve ajudar a reduzir esse custo ao longo do tempo. Embora os benchmarks variem amplamente, muitas organizações buscam reduzir o custo por ticket em 10–15% após a implementação de um sistema de roteamento aprimorado.
  </Accordion>
</AccordionGroup>

### Escolha o modelo Claude certo

A escolha do modelo depende dos trade-offs entre custo, precisão e tempo de resposta.

O Claude Haiku 5.5 (`claude-haiku-5-5`) é adequado para roteamento de tickets: é o modelo atual mais rápido e com melhor custo-benefício e, com esforço `low`, lida com solicitações simples e de alto volume, como classificação. Se o seu problema de classificação exigir profundo conhecimento especializado no assunto, um grande volume de categorias de intenção ou raciocínio complexo, você pode optar pelo [modelo Sonnet maior](https://platform.claude.com/docs/pt-BR/models/overview).

### Construa um prompt forte

O roteamento de tickets é um tipo de tarefa de classificação. O Claude analisa o conteúdo de um ticket de suporte e o classifica em categorias predefinidas com base no tipo de problema, urgência, especialização necessária ou outros fatores relevantes.

Escreva um prompt de classificação de tickets. O prompt inicial deve conter o conteúdo da solicitação do usuário e retornar tanto o raciocínio quanto a intenção.

<Tip>
  Experimente a [receita de metaprompt do Claude Cookbook](https://colab.research.google.com/github/anthropics/claude-cookbooks/blob/main/misc/metaprompt.ipynb) para que o Claude escreva um primeiro rascunho para você.
</Tip>

Aqui está um exemplo de prompt de classificação para roteamento de tickets:

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Construa o prompt no código.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Construa o prompt no código.
  </CodeGroupItem>

  ```python Python
  def classify_support_request(ticket_contents):
      # Define o prompt para a tarefa de classificação
      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) {
    // Define o prompt para a tarefa de classificação
    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)
  {
      // Define o prompt para a tarefa de classificação
      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) {
  	// Define o prompt para a tarefa de classificação
  	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) {
      // Define o prompt para a tarefa de classificação
      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
  {
      // Define o prompt para a tarefa de classificação
      $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)
    # Define o prompt para a tarefa de classificação
    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>
  Este prompt foi escrito para o Claude Haiku 5.5, que é executado aqui com esforço `low`. No Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5 e Claude Sonnet 5.5, peça, em vez disso, a intenção e um resumo de uma frase da solicitação. Consulte [Mantenha o raciocínio nos blocos de pensamento](https://platform.claude.com/docs/pt-BR/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks).
</Note>

Aqui estão os principais componentes deste prompt:

* O template do prompt insere `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`) nas tags `<request>`.
* O prompt dá ao Claude um papel claramente definido como um sistema de classificação que analisa cuidadosamente o conteúdo do ticket para determinar a intenção e as necessidades principais do cliente.
* O prompt instrui o Claude sobre a formatação adequada da saída, neste caso para fornecer seu raciocínio e análise dentro de tags `<reasoning>`, seguidos do rótulo de classificação apropriado dentro de tags `<intent>`.
* O prompt especifica as categorias de intenção válidas: "Support, Feedback, Complaint", "Order Tracking" e "Refund/Exchange".
* O prompt inclui alguns exemplos (também conhecido como "few-shot prompting", ou prompting com poucos exemplos) para ilustrar como a saída deve ser formatada, o que melhora a precisão e a consistência.

Fazer com que o Claude divida sua resposta em seções separadas de tags XML permite que você use expressões regulares para extrair o raciocínio e a intenção da saída de forma independente. Isso permite criar próximos passos direcionados no fluxo de trabalho de roteamento de tickets, como usar apenas a intenção para decidir para qual pessoa rotear o ticket.

### Implante seu prompt

É difícil saber o quão bem seu prompt funciona sem implantá-lo em um ambiente de produção de teste e [executar avaliações](https://platform.claude.com/docs/pt-BR/test-and-evaluate/develop-tests).

Construa a estrutura de implantação. Comece definindo a assinatura do método que encapsula a chamada ao Claude. Estenda o método que você começou a escrever anteriormente, que recebe `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`) como entrada, para que agora ele retorne o raciocínio e a intenção como saída. Se você tiver uma automação existente usando ML tradicional, siga a assinatura desse método.

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Este fluxo de trabalho precisa de mais lógica do que um único comando de shell. Use o Claude SDK para executá-lo.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Este fluxo de trabalho precisa de mais lógica do que um único comando de shell. Use o Claude SDK para executá-lo.
  </CodeGroupItem>

  ```python Python
  import re

  # Crie uma instância do cliente da API do Claude
  client = anthropic.Anthropic()

  # Defina o modelo padrão
  DEFAULT_MODEL = "claude-haiku-5-5"


  def classify_support_request(ticket_contents):
      # Defina o prompt para a tarefa de classificação
      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.
          """
      # Envie o prompt para a API para classificar a solicitação de suporte.
      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"), ""
      )

      # Use a biblioteca de expressões regulares do Python para extrair `reasoning`.
      reasoning_match = re.search(
          r"<reasoning>(.*?)</reasoning>", reasoning_and_intent, re.DOTALL
      )
      reasoning = reasoning_match.group(1).strip() if reasoning_match else ""

      # Da mesma forma, extraia também o `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
  // Crie uma instância do cliente da API do Claude
  const client = new Anthropic();

  // Defina o modelo padrão
  const DEFAULT_MODEL = "claude-haiku-5-5";

  async function classifySupportRequest(
    ticketContents: string
  ): Promise<{ reasoning: string; intent: string }> {
    // Defina o prompt para a tarefa de classificação
    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.
      `;
    // Envie o prompt para a API para classificar a solicitação de suporte.
    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 ?? "";

    // Use uma expressão regular para extrair `reasoning`.
    const reasoningMatch = /<reasoning>(.*?)<\/reasoning>/s.exec(reasoningAndIntent);
    const reasoning = reasoningMatch?.[1].trim() ?? "";

    // Da mesma forma, extraia também o `intent`.
    const intentMatch = /<intent>(.*?)<\/intent>/s.exec(reasoningAndIntent);
    const intent = intentMatch?.[1].trim() ?? "";

    return { reasoning, intent };
  }
  ```

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

  // Crie uma instância do cliente da API do Claude
  AnthropicClient client = new();

  // Defina o modelo padrão
  const Model DefaultModel = Model.ClaudeHaiku5_5;

  async Task<(string Reasoning, string Intent)> ClassifySupportRequest(string ticketContents)
  {
      // Defina o prompt para a tarefa de classificação
      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.
          """;
      // Envie o prompt para a API para classificar a solicitação de suporte.
      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;
          }
      }

      // Use uma expressão regular para extrair `reasoning`.
      var reasoningMatch = Regex.Match(reasoningAndIntent, "<reasoning>(.*?)</reasoning>", RegexOptions.Singleline);
      var reasoning = reasoningMatch.Success ? reasoningMatch.Groups[1].Value.Trim() : "";

      // Da mesma forma, extraia também o `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"
  // ...
  )

  // Crie uma instância do cliente da API do Claude
  var client = anthropic.NewClient()

  // Defina o modelo padrão
  const defaultModel = anthropic.ModelClaudeHaiku5_5

  func classifySupportRequest(ctx context.Context, ticketContents string) (reasoning, intent string, err error) {
  	// Defina o prompt para a tarefa de classificação
  	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.
  		`
  	// Envie o prompt para a API para classificar a solicitação de suporte.
  	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
  		}
  	}

  	// Use uma expressão regular para extrair `reasoning`.
  	reasoningMatch := regexp.MustCompile(`(?s)<reasoning>(.*?)</reasoning>`).FindStringSubmatch(reasoningAndIntent)
  	if reasoningMatch != nil {
  		reasoning = strings.TrimSpace(reasoningMatch[1])
  	}

  	// Da mesma forma, extraia também o `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;

  // Crie uma instância do cliente da API do Claude
  final AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Defina o modelo padrão
  static final Model DEFAULT_MODEL = Model.CLAUDE_HAIKU_5_5;

  record Classification(String reasoning, String intent) {}

  Classification classifySupportRequest(String ticketContents) {
      // Defina o prompt para a tarefa de classificação
      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.
          """;
      // Envie o prompt para a API para classificar a solicitação de suporte.
      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("");

      // Use uma expressão regular para extrair `reasoning`.
      Matcher reasoningMatch = Pattern.compile("<reasoning>(.*?)</reasoning>", Pattern.DOTALL)
          .matcher(reasoningAndIntent);
      String reasoning = reasoningMatch.find() ? reasoningMatch.group(1).strip() : "";

      // Da mesma forma, extraia também o `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
  // Cria uma instância do cliente da API do Claude
  $client = new Client();

  // Define o modelo padrão
  const DEFAULT_MODEL = Model::CLAUDE_HAIKU_5_5;

  /**
   * @return array{string, string} the reasoning and the intent
   */
  function classifySupportRequest(Client $client, string $ticketContents): array
  {
      // Define o prompt para a tarefa de classificação
      $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;
      // Envia o prompt para a API para classificar a solicitação de suporte.
      $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;
          }
      }

      // Usa uma expressão regular para extrair `reasoning`.
      $reasoning = preg_match('/<reasoning>(.*?)<\/reasoning>/s', $reasoningAndIntent, $reasoningMatch)
          ? trim($reasoningMatch[1])
          : '';

      // Da mesma forma, extrai também o `intent`.
      $intent = preg_match('/<intent>(.*?)<\/intent>/s', $reasoningAndIntent, $intentMatch)
          ? trim($intentMatch[1])
          : '';

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

  ```ruby Ruby
  # Crie uma instância do cliente da API do Claude
  client = Anthropic::Client.new

  # Defina o modelo padrão
  DEFAULT_MODEL = Anthropic::Model::CLAUDE_HAIKU_5_5

  def classify_support_request(client, ticket_contents)
    # Defina o prompt para a tarefa de classificação
    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
    # Envie o prompt para a API para classificar a solicitação de suporte.
    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 || ""

    # Use uma expressão regular para extrair `reasoning`.
    reasoning = reasoning_and_intent[%r{<reasoning>(.*?)</reasoning>}m, 1]&.strip || ""

    # Da mesma forma, extraia também o `intent`.
    intent = reasoning_and_intent[%r{<intent>(.*?)</intent>}m, 1]&.strip || ""

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

Este código:

* Cria uma instância de cliente usando sua chave de API.
* Define uma função `classify_support_request` (typescript, go, java, php: `classifySupportRequest`; csharp: `ClassifySupportRequest`) que recebe uma string `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`).
* Envia `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`) ao Claude para classificação usando `classification_prompt` (typescript, csharp, go, java: `classificationPrompt`; php: `$classificationPrompt`).
* Retorna o raciocínio e a intenção do modelo extraídos da resposta.

Como todo o texto de raciocínio e intenção precisa ser gerado antes da análise, o exemplo não faz streaming da resposta.

***

## Avalie seu prompt

O prompting frequentemente requer testes e otimização para estar pronto para produção. Para determinar a prontidão da sua solução, avalie o desempenho com base nos critérios de sucesso e limites que você estabeleceu anteriormente.

Para executar sua avaliação, você precisa de casos de teste nos quais executá-la. O restante deste guia pressupõe que você já [desenvolveu seus casos de teste](https://platform.claude.com/docs/pt-BR/test-and-evaluate/develop-tests).

### Construa uma função de avaliação

A avaliação de exemplo deste guia mede o desempenho do Claude em três métricas principais:

* Precisão
* Custo por classificação

Talvez você precise avaliar o Claude em outros eixos, dependendo de quais fatores são importantes para você.

Para avaliar isso, primeiro modifique o script para adicionar uma função que compara a intenção prevista com a intenção real e calcula a porcentagem de previsões corretas. Em seguida, adicione a funcionalidade de cálculo de custo e medição de tempo.

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Este fluxo de trabalho precisa de mais lógica do que um único comando de shell. Use o Claude SDK para executá-lo.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Este fluxo de trabalho precisa de mais lógica do que um único comando de shell. Use o Claude SDK para executá-lo.
  </CodeGroupItem>

  ```python Python
  import re

  # Crie uma instância do cliente da API do Claude
  client = anthropic.Anthropic()

  # Defina o modelo padrão
  DEFAULT_MODEL = "claude-haiku-5-5"


  def classify_support_request(request, actual_intent):
      # Defina o prompt para a tarefa de classificação
      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"), ""
      )

      # Use a biblioteca de expressões regulares do Python para extrair `reasoning`.
      reasoning_match = re.search(
          r"<reasoning>(.*?)</reasoning>", reasoning_and_intent, re.DOTALL
      )
      reasoning = reasoning_match.group(1).strip() if reasoning_match else ""

      # Da mesma forma, extraia também o `intent`.
      intent_match = re.search(r"<intent>(.*?)</intent>", reasoning_and_intent, re.DOTALL)
      intent = intent_match.group(1).strip() if intent_match else ""

      # Verifique se a previsão do modelo está correta.
      correct = actual_intent.strip() == intent.strip()

      # Retorne o raciocínio, a intenção, se está correto e o uso.
      return reasoning, intent, correct, usage
  ```

  ```typescript TypeScript
  // Cria uma instância do cliente da API do Claude
  const client = new Anthropic();

  // Define o modelo padrão
  const DEFAULT_MODEL = "claude-haiku-5-5";

  async function classifySupportRequest(
    request: string,
    actualIntent: string
  ): Promise<{ reasoning: string; intent: string; correct: boolean; usage: Anthropic.Usage }> {
    // Define o prompt para a tarefa de classificação
    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 }]
    });
    // Obtém as estatísticas de uso da chamada à API: quantos tokens de entrada e saída foram usados.
    const usage = message.usage;
    const textBlock = message.content.find(
      (block): block is Anthropic.TextBlock => block.type === "text"
    );
    const reasoningAndIntent = textBlock?.text ?? "";

    // Usa uma expressão regular para extrair `reasoning`.
    const reasoningMatch = /<reasoning>(.*?)<\/reasoning>/s.exec(reasoningAndIntent);
    const reasoning = reasoningMatch?.[1].trim() ?? "";

    // Da mesma forma, extrai também o `intent`.
    const intentMatch = /<intent>(.*?)<\/intent>/s.exec(reasoningAndIntent);
    const intent = intentMatch?.[1].trim() ?? "";

    // Verifica se a previsão do modelo está correta.
    const correct = actualIntent.trim() === intent.trim();

    // Retorna o raciocínio, a intenção, se está correto e o uso.
    return { reasoning, intent, correct, usage };
  }
  ```

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

  // Cria uma instância do cliente da API do Claude
  AnthropicClient client = new();

  // Define o modelo padrão
  const Model DefaultModel = Model.ClaudeHaiku5_5;

  async Task<(string Reasoning, string Intent, bool Correct, Usage Usage)> ClassifySupportRequest(string request, string actualIntent)
  {
      // Define o prompt para a tarefa de classificação
      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 }],
      });
      // Obtém as estatísticas de uso da chamada à API: quantos tokens de entrada e de saída foram usados.
      var usage = message.Usage;
      var reasoningAndIntent = "";
      foreach (var block in message.Content)
      {
          if (block.TryPickText(out var textBlock))
          {
              reasoningAndIntent = textBlock.Text;
              break;
          }
      }

      // Usa uma expressão regular para extrair `reasoning`.
      var reasoningMatch = Regex.Match(reasoningAndIntent, "<reasoning>(.*?)</reasoning>", RegexOptions.Singleline);
      var reasoning = reasoningMatch.Success ? reasoningMatch.Groups[1].Value.Trim() : "";

      // Da mesma forma, extrai também o `intent`.
      var intentMatch = Regex.Match(reasoningAndIntent, "<intent>(.*?)</intent>", RegexOptions.Singleline);
      var intent = intentMatch.Success ? intentMatch.Groups[1].Value.Trim() : "";

      // Verifica se a previsão do modelo está correta.
      var correct = actualIntent.Trim() == intent.Trim();

      // Retorna o raciocínio, a intenção, se está correto e o uso.
      return (reasoning, intent, correct, usage);
  }
  ```

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

  // Cria uma instância do cliente da API do Claude
  var client = anthropic.NewClient()

  // Define o modelo padrão
  const defaultModel = anthropic.ModelClaudeHaiku5_5

  func classifySupportRequest(ctx context.Context, request, actualIntent string) (reasoning, intent string, correct bool, usage anthropic.Usage, err error) {
  	// Define o prompt para a tarefa de classificação
  	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
  	}
  	// Obtém as estatísticas de uso da chamada à API: quantos tokens de entrada e saída foram usados.
  	usage = message.Usage
  	var reasoningAndIntent string
  	for _, block := range message.Content {
  		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  			reasoningAndIntent = textBlock.Text
  			break
  		}
  	}

  	// Usa uma expressão regular para extrair `reasoning`.
  	reasoningMatch := regexp.MustCompile(`(?s)<reasoning>(.*?)</reasoning>`).FindStringSubmatch(reasoningAndIntent)
  	if reasoningMatch != nil {
  		reasoning = strings.TrimSpace(reasoningMatch[1])
  	}

  	// Da mesma forma, extrai também o `intent`.
  	intentMatch := regexp.MustCompile(`(?s)<intent>(.*?)</intent>`).FindStringSubmatch(reasoningAndIntent)
  	if intentMatch != nil {
  		intent = strings.TrimSpace(intentMatch[1])
  	}

  	// Verifica se a previsão do modelo está correta.
  	correct = strings.TrimSpace(actualIntent) == strings.TrimSpace(intent)

  	// Retorna o raciocínio, a intenção, se está correto e o uso.
  	return reasoning, intent, correct, usage, nil
  }
  ```

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

  // Cria uma instância do cliente da API do Claude
  final AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Define o modelo padrão
  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) {
      // Define o prompt para a tarefa de classificação
      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());
      // Obtém as estatísticas de uso da chamada à API: quantos tokens de entrada e saída foram usados.
      Usage usage = message.usage();
      String reasoningAndIntent = message.content().stream()
          .flatMap(block -> block.text().stream())
          .map(textBlock -> textBlock.text())
          .findFirst()
          .orElse("");

      // Usa uma expressão regular para extrair `reasoning`.
      Matcher reasoningMatch = Pattern.compile("<reasoning>(.*?)</reasoning>", Pattern.DOTALL)
          .matcher(reasoningAndIntent);
      String reasoning = reasoningMatch.find() ? reasoningMatch.group(1).strip() : "";

      // Da mesma forma, extrai também o `intent`.
      Matcher intentMatch = Pattern.compile("<intent>(.*?)</intent>", Pattern.DOTALL)
          .matcher(reasoningAndIntent);
      String intent = intentMatch.find() ? intentMatch.group(1).strip() : "";

      // Verifica se a previsão do modelo está correta.
      boolean correct = actualIntent.strip().equals(intent.strip());

      // Retorna o raciocínio, a intenção, se está correto e o uso.
      return new Classification(reasoning, intent, correct, usage);
  }
  ```

  ```php PHP
  // Cria uma instância do cliente da API do Claude
  $client = new Client();

  // Define o modelo padrão
  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
  {
      // Define o prompt para a tarefa de classificação
      $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]],
      );
      // Obtém as estatísticas de uso da chamada à API: quantos tokens de entrada e saída foram usados.
      $usage = $message->usage;
      $reasoningAndIntent = '';
      foreach ($message->content as $block) {
          if ($block instanceof \Anthropic\Messages\TextBlock) {
              $reasoningAndIntent = $block->text;
              break;
          }
      }

      // Usa uma expressão regular para extrair `reasoning`.
      $reasoning = preg_match('/<reasoning>(.*?)<\/reasoning>/s', $reasoningAndIntent, $reasoningMatch)
          ? trim($reasoningMatch[1])
          : '';

      // Da mesma forma, extrai também o `intent`.
      $intent = preg_match('/<intent>(.*?)<\/intent>/s', $reasoningAndIntent, $intentMatch)
          ? trim($intentMatch[1])
          : '';

      // Verifica se a previsão do modelo está correta.
      $correct = trim($actualIntent) === trim($intent);

      // Retorna o raciocínio, a intenção, se está correto e o uso.
      return [$reasoning, $intent, $correct, $usage];
  }
  ```

  ```ruby Ruby
  # Crie uma instância do cliente da API do Claude
  client = Anthropic::Client.new

  # Defina o modelo padrão
  DEFAULT_MODEL = Anthropic::Model::CLAUDE_HAIKU_5_5

  def classify_support_request(client, request, actual_intent)
    # Define o prompt para a tarefa de classificação
    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 }]
    )
    # Obtém as estatísticas de uso da chamada à API: quantos tokens de entrada e saída foram usados.
    usage = message.usage
    reasoning_and_intent = message.content.grep(Anthropic::Models::TextBlock).first&.text || ""

    # Usa uma expressão regular para extrair `reasoning`.
    reasoning = reasoning_and_intent[%r{<reasoning>(.*?)</reasoning>}m, 1]&.strip || ""

    # Da mesma forma, extrai também o `intent`.
    intent = reasoning_and_intent[%r{<intent>(.*?)</intent>}m, 1]&.strip || ""

    # Verifica se a previsão do modelo está correta.
    correct = actual_intent.strip == intent.strip

    # Retorna o raciocínio, a intenção, se está correto e o uso.
    [reasoning, intent, correct, usage]
  end
  ```
</CodeGroup>

Aqui está um detalhamento das edições:

* O método `classify_support_request` (typescript, go, java, php: `classifySupportRequest`; csharp: `ClassifySupportRequest`) agora recebe `actual_intent` (typescript, csharp, go, java: `actualIntent`; php: `$actualIntent`) dos casos de teste e o compara com a classificação de intenção do Claude para avaliar se correspondem.
* O método extrai estatísticas de uso da chamada de API para calcular o custo com base nos tokens de entrada e saída usados.

### Execute sua avaliação

Uma avaliação adequada requer limites e benchmarks claros para determinar o que é um bom resultado. O script anterior retorna os valores em tempo de execução para precisão, tempo de resposta e custo por classificação, mas você ainda precisa de limites claramente estabelecidos. Por exemplo:

* **Precisão:** 95% (em 100 testes)
* **Custo por classificação:** redução de 50% em média (em 100 testes) em relação ao método de roteamento atual

Ter esses limites permite que você diga de forma rápida e fácil, em escala e com empirismo imparcial, qual método é melhor para você e quais mudanças podem precisar ser feitas para atender melhor aos seus requisitos.

***

## Melhore o desempenho

Em cenários complexos, pode ser útil considerar estratégias adicionais para melhorar o desempenho além das [técnicas de engenharia de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/overview) padrão e das [estratégias de implementação de guardrails](https://platform.claude.com/docs/pt-BR/test-and-evaluate/strengthen-guardrails/reduce-hallucinations). Aqui estão alguns cenários comuns:

### Use uma hierarquia taxonômica para casos com mais de 20 categorias de intenção

À medida que o número de classes cresce, o número de exemplos necessários também aumenta, podendo tornar o prompt difícil de gerenciar. Como alternativa, você pode considerar implementar um sistema de classificação hierárquica usando uma combinação de classificadores.

1. Organize suas intenções em uma estrutura de árvore taxonômica.
2. Crie uma série de classificadores em cada nível da árvore, permitindo uma abordagem de roteamento em cascata.

Por exemplo, você pode ter um classificador de nível superior que categoriza amplamente os tickets em "Technical Issues", "Billing Questions" e "General Inquiries". Cada uma dessas categorias pode então ter seu próprio subclassificador para refinar ainda mais a classificação.

```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[...]
```

* **Prós - maior nuance e precisão:** Você pode criar prompts diferentes para cada caminho pai, permitindo uma classificação mais direcionada e específica ao contexto. Isso pode levar a uma precisão aprimorada e a um tratamento mais refinado das solicitações dos clientes.

* **Contras - maior latência:** Esteja ciente de que múltiplos classificadores podem levar a um aumento da "latency" (latência), e a Anthropic recomenda implementar essa abordagem com o modelo mais rápido, o Haiku.

### Use bancos de dados vetoriais e recuperação por busca de similaridade para lidar com tickets altamente variáveis

Apesar de fornecer exemplos ser a maneira mais eficaz de melhorar o desempenho, se as solicitações de suporte forem altamente variáveis, pode ser difícil incluir exemplos suficientes em um único prompt.

Nesse cenário, você pode empregar um banco de dados vetorial para fazer buscas de similaridade a partir de um conjunto de dados de exemplos e recuperar os exemplos mais relevantes para uma determinada consulta.

Essa abordagem, descrita em detalhes na [receita de classificação](https://platform.claude.com/cookbook/capabilities-classification-guide), demonstrou melhorar o desempenho de 71% de precisão para 93% de precisão.

### Considere especificamente os casos extremos esperados

Aqui estão alguns cenários em que o Claude pode classificar tickets incorretamente (pode haver outros que sejam exclusivos da sua situação). Nesses cenários, considere fornecer instruções explícitas ou exemplos no prompt de como o Claude deve lidar com o caso extremo:

<AccordionGroup>
  <Accordion title="Clientes fazem solicitações implícitas">
    Os clientes frequentemente expressam necessidades de forma indireta. Por exemplo, "Estou esperando meu pacote há mais de duas semanas" pode ser uma solicitação indireta de status do pedido.

    * **Solução:** Forneça ao Claude alguns exemplos reais de clientes desses tipos de solicitações, junto com qual é a intenção subjacente. Você pode obter resultados ainda melhores se incluir uma justificativa de classificação para intenções de tickets particularmente sutis, para que o Claude possa generalizar melhor a lógica para outros tickets.
  </Accordion>

  <Accordion title="O Claude prioriza a emoção em vez da intenção">
    Quando os clientes expressam insatisfação, o Claude pode priorizar lidar com a emoção em vez de resolver o problema subjacente.

    * **Solução:** Forneça ao Claude orientações sobre quando priorizar ou não o sentimento do cliente. Pode ser algo tão simples quanto "Ignore todas as emoções do cliente. Concentre-se apenas em analisar a intenção da solicitação do cliente e quais informações o cliente pode estar pedindo."
  </Accordion>

  <Accordion title="Múltiplos problemas causam confusão na priorização de problemas">
    Quando os clientes apresentam múltiplos problemas em uma única interação, o Claude pode ter dificuldade em identificar a preocupação principal.

    * **Solução:** Esclareça a priorização das intenções para que o Claude possa classificar melhor as intenções extraídas e identificar a preocupação principal.
  </Accordion>
</AccordionGroup>

***

## Integre o Claude ao seu fluxo de trabalho de suporte mais amplo

Uma integração adequada requer que você tome algumas decisões sobre como seu script de roteamento de tickets baseado no Claude se encaixa na arquitetura do seu sistema de roteamento de tickets mais amplo. Há duas maneiras de fazer isso:

* **Baseada em push:** O sistema de tickets de suporte que você está usando (por exemplo, Zendesk) aciona seu código enviando um evento de webhook para seu serviço de roteamento, que então classifica a intenção e faz o roteamento.
  * Essa abordagem é mais escalável na web, mas exige que você exponha um endpoint público.
* **Baseada em pull:** Seu código busca os tickets mais recentes com base em um cronograma determinado e os roteia no momento da busca.
  * Essa abordagem é mais fácil de implementar, mas pode fazer chamadas desnecessárias ao sistema de tickets de suporte quando a frequência de busca é muito alta ou pode ser excessivamente lenta quando a frequência de busca é muito baixa.

Para qualquer uma dessas abordagens, você precisa encapsular seu script em um serviço. A escolha da abordagem depende de quais APIs seu sistema de tickets de suporte fornece.

***

<CardGroup cols={2}>
  <Card title="Cookbook de classificação" icon="link" href="https://platform.claude.com/cookbook/capabilities-classification-guide">
    Visite o cookbook de classificação para mais exemplos de código e orientações detalhadas de avaliação.
  </Card>

  <Card title="Claude Console" icon="link" href="https://platform.claude.com/dashboard">
    Comece a construir e avaliar seu fluxo de trabalho no Claude Console.
  </Card>
</CardGroup>