---
title: Enrutamiento de tickets
url: https://platform.claude.com/docs/es/about-claude/use-case-guides/ticket-routing
description: Esta guía explica cómo usar las capacidades avanzadas de comprensión del lenguaje natural de Claude para clasificar tickets de soporte al cliente a escala según la intención del cliente, la urgencia, la priorización, el perfil del cliente y más.
---

## Requisitos previos

* Una clave de API de Claude y el Anthropic SDK instalado
* Acceso a tu sistema de tickets de soporte existente y familiaridad con él
* Un conjunto de muestra de tickets de soporte históricos para pruebas

## Define si usar Claude para el enrutamiento de tickets

Estos son algunos indicadores clave de que deberías usar un “large language model” (modelo de lenguaje grande), o LLM, como Claude en lugar de enfoques tradicionales de “machine learning” (aprendizaje automático), o ML, para tu tarea de clasificación:

<AccordionGroup>
  <Accordion title="Tienes pocos datos de entrenamiento etiquetados disponibles">
    Los procesos tradicionales de ML requieren conjuntos de datos etiquetados masivos. El modelo preentrenado de Claude puede clasificar tickets de manera efectiva con solo unas pocas docenas de ejemplos etiquetados, lo que reduce significativamente el tiempo y los costos de preparación de datos.
  </Accordion>

  <Accordion title="Es probable que tus categorías de clasificación cambien o evolucionen con el tiempo">
    Una vez que se ha establecido un enfoque tradicional de ML, cambiarlo es una tarea laboriosa que requiere muchos datos. Por otro lado, a medida que tu producto o las necesidades de tus clientes evolucionan, Claude puede adaptarse fácilmente a cambios en las definiciones de clases o a nuevas clases sin un reetiquetado extenso de los datos de entrenamiento.
  </Accordion>

  <Accordion title="Necesitas manejar entradas de texto complejas y no estructuradas">
    Los modelos tradicionales de ML a menudo tienen dificultades con datos no estructurados y requieren una extensa ingeniería de características. La comprensión avanzada del lenguaje de Claude permite una clasificación precisa basada en el contenido y el contexto, en lugar de depender de estructuras ontológicas estrictas.
  </Accordion>

  <Accordion title="Tus reglas de clasificación se basan en la comprensión semántica">
    Los enfoques tradicionales de ML a menudo se basan en modelos de bolsa de palabras o en coincidencias de patrones simples. Claude sobresale en la aplicación de reglas subyacentes cuando las clases se definen mediante condiciones en lugar de ejemplos.
  </Accordion>

  <Accordion title="Necesitas un razonamiento interpretable para las decisiones de clasificación">
    Muchos modelos tradicionales de ML ofrecen poca visibilidad sobre su proceso de toma de decisiones. Claude puede proporcionar explicaciones legibles por humanos para sus decisiones de clasificación, lo que genera confianza en el sistema de automatización y facilita la adaptación si es necesario.
  </Accordion>

  <Accordion title="Quieres manejar casos límite y tickets ambiguos de manera más efectiva">
    Los sistemas tradicionales de ML a menudo tienen dificultades con valores atípicos y entradas ambiguas, clasificándolos incorrectamente con frecuencia o asignándolos por defecto a una categoría general. Las capacidades de procesamiento de lenguaje natural de Claude le permiten interpretar mejor el contexto y los matices en los tickets de soporte, lo que potencialmente reduce la cantidad de tickets mal enrutados o sin clasificar que requieren intervención manual.
  </Accordion>

  <Accordion title="Necesitas soporte multilingüe sin mantener modelos separados">
    Los enfoques tradicionales de ML normalmente requieren modelos separados o procesos de traducción extensos para cada idioma admitido. Las capacidades multilingües de Claude le permiten clasificar tickets en varios idiomas sin necesidad de modelos separados ni procesos de traducción extensos, lo que simplifica el soporte para bases de clientes globales.
  </Accordion>
</AccordionGroup>

***

## Construye y despliega tu flujo de trabajo de soporte con LLM

### Comprende tu enfoque de soporte actual

Antes de automatizar, es crucial comprender tu sistema de tickets existente. Comienza investigando cómo tu equipo de soporte maneja actualmente el enrutamiento de tickets.

Considera preguntas como:

* ¿Qué criterios se utilizan para determinar qué SLA/oferta de servicio se aplica?
* ¿Se utiliza el enrutamiento de tickets para determinar a qué nivel de soporte o especialista de producto va un ticket?
* ¿Existen ya reglas o flujos de trabajo automatizados? ¿En qué casos fallan?
* ¿Cómo se manejan los casos límite o los tickets ambiguos?
* ¿Cómo prioriza el equipo los tickets?

Cuanto más sepas sobre cómo los humanos manejan ciertos casos, mejor podrás trabajar con Claude para realizar la tarea.

### Define las categorías de intención del usuario

Una lista bien definida de categorías de intención del usuario es crucial para una clasificación precisa de tickets de soporte con Claude. La capacidad de Claude para enrutar tickets de manera efectiva dentro de tu sistema es directamente proporcional a lo bien definidas que estén las categorías de tu sistema.

Estos son algunos ejemplos de categorías y subcategorías de intención del usuario.

<AccordionGroup>
  <Accordion title="Problema técnico">
    * Problema de hardware
    * Error de software
    * Problema de compatibilidad
    * Problema de rendimiento
  </Accordion>

  <Accordion title="Gestión de cuenta">
    * Restablecimiento de contraseña
    * Problemas de acceso a la cuenta
    * Consultas de facturación
    * Cambios de suscripción
  </Accordion>

  <Accordion title="Información del producto">
    * Consultas sobre funciones
    * Preguntas sobre compatibilidad del producto
    * Información de precios
    * Consultas de disponibilidad
  </Accordion>

  <Accordion title="Orientación al usuario">
    * Preguntas de tipo “cómo hacer”
    * Asistencia en el uso de funciones
    * Consejos sobre mejores prácticas
    * Orientación para la resolución de problemas
  </Accordion>

  <Accordion title="Retroalimentación">
    * Reportes de errores
    * Solicitudes de funciones
    * Retroalimentación general o sugerencias
    * Quejas
  </Accordion>

  <Accordion title="Relacionado con pedidos">
    * Consultas sobre el estado del pedido
    * Información de envío
    * Devoluciones y cambios
    * Modificaciones de pedidos
  </Accordion>

  <Accordion title="Solicitud de servicio">
    * Asistencia de instalación
    * Solicitudes de actualización
    * Programación de mantenimiento
    * Cancelación de servicio
  </Accordion>

  <Accordion title="Inquietudes de seguridad">
    * Consultas sobre privacidad de datos
    * Reportes de actividad sospechosa
    * Asistencia con funciones de seguridad
  </Accordion>

  <Accordion title="Cumplimiento y asuntos legales">
    * Preguntas sobre cumplimiento normativo
    * Consultas sobre términos de servicio
    * Solicitudes de documentación legal
  </Accordion>

  <Accordion title="Soporte de emergencia">
    * Fallas críticas del sistema
    * Problemas de seguridad urgentes
    * Problemas sensibles al tiempo
  </Accordion>

  <Accordion title="Capacitación y educación">
    * Solicitudes de capacitación sobre el producto
    * Consultas sobre documentación
    * Información sobre webinars o talleres
  </Accordion>

  <Accordion title="Integración y API">
    * Asistencia de integración
    * Preguntas sobre el uso de la API
    * Consultas sobre compatibilidad con terceros
  </Accordion>
</AccordionGroup>

Además de la intención, el enrutamiento y la priorización de tickets también pueden verse influenciados por otros factores como la urgencia, el tipo de cliente, los SLA o el idioma. Asegúrate de considerar otros criterios de enrutamiento al construir tu sistema de enrutamiento automatizado.

### Establece criterios de éxito

Trabaja con tu equipo de soporte para [definir criterios de éxito claros](https://platform.claude.com/docs/es/test-and-evaluate/develop-tests) con puntos de referencia, umbrales y objetivos medibles.

Estos son algunos criterios y puntos de referencia estándar al usar LLMs para el enrutamiento de tickets de soporte:

<AccordionGroup>
  <Accordion title="Consistencia de clasificación">
    Esta métrica evalúa qué tan consistentemente Claude clasifica tickets similares a lo largo del tiempo. Es fundamental para mantener la confiabilidad del enrutamiento. Mídela probando periódicamente el modelo con un conjunto de entradas estandarizadas y apuntando a una tasa de consistencia del 95 por ciento o superior.
  </Accordion>

  <Accordion title="Velocidad de adaptación">
    Esto mide qué tan rápido Claude puede adaptarse a nuevas categorías o a patrones cambiantes de tickets. Pruébalo introduciendo nuevos tipos de tickets y midiendo el tiempo que tarda el modelo en lograr una precisión satisfactoria (por ejemplo, más del 90 por ciento) en estas nuevas categorías. Apunta a una adaptación dentro de 50 a 100 tickets de muestra.
  </Accordion>

  <Accordion title="Manejo multilingüe">
    Esto evalúa la capacidad de Claude para enrutar con precisión tickets en varios idiomas. Mide la precisión del enrutamiento en diferentes idiomas, apuntando a una caída de precisión no mayor al 5 a 10 por ciento para los idiomas no principales.
  </Accordion>

  <Accordion title="Manejo de casos límite">
    Esto evalúa el rendimiento de Claude en tickets inusuales o complejos. Crea un conjunto de prueba de casos extremos y mide la precisión del enrutamiento, apuntando a al menos un 80 por ciento de precisión en estas entradas desafiantes.
  </Accordion>

  <Accordion title="Mitigación de sesgos">
    Esto mide la equidad de Claude en el enrutamiento entre diferentes grupos demográficos de clientes. Audita regularmente las decisiones de enrutamiento en busca de posibles sesgos, apuntando a una precisión de enrutamiento consistente (dentro del 2 a 3 por ciento) en todos los grupos de clientes.
  </Accordion>

  <Accordion title="Eficiencia del prompt">
    En situaciones donde minimizar la cantidad de tokens es fundamental, este criterio evalúa qué tan bien se desempeña Claude con un contexto mínimo. Mide la precisión del enrutamiento con distintas cantidades de contexto proporcionado, apuntando a al menos un 90 por ciento de precisión con solo el título del ticket y una breve descripción.
  </Accordion>

  <Accordion title="Puntuación de explicabilidad">
    Esto evalúa la calidad y relevancia de las explicaciones de Claude para sus decisiones de enrutamiento. Evaluadores humanos pueden puntuar las explicaciones en una escala (por ejemplo, 1–5), con el objetivo de lograr una puntuación promedio de 4 o superior.
  </Accordion>
</AccordionGroup>

Estos son algunos criterios de éxito comunes que pueden ser útiles independientemente de si se usa un LLM:

<AccordionGroup>
  <Accordion title="Precisión del enrutamiento">
    La precisión del enrutamiento mide con qué frecuencia los tickets se asignan correctamente al equipo o a la persona adecuada en el primer intento. Esto normalmente se mide como un porcentaje de tickets enrutados correctamente sobre el total de tickets. Los puntos de referencia de la industria suelen apuntar a una precisión del 90 al 95 por ciento, aunque esto puede variar según la complejidad de la estructura de soporte.
  </Accordion>

  <Accordion title="Tiempo hasta la asignación">
    Esta métrica rastrea qué tan rápido se asignan los tickets después de ser enviados. Tiempos de asignación más rápidos generalmente conducen a resoluciones más rápidas y a una mayor satisfacción del cliente. Los mejores sistemas de su clase suelen lograr tiempos de asignación promedio de menos de 5 minutos, y muchos apuntan a un enrutamiento casi instantáneo (lo cual es posible con implementaciones de LLM).
  </Accordion>

  <Accordion title="Tasa de reenrutamiento">
    La tasa de reenrutamiento indica con qué frecuencia los tickets necesitan ser reasignados después del enrutamiento inicial. Una tasa más baja sugiere un enrutamiento inicial más preciso. Apunta a una tasa de reenrutamiento inferior al 10 por ciento; los sistemas de mejor rendimiento logran tasas tan bajas como el 5 por ciento o menos.
  </Accordion>

  <Accordion title="Tasa de resolución en el primer contacto">
    Esto mide el porcentaje de tickets resueltos durante la primera interacción con el cliente. Las tasas más altas indican un enrutamiento eficiente y equipos de soporte bien preparados. Los puntos de referencia de la industria suelen oscilar entre el 70 y el 75 por ciento, y los mejores logran tasas del 80 por ciento o superiores.
  </Accordion>

  <Accordion title="Tiempo promedio de gestión">
    El tiempo promedio de gestión mide cuánto tiempo se tarda en resolver un ticket de principio a fin. Un enrutamiento eficiente puede reducir significativamente este tiempo. Los puntos de referencia varían ampliamente según la industria y la complejidad, pero muchas organizaciones apuntan a mantener el tiempo promedio de gestión por debajo de 24 horas para problemas no críticos.
  </Accordion>

  <Accordion title="Puntuaciones de satisfacción del cliente">
    A menudo medidas mediante encuestas posteriores a la interacción, estas puntuaciones reflejan la satisfacción general del cliente con el proceso de soporte. Un enrutamiento eficaz contribuye a una mayor satisfacción. Apunta a puntuaciones CSAT del 90 por ciento o superiores; los mejores suelen lograr tasas de satisfacción de al menos el 95 por ciento.
  </Accordion>

  <Accordion title="Tasa de escalamiento">
    Esto mide con qué frecuencia los tickets necesitan escalarse a niveles superiores de soporte. Las tasas de escalamiento más bajas suelen indicar un enrutamiento inicial más preciso. Procura una tasa de escalamiento inferior al 20 por ciento; los mejores sistemas de su clase logran tasas del 10 por ciento o menos.
  </Accordion>

  <Accordion title="Productividad de los agentes">
    Esta métrica analiza cuántos tickets pueden manejar los agentes de manera efectiva después de implementar la solución de enrutamiento. Un mejor enrutamiento debería aumentar la productividad. Mídela registrando los tickets resueltos por agente por día u hora, apuntando a una mejora del 10 al 20 por ciento después de implementar un nuevo sistema de enrutamiento.
  </Accordion>

  <Accordion title="Tasa de desvío por autoservicio">
    Esto mide el porcentaje de tickets potenciales resueltos mediante opciones de autoservicio antes de entrar al sistema de enrutamiento. Las tasas más altas indican un triaje previo al enrutamiento eficaz. Apunta a una tasa de desvío del 20 al 30 por ciento; los mejores logran tasas del 40 por ciento o superiores.
  </Accordion>

  <Accordion title="Costo por ticket">
    Esta métrica calcula el costo promedio para resolver cada ticket de soporte. Un enrutamiento eficiente debería ayudar a reducir este costo con el tiempo. Aunque los puntos de referencia varían ampliamente, muchas organizaciones apuntan a reducir el costo por ticket entre un 10 y un 15 por ciento después de implementar un sistema de enrutamiento mejorado.
  </Accordion>
</AccordionGroup>

### Elige el modelo de Claude adecuado

La elección del modelo depende de los compromisos entre costo, precisión y tiempo de respuesta.

Claude Haiku 5.5 (`claude-haiku-5-5`) es adecuado para el enrutamiento de tickets: es el modelo actual más rápido y rentable, y con esfuerzo `low` maneja solicitudes simples y de alto volumen como la clasificación. Si tu problema de clasificación requiere un profundo conocimiento especializado, un gran volumen de categorías de intención o un razonamiento complejo, puedes optar por el [modelo Sonnet más grande](https://platform.claude.com/docs/es/models/overview).

### Construye un prompt sólido

El enrutamiento de tickets es un tipo de tarea de clasificación. Claude analiza el contenido de un ticket de soporte y lo clasifica en categorías predefinidas según el tipo de problema, la urgencia, la experiencia requerida u otros factores relevantes.

Escribe un prompt de clasificación de tickets. El prompt inicial debe contener el contenido de la solicitud del usuario y devolver tanto el razonamiento como la intención.

<Tip>
  Prueba la [receta de metaprompt del Claude Cookbook](https://colab.research.google.com/github/anthropics/claude-cookbooks/blob/main/misc/metaprompt.ipynb) para que Claude escriba un primer borrador por ti.
</Tip>

Este es un ejemplo de prompt de clasificación para el enrutamiento de tickets:

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Construye el prompt en código.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Construye el prompt en código.
  </CodeGroupItem>

  ```python Python
  def classify_support_request(ticket_contents):
      # Define el prompt para la tarea de clasificación
      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 el prompt para la tarea de clasificación
    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 el prompt para la tarea de clasificación
      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 el prompt para la tarea de clasificación
  	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 el prompt para la tarea de clasificación
      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 el prompt para la tarea de clasificación
      $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 el prompt para la tarea de clasificación
    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 está escrito para Claude Haiku 5.5, que aquí se ejecuta con esfuerzo `low`. En Claude Fable 5.2, Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5 y Claude Sonnet 5.5, pide en su lugar la intención y un resumen de una oración de la solicitud. Consulta [Mantén el razonamiento en bloques de pensamiento](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks).
</Note>

Estos son los componentes clave de este prompt:

* La plantilla del prompt inserta `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`) en las etiquetas `<request>`.
* El prompt le da a Claude un rol claramente definido como sistema de clasificación que analiza cuidadosamente el contenido del ticket para determinar la intención y las necesidades principales del cliente.
* El prompt le indica a Claude el formato de salida adecuado, en este caso proporcionar su razonamiento y análisis dentro de etiquetas `<reasoning>`, seguido de la etiqueta de clasificación apropiada dentro de etiquetas `<intent>`.
* El prompt especifica las categorías de intención válidas: `Support, Feedback, Complaint`, `Order Tracking` y `Refund/Exchange`.
* El prompt incluye algunos ejemplos, una técnica conocida como “few-shot prompting” (prompting con pocos ejemplos), para ilustrar cómo debe formatearse la salida, lo que mejora la precisión y la consistencia.

Hacer que Claude divida su respuesta en secciones separadas con etiquetas XML te permite usar expresiones regulares para extraer el razonamiento y la intención de la salida de forma independiente. Esto te permite crear pasos siguientes específicos en el flujo de trabajo de enrutamiento de tickets, como usar solo la intención para decidir a qué persona enrutar el ticket.

### Despliega tu prompt

Es difícil saber qué tan bien funciona tu prompt sin desplegarlo en un entorno de producción de prueba y [ejecutar evaluaciones](https://platform.claude.com/docs/es/test-and-evaluate/develop-tests).

Construye la estructura de implementación. Comienza definiendo la firma de la función que envuelve la llamada a Claude. Amplía la función que comenzaste a escribir antes, que recibe `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`) como entrada, para que ahora devuelva el razonamiento y la intención como salida. Si tienes una automatización existente que usa ML tradicional, te convendrá seguir esa firma en su lugar.

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el Anthropic SDK para ejecutarlo.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el Anthropic SDK para ejecutarlo.
  </CodeGroupItem>

  ```python Python
  import re

  # Crea una instancia del cliente de la API de Claude
  client = anthropic.Anthropic()

  # Establece el modelo predeterminado
  DEFAULT_MODEL = "claude-haiku-5-5"


  def classify_support_request(ticket_contents):
      # Define el prompt para la tarea de clasificación
      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.
          """
      # Envía el prompt a la API para clasificar la solicitud de soporte.
      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"), ""
      )

      # Usa la biblioteca de expresiones regulares de Python para extraer `reasoning`.
      reasoning_match = re.search(
          r"<reasoning>(.*?)</reasoning>", reasoning_and_intent, re.DOTALL
      )
      reasoning = reasoning_match.group(1).strip() if reasoning_match else ""

      # De forma similar, extrae también el `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
  // Crea una instancia del cliente de la API de Claude
  const client = new Anthropic();

  // Establece el modelo predeterminado
  const DEFAULT_MODEL = "claude-haiku-5-5";

  async function classifySupportRequest(
    ticketContents: string
  ): Promise<{ reasoning: string; intent: string }> {
    // Define el prompt para la tarea de clasificación
    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.
      `;
    // Envía el prompt a la API para clasificar la solicitud de soporte.
    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.type === "text");
    const reasoningAndIntent = textBlock?.text ?? "";

    // Usa una expresión regular para extraer `reasoning`.
    const reasoningMatch = /<reasoning>(.*?)<\/reasoning>/s.exec(reasoningAndIntent);
    const reasoning = reasoningMatch?.[1].trim() ?? "";

    // De manera similar, extrae también el `intent`.
    const intentMatch = /<intent>(.*?)<\/intent>/s.exec(reasoningAndIntent);
    const intent = intentMatch?.[1].trim() ?? "";

    return { reasoning, intent };
  }
  ```

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

  // Crea una instancia del cliente de la API de Claude
  AnthropicClient client = new();

  // Establece el modelo predeterminado
  const Model DefaultModel = Model.ClaudeHaiku5_5;

  async Task<(string Reasoning, string Intent)> ClassifySupportRequest(string ticketContents)
  {
      // Define el prompt para la tarea de clasificación
      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.
          """;
      // Envía el prompt a la API para clasificar la solicitud de soporte.
      var message = await client.Messages.Create(new MessageCreateParams
      {
          Model = DefaultModel,
          MaxTokens = 2048,
          OutputConfig = new OutputConfig { Effort = Effort.Low },
          Messages = [new UserMessageParam { Content = classificationPrompt }],
      });
      var reasoningAndIntent = "";
      foreach (var block in message.Content)
      {
          if (block.TryPickText(out var textBlock))
          {
              reasoningAndIntent = textBlock.Text;
              break;
          }
      }

      // Usa una expresión regular para extraer `reasoning`.
      var reasoningMatch = Regex.Match(reasoningAndIntent, "<reasoning>(.*?)</reasoning>", RegexOptions.Singleline);
      var reasoning = reasoningMatch.Success ? reasoningMatch.Groups[1].Value.Trim() : "";

      // De manera similar, extrae también el `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"
  // ...
  )

  // Crea una instancia del cliente de la API de Claude
  var client = anthropic.NewClient()

  // Establece el modelo predeterminado
  const defaultModel = anthropic.ModelClaudeHaiku5_5

  func classifySupportRequest(ctx context.Context, ticketContents string) (reasoning, intent string, err error) {
  	// Define el prompt para la tarea de clasificación
  	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.
  		`
  	// Envía el prompt a la API para clasificar la solicitud de soporte.
  	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
  		}
  	}

  	// Usa una expresión regular para extraer `reasoning`.
  	reasoningMatch := regexp.MustCompile(`(?s)<reasoning>(.*?)</reasoning>`).FindStringSubmatch(reasoningAndIntent)
  	if reasoningMatch != nil {
  		reasoning = strings.TrimSpace(reasoningMatch[1])
  	}

  	// De manera similar, extrae también el `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;

  // Crea una instancia del cliente de la API de Claude
  final AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Establece el modelo predeterminado
  static final Model DEFAULT_MODEL = Model.CLAUDE_HAIKU_5_5;

  record Classification(String reasoning, String intent) {}

  Classification classifySupportRequest(String ticketContents) {
      // Define el prompt para la tarea de clasificación
      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.
          """;
      // Envía el prompt a la API para clasificar la solicitud de soporte.
      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("");

      // Usa una expresión regular para extraer `reasoning`.
      Matcher reasoningMatch = Pattern.compile("<reasoning>(.*?)</reasoning>", Pattern.DOTALL)
          .matcher(reasoningAndIntent);
      String reasoning = reasoningMatch.find() ? reasoningMatch.group(1).strip() : "";

      // De forma similar, extrae también el `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
  // Crea una instancia del cliente de la API de Claude
  $client = new Client();

  // Establece el modelo predeterminado
  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 el prompt para la tarea de clasificación
      $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;
      // Envía el prompt a la API para clasificar la solicitud de soporte.
      $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 una expresión regular para extraer `reasoning`.
      $reasoning = preg_match('/<reasoning>(.*?)<\/reasoning>/s', $reasoningAndIntent, $reasoningMatch)
          ? trim($reasoningMatch[1])
          : '';

      // De manera similar, extrae también el `intent`.
      $intent = preg_match('/<intent>(.*?)<\/intent>/s', $reasoningAndIntent, $intentMatch)
          ? trim($intentMatch[1])
          : '';

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

  ```ruby Ruby
  # Crea una instancia del cliente de la API de Claude
  client = Anthropic::Client.new

  # Establece el modelo predeterminado
  DEFAULT_MODEL = Anthropic::Model::CLAUDE_HAIKU_5_5

  def classify_support_request(client, ticket_contents)
    # Define el prompt para la tarea de clasificación
    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
    # Envía el prompt a la API para clasificar la solicitud de soporte.
    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 || ""

    # Usa una expresión regular para extraer `reasoning`.
    reasoning = reasoning_and_intent[%r{<reasoning>(.*?)</reasoning>}m, 1]&.strip || ""

    # De forma similar, extrae también el `intent`.
    intent = reasoning_and_intent[%r{<intent>(.*?)</intent>}m, 1]&.strip || ""

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

Este código:

* Crea una instancia de cliente usando tu clave de API.
* Define una función `classify_support_request()` (typescript, go, java, php: `classifySupportRequest()`; csharp: `ClassifySupportRequest()`) que recibe una cadena `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`).
* Envía `ticket_contents` (typescript, csharp, go, java: `ticketContents`; php: `$ticketContents`) a Claude para su clasificación usando `classification_prompt` (typescript, csharp, go, java: `classificationPrompt`; php: `$classificationPrompt`).
* Devuelve el razonamiento y la intención del modelo extraídos de la respuesta.

Como todo el texto del razonamiento y la intención debe generarse antes del análisis, el ejemplo no usa streaming para la respuesta.

***

## Evalúa tu prompt

El prompting a menudo requiere pruebas y optimización para estar listo para producción. Para determinar la preparación de tu solución, evalúa el rendimiento según los criterios de éxito y umbrales que estableciste anteriormente.

Para ejecutar tu evaluación, necesitas casos de prueba sobre los cuales ejecutarla. El resto de esta guía asume que ya has [desarrollado tus casos de prueba](https://platform.claude.com/docs/es/test-and-evaluate/develop-tests).

### Construye una función de evaluación

La evaluación de ejemplo de esta guía mide el rendimiento de Claude según dos métricas clave:

* Precisión
* Costo por clasificación

Es posible que necesites evaluar a Claude en otros ejes según los factores que sean importantes para ti.

Para evaluar esto, primero modifica el script para que compare la intención predicha con la intención real. Luego haz que devuelva el uso de tokens de la llamada a la API, a partir del cual puedes calcular el costo.

<CodeGroup exclude="shell">
  <CodeGroupItem language="cURL">
    Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el Anthropic SDK para ejecutarlo.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el Anthropic SDK para ejecutarlo.
  </CodeGroupItem>

  ```python Python
  import re

  # Crea una instancia del cliente de la API de Claude
  client = anthropic.Anthropic()

  # Establece el modelo predeterminado
  DEFAULT_MODEL = "claude-haiku-5-5"


  def classify_support_request(ticket_contents, actual_intent):
      # Define el prompt para la tarea de clasificación
      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"), ""
      )

      # Usa la biblioteca de expresiones regulares de Python para extraer `reasoning`.
      reasoning_match = re.search(
          r"<reasoning>(.*?)</reasoning>", reasoning_and_intent, re.DOTALL
      )
      reasoning = reasoning_match.group(1).strip() if reasoning_match else ""

      # De forma similar, extrae también el `intent`.
      intent_match = re.search(r"<intent>(.*?)</intent>", reasoning_and_intent, re.DOTALL)
      intent = intent_match.group(1).strip() if intent_match else ""

      # Comprueba si la predicción del modelo es correcta.
      correct = actual_intent.strip() == intent.strip()

      # Devuelve el razonamiento, la intención, si es correcto y el uso.
      return reasoning, intent, correct, usage
  ```

  ```typescript TypeScript
  // Crea una instancia del cliente de la API de Claude
  const client = new Anthropic();

  // Establece el modelo predeterminado
  const DEFAULT_MODEL = "claude-haiku-5-5";

  async function classifySupportRequest(
    ticketContents: string,
    actualIntent: string
  ): Promise<{ reasoning: string; intent: string; correct: boolean; usage: Anthropic.Usage }> {
    // Define el prompt para la tarea de clasificación
    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én las estadísticas de uso de la llamada a la API: cuántos tokens de entrada y salida se usaron.
    const usage = message.usage;
    const textBlock = message.content.find((block) => block.type === "text");
    const reasoningAndIntent = textBlock?.text ?? "";

    // Usa una expresión regular para extraer `reasoning`.
    const reasoningMatch = /<reasoning>(.*?)<\/reasoning>/s.exec(reasoningAndIntent);
    const reasoning = reasoningMatch?.[1].trim() ?? "";

    // De forma similar, extrae también el `intent`.
    const intentMatch = /<intent>(.*?)<\/intent>/s.exec(reasoningAndIntent);
    const intent = intentMatch?.[1].trim() ?? "";

    // Comprueba si la predicción del modelo es correcta.
    const correct = actualIntent.trim() === intent.trim();

    // Devuelve el razonamiento, la intención, si es correcto y el uso.
    return { reasoning, intent, correct, usage };
  }
  ```

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

  // Crea una instancia del cliente de la API de Claude
  AnthropicClient client = new();

  // Establece el modelo predeterminado
  const Model DefaultModel = Model.ClaudeHaiku5_5;

  async Task<(string Reasoning, string Intent, bool Correct, Usage Usage)> ClassifySupportRequest(string ticketContents, string actualIntent)
  {
      // Define el prompt para la tarea de clasificación
      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 UserMessageParam { Content = classificationPrompt }],
      });
      // Obtén las estadísticas de uso de la llamada a la API: cuántos tokens de entrada y de salida se usaron.
      var usage = message.Usage;
      var reasoningAndIntent = "";
      foreach (var block in message.Content)
      {
          if (block.TryPickText(out var textBlock))
          {
              reasoningAndIntent = textBlock.Text;
              break;
          }
      }

      // Usa una expresión regular para extraer `reasoning`.
      var reasoningMatch = Regex.Match(reasoningAndIntent, "<reasoning>(.*?)</reasoning>", RegexOptions.Singleline);
      var reasoning = reasoningMatch.Success ? reasoningMatch.Groups[1].Value.Trim() : "";

      // De forma similar, extrae también el `intent`.
      var intentMatch = Regex.Match(reasoningAndIntent, "<intent>(.*?)</intent>", RegexOptions.Singleline);
      var intent = intentMatch.Success ? intentMatch.Groups[1].Value.Trim() : "";

      // Comprueba si la predicción del modelo es correcta.
      var correct = actualIntent.Trim() == intent.Trim();

      // Devuelve el razonamiento, la intención, si es correcto y el uso.
      return (reasoning, intent, correct, usage);
  }
  ```

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

  // Crea una instancia del cliente de la API de Claude
  var client = anthropic.NewClient()

  // Establece el modelo predeterminado
  const defaultModel = anthropic.ModelClaudeHaiku5_5

  func classifySupportRequest(ctx context.Context, ticketContents, actualIntent string) (reasoning, intent string, correct bool, usage anthropic.Usage, err error) {
  	// Define el prompt para la tarea de clasificación
  	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én las estadísticas de uso de la llamada a la API: cuántos tokens de entrada y salida se usaron.
  	usage = message.Usage
  	var reasoningAndIntent string
  	for _, block := range message.Content {
  		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  			reasoningAndIntent = textBlock.Text
  			break
  		}
  	}

  	// Usa una expresión regular para extraer `reasoning`.
  	reasoningMatch := regexp.MustCompile(`(?s)<reasoning>(.*?)</reasoning>`).FindStringSubmatch(reasoningAndIntent)
  	if reasoningMatch != nil {
  		reasoning = strings.TrimSpace(reasoningMatch[1])
  	}

  	// De forma similar, extrae también el `intent`.
  	intentMatch := regexp.MustCompile(`(?s)<intent>(.*?)</intent>`).FindStringSubmatch(reasoningAndIntent)
  	if intentMatch != nil {
  		intent = strings.TrimSpace(intentMatch[1])
  	}

  	// Comprueba si la predicción del modelo es correcta.
  	correct = strings.TrimSpace(actualIntent) == strings.TrimSpace(intent)

  	// Devuelve el razonamiento, la intención, si es correcto y el uso.
  	return reasoning, intent, correct, usage, nil
  }
  ```

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

  // Crea una instancia del cliente de la API de Claude
  final AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Establece el modelo predeterminado
  static final Model DEFAULT_MODEL = Model.CLAUDE_HAIKU_5_5;

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

  Classification classifySupportRequest(String ticketContents, String actualIntent) {
      // Define el prompt para la tarea de clasificación
      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én las estadísticas de uso de la llamada a la API: cuántos tokens de entrada y salida se usaron.
      Usage usage = message.usage();
      String reasoningAndIntent = message.content().stream()
          .flatMap(block -> block.text().stream())
          .map(textBlock -> textBlock.text())
          .findFirst()
          .orElse("");

      // Usa una expresión regular para extraer `reasoning`.
      Matcher reasoningMatch = Pattern.compile("<reasoning>(.*?)</reasoning>", Pattern.DOTALL)
          .matcher(reasoningAndIntent);
      String reasoning = reasoningMatch.find() ? reasoningMatch.group(1).strip() : "";

      // De forma similar, extrae también el `intent`.
      Matcher intentMatch = Pattern.compile("<intent>(.*?)</intent>", Pattern.DOTALL)
          .matcher(reasoningAndIntent);
      String intent = intentMatch.find() ? intentMatch.group(1).strip() : "";

      // Comprueba si la predicción del modelo es correcta.
      boolean correct = actualIntent.strip().equals(intent.strip());

      // Devuelve el razonamiento, la intención, si es correcto y el uso.
      return new Classification(reasoning, intent, correct, usage);
  }
  ```

  ```php PHP
  // Crea una instancia del cliente de la API de Claude
  $client = new Client();

  // Establece el modelo predeterminado
  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 $ticketContents, string $actualIntent): array
  {
      // Define el prompt para la tarea de clasificación
      $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én las estadísticas de uso de la llamada a la API: cuántos tokens de entrada y salida se usaron.
      $usage = $message->usage;
      $reasoningAndIntent = '';
      foreach ($message->content as $block) {
          if ($block instanceof \Anthropic\Messages\TextBlock) {
              $reasoningAndIntent = $block->text;
              break;
          }
      }

      // Usa una expresión regular para extraer `reasoning`.
      $reasoning = preg_match('/<reasoning>(.*?)<\/reasoning>/s', $reasoningAndIntent, $reasoningMatch)
          ? trim($reasoningMatch[1])
          : '';

      // De forma similar, extrae también el `intent`.
      $intent = preg_match('/<intent>(.*?)<\/intent>/s', $reasoningAndIntent, $intentMatch)
          ? trim($intentMatch[1])
          : '';

      // Comprueba si la predicción del modelo es correcta.
      $correct = trim($actualIntent) === trim($intent);

      // Devuelve el razonamiento, la intención, si es correcto y el uso.
      return [$reasoning, $intent, $correct, $usage];
  }
  ```

  ```ruby Ruby
  # Crea una instancia del cliente de la API de Claude
  client = Anthropic::Client.new

  # Establece el modelo predeterminado
  DEFAULT_MODEL = Anthropic::Model::CLAUDE_HAIKU_5_5

  def classify_support_request(client, ticket_contents, actual_intent)
    # Define el prompt para la tarea de clasificación
    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én las estadísticas de uso de la llamada a la API: cuántos tokens de entrada y salida se usaron.
    usage = message.usage
    reasoning_and_intent = message.content.grep(Anthropic::Models::TextBlock).first&.text || ""

    # Usa una expresión regular para extraer `reasoning`.
    reasoning = reasoning_and_intent[%r{<reasoning>(.*?)</reasoning>}m, 1]&.strip || ""

    # De forma similar, extrae también el `intent`.
    intent = reasoning_and_intent[%r{<intent>(.*?)</intent>}m, 1]&.strip || ""

    # Comprueba si la predicción del modelo es correcta.
    correct = actual_intent.strip == intent.strip

    # Devuelve el razonamiento, la intención, si es correcto y el uso.
    [reasoning, intent, correct, usage]
  end
  ```
</CodeGroup>

Este es un desglose de las modificaciones:

* La función `classify_support_request()` (typescript, go, java, php: `classifySupportRequest()`; csharp: `ClassifySupportRequest()`) ahora recibe `actual_intent` (typescript, csharp, go, java: `actualIntent`; php: `$actualIntent`) de los casos de prueba y lo compara con la clasificación de intención de Claude para evaluar si coinciden.
* La función extrae estadísticas de uso de la llamada a la API para calcular el costo según los tokens de entrada y salida utilizados.

### Ejecuta tu evaluación

Una evaluación adecuada requiere umbrales y puntos de referencia claros para determinar qué es un buen resultado. El script anterior devuelve los valores que necesitas para medir la precisión y el costo por clasificación, pero aún necesitas umbrales claramente establecidos. Por ejemplo:

* **Precisión:** 95% (de 100 pruebas)
* **Costo por clasificación:** reducción del 50% en promedio (en 100 pruebas) respecto al método de enrutamiento actual

Contar con estos umbrales te permite determinar a escala, y con un empirismo imparcial, qué método es el mejor para ti y qué cambios podrías necesitar hacer para adaptarte mejor a tus requisitos.

***

## Mejora el rendimiento

En escenarios complejos, puede ser útil considerar estrategias adicionales para mejorar el rendimiento más allá de las [técnicas de ingeniería de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/overview) estándar y las [estrategias de implementación de barreras de protección](https://platform.claude.com/docs/es/test-and-evaluate/strengthen-guardrails/reduce-hallucinations). Estos son algunos escenarios comunes:

### Usa una jerarquía taxonómica para casos con más de 20 categorías de intención

A medida que crece el número de clases, también aumenta el número de ejemplos requeridos, lo que potencialmente hace que el prompt sea difícil de manejar. Como alternativa, puedes considerar implementar un sistema de clasificación jerárquico usando una combinación de clasificadores.

1. Organiza tus intenciones en una estructura de árbol taxonómico.
2. Crea una serie de clasificadores en cada nivel del árbol para posibilitar un enfoque de enrutamiento en cascada.

Por ejemplo, podrías tener un clasificador de nivel superior que categorice ampliamente los tickets en “Technical Issues” (problemas técnicos), “Billing Questions” (preguntas de facturación) y “General Inquiries” (consultas generales). Cada una de estas categorías puede tener su propio subclasificador para refinar aún más la clasificación.

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

* **Ventajas - mayor matiz y precisión:** Puedes crear diferentes prompts para cada ruta principal, lo que permite una clasificación más específica y adaptada al contexto. Esto puede conducir a una mayor precisión y a un manejo más matizado de las solicitudes de los clientes.

* **Desventajas - mayor latencia:** Varios clasificadores pueden aumentar la “latency” (latencia), y Anthropic recomienda implementar este enfoque con el modelo más rápido, Haiku.

### Usa bases de datos vectoriales y recuperación por búsqueda de similitud para manejar tickets altamente variables

Aunque proporcionar ejemplos es la forma más efectiva de mejorar el rendimiento, si las solicitudes de soporte son altamente variables, puede ser difícil incluir suficientes ejemplos en un solo prompt.

En este escenario, podrías emplear una base de datos vectorial para realizar búsquedas de similitud a partir de un conjunto de datos de ejemplos y recuperar los ejemplos más relevantes para una consulta dada.

Se ha demostrado que este enfoque, descrito en detalle en la [receta de clasificación](https://platform.claude.com/cookbook/capabilities-classification-guide), mejora el rendimiento de un 71 por ciento de precisión a un 93 por ciento de precisión.

### Ten en cuenta específicamente los casos límite esperados

Estos son algunos escenarios en los que Claude podría clasificar incorrectamente los tickets (puede haber otros que sean exclusivos de tu situación). En estos escenarios, considera proporcionar instrucciones explícitas o ejemplos en el prompt sobre cómo Claude debe manejar el caso extremo:

<AccordionGroup>
  <Accordion title="Los clientes hacen solicitudes implícitas">
    Los clientes a menudo expresan sus necesidades de forma indirecta. Por ejemplo, “Llevo más de dos semanas esperando mi paquete” podría ser una solicitud indirecta del estado del pedido.

    * **Solución:** Proporciona a Claude algunos ejemplos reales de clientes con este tipo de solicitudes, junto con cuál es la intención subyacente. Puedes obtener resultados aún mejores si incluyes una justificación de clasificación para intenciones de tickets particularmente matizadas, de modo que Claude pueda generalizar mejor la lógica a otros tickets.
  </Accordion>

  <Accordion title="Claude prioriza la emoción sobre la intención">
    Cuando los clientes expresan insatisfacción, Claude podría priorizar atender la emoción en lugar de resolver el problema subyacente.

    * **Solución:** Proporciona a Claude indicaciones sobre cuándo priorizar o no el sentimiento del cliente. Por ejemplo: “Ignora todas las emociones del cliente. Concéntrate solo en analizar la intención de la solicitud del cliente y qué información podría estar pidiendo el cliente”.
  </Accordion>

  <Accordion title="Múltiples problemas causan confusión en la priorización">
    Cuando los clientes presentan varios problemas en una sola interacción, Claude podría tener dificultades para identificar la preocupación principal.

    * **Solución:** Aclara la priorización de intenciones para que Claude pueda ordenar mejor las intenciones extraídas e identificar la preocupación principal.
  </Accordion>
</AccordionGroup>

***

## Integra Claude en tu flujo de trabajo de soporte general

Una integración adecuada requiere que tomes algunas decisiones sobre cómo tu script de enrutamiento de tickets basado en Claude encaja en la arquitectura de tu sistema de enrutamiento de tickets general. Hay dos formas de hacerlo:

* **Basado en push:** El sistema de tickets de soporte que estás usando (por ejemplo, Zendesk) activa tu código enviando un evento de webhook a tu servicio de enrutamiento, que luego clasifica la intención y lo enruta.
  * Este enfoque es más escalable en la web, pero requiere que expongas un endpoint público.
* **Basado en pull:** Tu código consulta los tickets más recientes según un cronograma determinado y los enruta en el momento de la consulta.
  * Este enfoque es más fácil de implementar, pero podría realizar llamadas innecesarias al sistema de tickets de soporte cuando la frecuencia de consulta es demasiado alta, o podría ser demasiado lento cuando la frecuencia de consulta es demasiado baja.

Para cualquiera de estos enfoques, necesitas envolver tu script en un servicio. La elección del enfoque depende de qué APIs proporcione tu sistema de tickets de soporte.

***

<CardGroup cols={2}>
  <Card title="Receta de clasificación" icon="link" href="https://platform.claude.com/cookbook/capabilities-classification-guide">
    Visita la receta de clasificación para ver más código de ejemplo y orientación detallada sobre evaluaciones.
  </Card>

  <Card title="Claude Console" icon="link" href="https://platform.claude.com/dashboard">
    Comienza a construir y evaluar tu flujo de trabajo en la Claude Console.
  </Card>
</CardGroup>