---
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 aprovechar 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 SDK de Claude 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 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 dependen de modelos de bolsa de palabras o de coincidencia simple de patrones. Claude sobresale en comprender y aplicar reglas subyacentes cuando las clases se definen por condiciones en lugar de ejemplos.
  </Accordion>

  <Accordion title="Requieres 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 influidos 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 crucial 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% 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 de tickets cambiantes. Pruébalo introduciendo nuevos tipos de tickets y midiendo el tiempo que tarda el modelo en alcanzar una precisión satisfactoria (por ejemplo, >90%) en estas nuevas categorías. Apunta a una adaptación dentro de 50–100 tickets de muestra.
  </Accordion>

  <Accordion title="Manejo multilingüe">
    Esto evalúa la capacidad de Claude para enrutar con precisión tickets en múltiples idiomas. Mide la precisión del enrutamiento en diferentes idiomas, apuntando a una caída de precisión no mayor al 5–10% 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 límite y mide la precisión del enrutamiento, apuntando a al menos un 80% 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–3%) en todos los grupos de clientes.
  </Accordion>

  <Accordion title="Eficiencia del prompt">
    En situaciones donde minimizar el conteo de tokens es crucial, 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 una precisión del 90% o más 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 persona apropiada en el primer intento. 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–95%, 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 deben reasignarse 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%, con los sistemas de mejor rendimiento logrando tasas tan bajas como el 5% 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. 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–75%, con los mejores logrando tasas del 80% 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 efectivo contribuye a una mayor satisfacción. Apunta a puntuaciones CSAT del 90% o superiores, con los mejores logrando a menudo tasas de satisfacción del 95% o más.
  </Accordion>

  <Accordion title="Tasa de escalamiento">
    Esto mide con qué frecuencia los tickets deben escalarse a niveles superiores de soporte. Tasas de escalamiento más bajas suelen indicar un enrutamiento inicial más preciso. Esfuérzate por lograr una tasa de escalamiento inferior al 20%, con los mejores sistemas de su clase logrando tasas del 10% 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 enrutamiento mejorado debería aumentar la productividad. Mídela rastreando los tickets resueltos por agente por día u hora, apuntando a una mejora del 10–20% 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 ingresar al sistema de enrutamiento. Tasas más altas indican un triaje previo al enrutamiento efectivo. Apunta a una tasa de desvío del 20–30%, con los mejores logrando tasas del 40% o superiores.
  </Accordion>

  <Accordion title="Costo por ticket">
    Esta métrica calcula el costo promedio de 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 en un 10–15% después de implementar un sistema de enrutamiento mejorado.
  </Accordion>
</AccordionGroup>

### Elige el modelo de Claude adecuado

La elección del modelo depende de las compensaciones 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 una experiencia profunda en la materia, 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.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 despliegue. Comienza definiendo la firma del método que envuelve la llamada a Claude. Amplía el método 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 de método 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 SDK de Claude para ejecutarlo.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el SDK de Claude 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 is Anthropic.TextBlock => 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() { Role = Role.User, 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 tres 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 agregar una función que compare la intención predicha con la intención real y calcule el porcentaje de predicciones correctas. Luego agrega la funcionalidad de cálculo de costos y medición de tiempo.

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

  <CodeGroupItem language="CLI">
    Este flujo de trabajo necesita más lógica que un solo comando de shell. Usa el SDK de Claude 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(request, 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(
    request: 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 is Anthropic.TextBlock => 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 request, 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() { Role = Role.User, 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, request, 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 request, 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 $request, 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, request, 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:

* El método `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.
* El método extrae las 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 en tiempo de ejecución de precisión, tiempo de respuesta y 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

Tener estos umbrales te permite determinar rápida y fácilmente a escala, y con empirismo imparcial, qué método es mejor para ti y qué cambios podrían ser necesarios para ajustarse 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, lo que permite 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 "latency" (latencia):** Ten en cuenta que múltiples clasificadores pueden aumentar la 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.

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

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

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

<AccordionGroup>
  <Accordion title="Los clientes hacen solicitudes implícitas">
    Los clientes a menudo expresan sus necesidades de forma indirecta. Por ejemplo, "Llevo esperando mi paquete más de dos semanas" puede 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 puede priorizar abordar la emoción por encima de resolver el problema subyacente.

    * **Solución:** Proporciona a Claude indicaciones sobre cuándo priorizar o no el sentimiento del cliente. Puede ser algo tan simple como "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 múltiples problemas en una sola interacción, Claude puede 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="Cookbook de clasificación" icon="link" href="https://platform.claude.com/cookbook/capabilities-classification-guide">
    Visita el cookbook 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>