Skip to content

Pregunta Choice: elige una opción de un conjunto fijo ​

Los materiales ya se prepararon en la lección anterior; en esta lección empiezas a aprender a preguntar. Jev Choice es la primera de las cinco formas de preguntar, y también la más directa: enumeras claramente las opciones, Jev elige una de ellas y la devuelve junto con la probabilidad de cada opción y la confianza general—la respuesta siempre es una de tus opciones, y en tu código no tienes que escribir ni una línea de if para analizar texto.

En realidad ya lo usaste en la primera solicitud: el department de route_ticket.py era una pregunta Choice que eligió technical. Esta lección lo explica a fondo, en 10 minutos en total.

Qué podrás hacer al terminar ​

  • Escribir una pregunta Jev Choice completa con un map de opciones criteria (nombre de opción → descripción de una línea), sabiendo que tanto los nombres como las descripciones se envían al modelo
  • Leer los tres campos de retorno choice, probabilities, confidence, y mapear directamente la opción de mayor probabilidad a una rama de código
  • Preguntar en paralelo varias preguntas Choice en una sola solicitud (una pregunta admite hasta 255 opciones), ignorando las respuestas de las preguntas especulativas que no uses
  • Añadir una opción other cuando la lista puede no ser completa, o, según la recomendación oficial, configurar un Noul complementario como red de seguridad
  • Verificar la estabilidad de las respuestas con «reordenar las opciones y volver a ejecutar»—el orden de las opciones puede influir en la respuesta

Tu dilema actual ​

  • Pides a GPT que clasifique tickets, y cada vez devuelve nombres de categorías distintos—«reembolso», «devolución y reembolso», «pide la devolución del dinero»; el if de tu flujo posterior nunca alcanza su vocabulario inventado
  • Quieres saber qué tan seguro está, y solo puedes preguntar «¿qué tan seguro estás?», recibiendo un párrafo de prosa como «creo que es bastante probable», imposible de escribir en código
  • Un ticket requiere evaluar varias cosas (a qué grupo pertenece, cuál es la causa, qué quiere el cliente); encadenar tres solicitudes es lento y caro; y si lo aprietas todo en un solo prompt, las respuestas se interfieren entre sí

Cuándo usar esta técnica ​

Cuando necesitas:

  • Que la respuesta sea un conjunto de opciones que tú mismo defines: a qué grupo enrutar, a qué categoría pertenece el producto, en qué lenguaje está escrito el código
  • Que la respuesta se convierta directamente en una rama de código—una opción, una ruta, sin analizar texto generado
  • Preguntar varias preguntas de opción sobre el mismo material, y además querer enviar solo una solicitud

Y no quieres:

  • Que el modelo invente nuevas respuestas fuera de tu lista sobre la marcha
  • Escribir un prompt largo para un juicio de un segundo como «a quién pertenece este ticket»
  • Dejar que se ejecute automáticamente incluso cuando el modelo no está seguro

🎒 Preparativos antes de empezar ​

  • Haber completado State (estado): saber que los materiales van en state (cadenas, objetos JSON y arrays de texto sirven), y que las preguntas de evaluación se escriben en questions
  • Haber ejecutado la primera solicitud: .venv tiene instalado typesafe-sdk y la variable de entorno TYPESAFE_API_KEY está configurada
  • Recordar el aspecto general de la pregunta department en route_ticket.py—si la olvidaste, vuelve a echarle un vistazo

Idea central ​

La definición oficial en una frase: cuando la respuesta es una de un conjunto fijo de opciones, usa Choice. Los problemas típicos que da la documentación: qué equipo procesa este ticket, a qué categoría pertenece este producto, en qué lenguaje está escrito este fragmento de código.

La razón de que Choice funcione tan bien es una garantía estricta—la respuesta está restringida a las opciones que das:

Cada respuesta está restringida a las opciones que proporcionas. El modelo devuelve una distribución de probabilidad sobre tus opciones, nunca un valor fuera de ellas. Tu código nunca tiene que extraer la respuesta de prosa generada.

Una pregunta Choice se ve así:

CampoQué escribirExplicación
ID (la clave de la pregunta)A tu elección, por ejemplo departmentSe usa solo en tu código, no se envía al modelo; la respuesta se recupera por esta clave
typeFijo "choice"—
instructionsLa pregunta completaTodo el contenido de la pregunta se escribe aquí; no cuentes con que el ID transmita el mensaje por ti
criteriaMap de opciones: nombre de opción → descripciónTanto los nombres como las descripciones de las opciones se envían al modelo; una pregunta admite hasta 255 opciones

Cómo elegir entre los tres tipos de pregunta (criterio oficial):

Tipo de preguntaQué respondeUso en el código
Choice (esta lección)Cuál opción fija elegir, sin orden entre las opcionesUna opción, una ruta de código
ScoreHasta qué punto en un espectro, con cada nivel que puedes describirComparar con umbral, ordenar
Noulun sí/no limpio, la probabilidad en sí es útilun if

La respuesta es: si es un espectro (qué tan grave, qué tan enojado) → Score; si es un sí/no limpio (si se menciona o no un reembolso) → Noul. Cuando se parece a ambos, la recomendación oficial es elegiraquel cuya respuesta pueda ser accionada directamente por código: refund / rebook / information son tres opciones que se mapean directamente a tres rutas de código, esa es la forma de Choice.

Hazlo conmigo ​

Paso 1: define el map de opciones y escribe tu primera pregunta Choice de Jev ​

Por qué: una pregunta Choice solo tiene tres campos: type, instructions y criteria; tanto los nombres de las opciones como las descripciones se envían al modelo, así que las descripciones deben escribirse de forma que distingan las opciones entre sí.

Usa el ejemplo de la documentación oficial: un ticket de soporte de una tienda de zapatos en línea, preguntando qué equipo debe atenderlo. Crea choice_first.py:

python
# 运行前:export TYPESAFE_API_KEY="<你的API Key>"
from typesafe_sdk import Choice, TypeSafeClient

with TypeSafeClient() as client:
    response = client.system_one(
        state="My running shoes arrived in the wrong size. Can I swap them for a size 10?",
        questions={
            "department": Choice(
                instructions="Which team should handle this?",
                criteria={
                    "returns": "Exchanges, wrong or damaged items",
                    "shipping": "Delivery status, delays, lost packages",
                    "billing": "Charges, invoices, payment problems",
                },
            ),
        },
    )

    print(response.answers["department"].choice)

Ejecútalo:

bash
.venv/bin/python choice_first.py

Deberías ver:

text
returns

Talla incorrecta, quiere cambiar el par: asunto del equipo de returns; en la grabación del ejemplo oficial, el modelo lo apostó todo a returns.

Tres puntos clave para escribir criteria:

  • El nombre de la opción es el valor de la respuesta. El choice que obtienes en el código es la cadena del nombre de la opción; usa identificadores estables en inglés (returns), no texto de visualización que pueda cambiar

  • La función de la descripción es separar. Palabra oficial: los nombres de las opciones y las descripciones se envían al modelo, «así que escribe las descripciones de modo que las opciones se distingan entre sí». Cuando el nombre por sí solo ya lo deja claro, la descripción puede ser null (en el paso 3 hay un ejemplo listo)

  • Da la lista completa, no una lista corta. Una Choice admite como máximo 255 opciones, y añadir opciones solo cuesta unos pocos tokens: dale al modelo todos los equipos, categorías y productos, en lugar de filtrar primero

  • Obtuve returns y sé que este valor viene del nombre de una opción en criteria

Paso 2: entiende el choice, probabilities y confidence que se devuelven ​

Por qué: choice es solo el pico de la distribución; en un proyecto real probablemente usarás probabilities y confidence para escribir ramas, no solo tomar un nombre.

La respuesta completa de la solicitud del paso 1 (ejemplo oficial):

json
{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "returns",
      "confidence": 1.0,
      "probabilities": {
        "shipping": 0.0,
        "returns": 1.0,
        "billing": 0.0
      }
    }
  },
  "usage": {
    "input_tokens": 328,
    "output_tokens": 34
  }
}

Deberías ver: el objeto de respuesta, además de type, contiene tres valores; vamos a desglosarlos uno por uno:

CampoValor en este ejemploCómo leerlo
choicereturnsla opción con mayor probabilidad
probabilitiesreturns 1.0, el resto 0.0la distribución de todas las opciones, suma aproximadamente 1; las claves son los nombres de las opciones
confidence1.0comprime la forma de la distribución en un número de 0–1: todo en una opción = 1, repartido uniformemente = 0

Tres ideas que vale la pena recordar:

  • La respuesta siempre está dentro de las opciones. En una pregunta de tres opciones, probabilities solo tiene esas tres claves; no existe «el modelo agregó una cuarta por su cuenta»
  • confidence solo mira la probabilidad máxima. La fórmula para tres opciones es (3 × 最大概率 − 1) / 2 (donde «最大概率» significa la probabilidad máxima), por eso tanto (0.6, 0.3, 0.1) como (0.6, 0.2, 0.2) tienen un confidence de 0.4. Cómo se calcula este número a partir de la forma de la distribución y cómo usar los tres niveles se explica en detalle en la lección Confidence 置信度
  • confidence es una descripción de la distribución, no una garantía de que la respuesta sea correcta. Este ticket es simple, la probabilidad se apostó toda a returns, así que el confidence es naturalmente 1.0; un ticket que mencione tanto una talla incorrecta como un cobro duplicado repartirá la probabilidad entre returns y billing, y el confidence bajará; en el paso 3 hay justamente uno así

El "model": "jev-1.13.0" del ejemplo es la versión que se usó al grabar el ejemplo oficial; si lo ejecutas ahora con jev-latest, ese campo muestra la versión actual del modelo.

  • Puedo señalar en la respuesta que: choice es el pico, probabilities es la distribución (suma total aproximadamente 1) y confidence es la forma de la distribución

Paso 3: pregunta cinco Choice en una sola solicitud (evaluación en paralelo) ​

Por qué: la recomendación oficial es preguntar de una sola vez todas las Choice que podrías usar: todas las preguntas se evalúan de forma paralela e independiente sobre el mismo state; añadir preguntas casi no aumenta el tiempo de respuesta, y al código le basta ignorar las respuestas que no usa.

Esta vez cambia por un ticket más ambiguo: dos semanas de retraso, talla incorrecta y dos cobros duplicados; los tres equipos tienen algo que ver y el cliente no pidió nada específico. Para este ticket, el ejemplo oficial preguntó de una sola vez cinco Choice:

python
# 运行前:export TYPESAFE_API_KEY="<你的API Key>"
from typesafe_sdk import Choice, TypeSafeClient

TRIAGE_QUESTIONS = {
    "department": Choice(
        instructions="Which team should handle this?",
        criteria={
            "returns": "Exchanges, wrong or damaged items",
            "shipping": "Delivery status, delays, lost packages",
            "billing": "Charges, invoices, payment problems",
        },
    ),
    "return_reason": Choice(
        instructions="If the customer wants to return something, why?",
        criteria={
            "wrong_size": "The item doesn't fit",
            "wrong_item": "A different product was delivered",
            "damaged": "The item arrived broken or faulty",
            "changed_mind": "The item is fine, the customer no longer wants it",
            "other": "A return reason that fits none of the above",
        },
    ),
    "shipping_issue": Choice(
        instructions="If this is a shipping problem, which kind is it?",
        criteria={
            "not_delivered": "The package never arrived",
            "delayed": "The package is late but still on the way",
            "wrong_address": "The package went to the wrong place",
            "damaged_in_transit": "The package arrived damaged",
            "other": "A shipping problem that fits none of the above",
        },
    ),
    "requested_resolution": Choice(
        instructions="What does the customer want to happen?",
        criteria={
            "exchange": "Swap the item for a different one",
            "refund": "Money back",
            "replacement": "The same item sent again",
            "information": "Just an answer, no action needed",
        },
    ),
    "tone": Choice(
        instructions="What is the customer's tone?",
        criteria={"calm": None, "frustrated": None, "angry": None},
    ),
}

ticket = "Shoes arrived two weeks late and in the wrong size. Also I see two charges of $120 on my card. What are you going to do about this?"

with TypeSafeClient() as client:
    response = client.system_one(state=ticket, questions=TRIAGE_QUESTIONS)

Deberías ver (respuesta del ejemplo oficial, las cinco respuestas llegan juntas; esta solicitud consumió en total 589 tokens de entrada / 212 tokens de salida):

Preguntachoiceconfidencepuntos clave de probabilidad
departmentreturns0.42returns 0.61, billing 0.35, shipping 0.04
return_reasonwrong_size1.0wrong_size 1.0, el resto 0.0
shipping_issuedelayed0.67delayed 0.74, other 0.26
requested_resolutionrefund0.2refund 0.40, replacement 0.34, exchange 0.24
tonefrustrated0.76frustrated 0.84, angry 0.16

La interpretación oficial de cada respuesta merece leerse punto por punto:

  • department se dividió: returns 0.61, billing 0.35 — el cobro duplicado le dio a billing una probabilidad de más del treinta por ciento. Este ticket abarca dos grupos, y el confidence 0.42 habla justamente de esto
  • return_reason limpio: «talla incorrecta» está escrito con toda claridad, todo apostado a wrong_size, confidence 1.0
  • shipping_issue es una pregunta especulativa: las respuestas se reparten entre delayed y other, pero department ni siquiera es shipping — el código simplemente lo ignora (el paso 4 hace justamente eso)
  • requested_resolution de baja confianza: refund 0.40, replacement 0.34, exchange 0.24 — el cobro duplicado parece pedir devolución del dinero, la talla incorrecta parece pedir un cambio, y el cliente de principio a fin no dijo cuál quiere
  • tone tiene todas sus descripciones en null: calm / frustrated / angry se explican por su nombre, no necesitan descripción — este es justamente el caso del paso 1 de «si no puedes escribir diferenciación, dale null»

Observa que de estas cinco preguntas hay dos preguntas especulativas (speculative): return_reason solo sirve cuando se clasifica en el grupo returns, y shipping_issue solo sirve cuando se clasifica en shipping. Preguntar primero y tomar según necesidad es la práctica estándar de Jev — la medición real de preguntas oficiales 13 vs 13 solicitudes da 12.2 veces más barato y 10.0 veces más rápido, con las mismas respuestas (se desarrolla en la lección preguntas en paralelo). El demo oficial de hogar inteligente es más extremo: cada solicitud evalúa en conjunto una larga lista de preguntas Choice (categoría, habitación, dispositivo, acción); la mayoría de las respuestas no se usan y el código solo toma las pocas que necesita.

Paso 4: escribe ramas de enrutamiento con choice, probabilities y confidence ​

Por qué: las respuestas son valores tipados — choice se mapea directamente a rutas de código, la baja confianza se deriva a un humano, y si la probabilidad de la segunda opción supera el umbral se envía copia. Una solicitud, cinco respuestas, y todo lo demás es un if normal.

El código de enrutamiento completo oficial, a continuación del paso 3:

python
def triage(ticket: str) -> None:
    with TypeSafeClient() as client:
        response = client.system_one(
            state=ticket,
            questions=TRIAGE_QUESTIONS,
        )
    answers = response.answers

    department = answers["department"]
    if department.confidence < 0.3:
        # Not clear which team to send to. Let a person decide.
        send_to_manual_triage(ticket)
        return

    if department.choice == "returns":
        # return_reason answer is only used here
        assign(ticket, team="returns", issue=answers["return_reason"].choice)
    elif department.choice == "shipping":
        # shipping_issue answer is only used here
        assign(ticket, team="shipping", issue=answers["shipping_issue"].choice)
    else:
        assign(ticket, team="billing")

    # A second team with a real share of the probability gets a copy
    for team, probability in department.probabilities.items():
        if team != department.choice and probability > 0.25:
            notify(ticket, team=team)

    resolution = answers["requested_resolution"]
    if resolution.confidence < 0.5:
        # The customer hasn't said what they want. Ask, don't guess.
        ask_customer_what_they_want(ticket)
    elif resolution.choice == "refund":
        flag_for_refund_approval(ticket)

    if answers["tone"].choice == "angry":
        flag_for_senior_agent(ticket)

(assign / notify / send_to_manual_triage etc. son funciones ilustrativas; sustitúyelas por tu propia lógica de enrutamiento.)

Deberías ver — para el ticket del paso 3, el comportamiento que da el oficial es:

text
assigned to returns team with issue wrong_size
billing team notified (0.35 > 0.25)
customer asked what they want (confidence 0.20 < 0.5)

Los tres valores de umbral vienen del ejemplo oficial: 0.3 (por debajo de él ni siquiera se puede fijar el grupo, se deriva a un humano), 0.25 (la cuota de probabilidad de la segunda opción; si supera la línea, se envía copia), 0.5 (el grado de certeza sobre lo que pide el cliente; por debajo de él se pregunta en lugar de adivinar). shipping_issue: su respuesta no se leyó en ningún momento — el sentido de las preguntas especulativas está justo aquí.

Convertir «clasificación de intención + umbral de confianza» en un sistema de enrutamiento completo (lógica determinista / LLM experto / derivación a humanos, tres niveles) se desarrolla en la lección enrutamiento inteligente.

  • Puedo explicar con claridad, para este ticket: por qué se envió copia a billing, por qué se le pregunta al cliente, por qué shipping_issue no se usó

Paso 5: dos salvaguardas cuando la lista no es completa: la opción other y la Noul acompañante ​

Por qué: la lista de opciones puede no cubrir todas las entradas — el cliente plantea una petición que no previste y el modelo solo puede forzar una elección entre las opciones que le diste. El oficial ofrece dos salvaguardas.

Salvaguarda uno: la opción other. Recomendación oficial: cuando la lista puede no cubrir todas las entradas, añade una opción other o none of the above para que el modelo pueda decir «ninguna de las anteriores». En return_reason, shipping_issue del paso 3 hay una opción other, con una descripción que aclara que es «la salida cuando nada encaja».

Salvaguarda dos: Noul acompañante (la que el oficial recomienda más). El oficial advierte que none of the above en muchos escenarios no necesariamente funciona bien; la alternativa es configurar, en la misma solicitud, una Noul que juzgue «¿hay alguna opción que encaje?», por ejemplo:

text
Choice: ¿a qué categoría pertenece esta petición?
Noul  : ¿se menciona en `message` alguno de `our_products`?

El código solo lee la respuesta de Choice cuando la Noul es yes — si nada encaja, se salta el grupo entero. Este es justamente el enfoque de filtrado de chat en directo: cada mensaje, una solicitud con tres preguntas; si no encaja, se deja pasar directamente. La Noul en sí se explica en la siguiente lección.

Deberías ver: ninguna de las dos salvaguardas necesita una nueva solicitud — other es una opción más en criteria, y la Noul acompañante es una pregunta más en el mismo questions; en conjunto, todo sigue dentro del marco de «una sola solicitud».

  • Puedo decir cuándo usar cada una de las dos salvaguardas: si a la lista de vez en cuando se le escapa algún caso, añade other; si quieres «interceptar incluso lo que no encaja en nada», configura una Noul acompañante

Punto de control ✅ ​

  • Mi criteria es un map de opciones (nombre → descripción), y sé que ambos se envían al modelo y que los ID de las preguntas no
  • Sé que la respuesta siempre está entre las opciones dadas, que probabilities cubre todas las opciones y que la suma es aproximadamente 1
  • Sé que en una solicitud se evalúan varias preguntas en paralelo e independientemente; las respuestas de las preguntas especulativas simplemente no se usan en el código
  • Sé que confidence solo mira la probabilidad máxima (con tres opciones, (3×最大概率−1)/2), es una descripción de la distribución, no una garantía de corrección
  • Recuerdo las dos autocomprobaciones: reordenar las opciones para verificar consistencia; si solo se elige la mejor, tomar directamente la probabilidad máxima

Recordatorio de errores comunes ​

❌ Las descripciones de dos opciones no se distinguen ​

Síntoma: con opciones casi sinónimas como return_policy / return_status, el ticket menciona return y refund en ambas, el modelo vacila entre las dos y el confidence no sube.

Por qué está mal: tanto los nombres de las opciones como las descripciones se envían al modelo. Cuando dos descripciones apuntan al mismo tipo de entrada, el modelo no tiene base de comparación y la probabilidad solo puede repartirse.

Forma correcta: fija las fronteras en las descripciones — qué cubre esta opción y qué no cubre (lo de la opción vecina). Así lo escribe el oficial para return_policy / return_status: cada descripción dice explícitamente el límite de «whether and how an item can be returned»; con ejemplos de contraste, el ejemplo oficial llega a return_status, confidence 1.0. Cuando hay que escribir más, usa directamente objetos como valores de opción (ver el primer consejo avanzado).

❌ Cambias el orden y la respuesta cambia ​

Síntoma: si reordenas las tres opciones de criteria, la respuesta cambia con ello.

Por qué está mal: es un modo de fallo conocido que figura en el manual de errores del oficial (aplicable a jev-1.13) — el orden de las opciones de Choice afecta la respuesta, y el modelo tiende a preferir las opciones que van primero.

Forma correcta: el oficial lo resume en una frase — «reordena las opciones, vuelve a ejecutar y comprueba que las respuestas sean consistentes». Tómalo como autocomprobación fija antes de salir a producción, sobre todo en preguntas con pocas opciones y descripciones cortas. La lista completa de modos de fallo está en el Jev 1.13 manual de errores.

❌ Usar Choice para que el modelo «escriba su propia respuesta» ​

Síntoma: en instructions se escribe «¿cuál es la fecha mencionada en este mensaje?», esperando que el modelo rellene la fecha.

Por qué está mal: Jev no es un modelo generativo; generar texto es tarea de un LLM. Preguntar por un valor abierto sale mal por ambos lados: el modelo no puede inventar (la respuesta está restringida a las opciones) y tú tampoco le diste opciones para elegir.

Forma correcta: si el espacio de respuestas es acotado, enuméralo como opciones. Las fechas son el caso típico: un Choice para el año, otro para el mes y otro para el día —el mes solo tiene doce, el día a lo sumo treinta y uno— y añade a cada uno una opción «no se menciona», así los componentes que falten se informan fielmente en lugar de adivinarse. El código ensambla los componentes en la fecha real y se encarga de todas las comparaciones y operaciones. La receta completa de extracción de valores (regex para hallar candidatos, Jev para elegir el correcto) está en extracción de valores.

❌ Poner umbrales de confidence por todas partes ​

Síntoma: se coloca un umbral de confidence en cada respuesta y en cada rama, cada vez más, y ya no se puede ajustar.

Por qué está mal: la lista de preguntas frecuentes de las Agent Skills oficiales señala este hábito —cuando solo importa elegir la mejor opción, basta con tomar directamente la de mayor probabilidad, sin necesidad de poner umbrales de confidence en todas partes; cuando de verdad hace falta un cálculo estadístico, lo que corresponde usar es probabilities.

Forma correcta: para ramas de enrutamiento usa choice; para análisis de distribuciones usa probabilities; pon umbrales de confidence solo en puertas críticas del tipo «no estoy seguro de ejecutar automáticamente» (como el 0.3 / 0.5 del paso 4), y haz que escalen con el riesgo —el método completo está en la lección Confidence.

Técnicas avanzadas (opcionales) ​

🔧 Cuando las opciones no caben en una línea, usa objetos. Si dos o tres opciones se confunden una y otra vez y una descripción de una línea no aclara la frontera, cambia la descripción por un objeto: un campo dice qué cubre la opción, otro qué no le corresponde y otro da algunos ejemplos. La escritura oficial de return_policy / return_status (petición cruda enviada directamente desde el Playground, la respuesta es return_status, confidence 1.0):

ejemplo oficial de criteria estructurado (JSON crudo)
json
{
  "state": "I sent the shoes back a week ago. When do I get my money?",
  "questions": {
    "return_topic": {
      "type": "choice",
      "instructions": {
        "question": "Which returns topic is the customer asking about?",
        "focus": "Classify the information the customer wants."
      },
      "criteria": {
        "return_policy": {
          "what": "Whether and how an item can be returned",
          "not_for": "Progress of a return already sent",
          "examples": [
            "Can I return shoes I've worn once?",
            "How long do I have to return an order?"
          ]
        },
        "return_status": {
          "what": "Progress of a return already sent",
          "not_for": "Whether and how an item can be returned",
          "examples": [
            "Has my return arrived yet?",
            "When will my refund be paid?"
          ]
        }
      }
    }
  }
}

Dos puntos clave: instructions también puede estructurarse así (question + focus); y los nombres de campo what / not_for / examples no son palabras reservadas de la API, los eliges tú —el modelo ve los nombres y los valores de los campos, así que basta con nombrarlos con palabras cortas que «anoten qué es lo que sigue».

🔧 Árboles de categorías profundas: pregunta capa por capa. Cuando las categorías son muy profundas (clasificación de patentes, catálogos de retail, el árbol de directorios de un repositorio de código), encadena Choices: la respuesta de cada capa determina qué opciones se dan en la petición de la siguiente. El cookbook oficial de clasificación jerárquica ejecuta además beam search —usando el probabilities de Choice para conservar en cada capa las K mejores rutas candidatas, en vez de apostar por una sola. El juego completo está en clasificación de niveles profundos.

🔧 Saltarte el SDK y conectarte directamente a la API. POST https://api.typesafe.ai/v1/systemone, con tres campos en el nivel superior del cuerpo de la petición: state / model / questions; el JSON crudo de la pregunta de department se ve así:

json
{
  "model": "jev-latest",
  "state": "My running shoes arrived in the wrong size. Can I swap them for a size 10?",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "returns": "Exchanges, wrong or damaged items",
        "shipping": "Delivery status, delays, lost packages",
        "billing": "Charges, invoices, payment problems"
      }
    }
  }
}

La definición completa de las restricciones de campos (criteria con un mínimo de 1 y un máximo de 255 opciones, respuesta en cuatro campos) está en referencia rápida de la API.

Resumen de la lección ​

✅ Cómo escribir Choice en Jev: un map de opciones en criteria (nombre → descripción de una línea; hasta 255), la respuesta siempre cae dentro de tus opciones y el código no tiene que parsear texto.

✅ Los tres campos de respuesta se leen juntos: choice es la opción de mayor probabilidad, probabilities es la distribución sobre todas las opciones, confidence es un único número que resume la forma de la distribución.

✅ Varias preguntas en paralelo en una sola petición, evaluadas de forma independiente; las preguntas especulativas se hacen por adelantado y el código usa lo que necesita —en pruebas reales, 13 preguntas combinadas en una petición salieron 12.2 veces más baratas y 10.0 veces más rápidas.

✅ Las listas pueden estar incompletas: añade una salida other, o acompaña con un Noul que juzgue «¿hay algo relacionado?».

Repaso de los campos de configuración clave:

CampoEscritura recomendadaExplicación
type"choice"Valor fijo
instructionsLa pregunta completaEl ID no se envía al modelo, la pregunta debe escribirse entera
criteriaMap de opciones: nombre → descripción diferenciadora de una líneaSi el nombre se explica solo, la descripción va en null; da la lista completa, no una lista corta
Acceso a la respuestaresponse.answers["id"].choiceLeer junto con .probabilities y .confidence

Para ver Choice en escenarios reales: clasificación de niveles profundos (beam search con probabilidades de Choice recorriendo el árbol de categorías), filtrado de chat en directo (un mensaje, una petición con tres preguntas), enrutamiento inteligente (Choice para clasificar la intención, confidence como puerta).

Avance de la próxima lección ​

El otro extremo de las opciones fijas es «en qué grado»: Score, preguntas de puntuación: puntuar según la escala que tú defines.

Aprenderás:

  • criteria cambia del map de opciones a una lista ordenada de niveles, donde el número de nivel es el índice del array
  • score puede caer entre dos niveles (por ejemplo 1.43), hay que leerlo junto con la distribución de probabilidades
  • Los juicios multidimensionales se dividen en varias preguntas Score, y el código los combina con pesos normalizados
  • Cuándo conviene cambiar Choice por Score
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.