~/tools / Archivos de modelo y plantillas de chat / Hugging Face Chat Template Tester

Hugging Face Chat Template Tester — Renderiza una plantilla de chat de Hugging Face y ve el prompt exacto

Pega una plantilla de chat de Hugging Face (Jinja) o el tokenizer_config.json completo de un modelo, añade messages y tools, y mira el texto exacto del prompt que produce apply_chat_template(..., tokenize=False) de transformers. La herramienta ejecuta Jinja2 con la misma configuración de sandbox que transformers, así que el texto, los errores y sus números de línea son los mismos que en Python. Nada sale de tu navegador.

Ejemplos (escritos para esta herramienta)

Pega la plantilla Jinja (chat_template.jinja), o el tokenizer_config.json o chat_template.json completo de los archivos del modelo en Hugging Face.

Una lista JSON de mensajes, la misma lista que pasas a apply_chat_template.

Una lista JSON de definiciones de herramientas (JSON Schema). Déjala vacía si no hay herramientas.

Añade al final el comienzo de un turno del asistente, para que el modelo escriba una respuesta (si la plantilla lo admite).

Deja abierto el último mensaje para que el modelo lo continúe (prefill). No se puede usar junto con add_generation_prompt.

Otros valores que se pasan a apply_chat_template como argumentos con nombre, en forma de objeto JSON, como {"enable_thinking": false}. Las variables que lee la plantilla se listan debajo de la salida.

Más opciones
Tokens especiales

transformers pasa a la plantilla los tokens especiales del tokenizador. Se rellenan cuando pegas tokenizer_config.json.

Para plantillas que admiten documents (RAG): una lista JSON de objetos como {"title": "…", "text": "…"}.

La hora que devuelve strftime_now(). Déjalo vacío para usar la hora actual.

Texto del prompt

<|im_start|>system
You are a helpful assistant.

# Tools

You can call these functions:
<tools>
{"type": "function", "function": {"name": "get_weather", "description": "Get the current weather in a city.", "parameters": {"type": "object", "properties": {"city": {"type": "string", "description": "City name"}}, "required": ["city"]}}}
</tools>

To call one, reply with JSON inside <tool_call></tool_call>.<|im_end|>
<|im_start|>user
What's the weather in Paris?<|im_end|>
<|im_start|>assistant

<tool_call>
{"name": "get_weather", "arguments": {"city": "Paris"}}
</tool_call><|im_end|>
<|im_start|>user
<tool_response>
{"temperature": 22}
</tool_response><|im_end|>
<|im_start|>assistant
688 caracteres

Sobre esta plantilla

Variables que lee
Definidas por apply_chat_template: add_generation_prompt, messages, tools
Tokens especiales: ninguna
Otras: ninguna
Usa {% generation %}
No

Compruébalo en Python

Ejecuta esto para comparar con transformers. Sustituye MODEL_ID por el modelo, o pasa tu plantilla como chat_template=.

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("MODEL_ID")
messages = [
    {'role': 'system', 'content': 'You are a helpful assistant.'},
    {'role': 'user', 'content': "What's the weather in Paris?"},
    {'role': 'assistant', 'content': '', 'tool_calls': [{'type': 'function', 'function': {'name': 'get_weather', 'arguments': {'city': 'Paris'}}}]},
    {'role': 'tool', 'name': 'get_weather', 'content': '{"temperature": 22}'},
]
tools = [
    {'type': 'function', 'function': {'name': 'get_weather', 'description': 'Get the current weather in a city.', 'parameters': {'type': 'object', 'properties': {'city': {'type': 'string', 'description': 'City name'}}, 'required': ['city']}}},
]
text = tokenizer.apply_chat_template(
    messages,
    tools=tools,
    add_generation_prompt=True,
    tokenize=False,
)
print(text)

La salida es el texto antes de la tokenización. transformers lo tokeniza después con add_special_tokens=False, así que los tokens especiales aparecen solo donde la plantilla los escribe.

Cuando se dan tools y el modelo tiene una plantilla llamada tool_use, transformers usa esa. También puedes elegir una plantilla por nombre.

messages, tools y documents se leen como el módulo json de Python: los números enteros pasan a int y los números con punto decimal pasan a float, lo que puede cambiar cómo los imprime la plantilla.

Comprobado el 2026-11-09 con transformers 5.22.2 y Jinja2 3.1.6 (Python 3.14). transformers: plantillas de chat · Código fuente de transformers

Todo se ejecuta en tu navegador. Nada de lo que pegas se envía ni se guarda.

La mayoría de los modelos abiertos de Hugging Face incluyen una plantilla de chat: un pequeño programa Jinja que convierte una lista de mensajes en el texto que el modelo lee de verdad. Un espacio que falta, un BOS duplicado o un prompt de generación incorrecto cambian lo que ve el modelo, y la plantilla es difícil de leer sin ejecutarla. Esta herramienta la ejecuta como lo hace transformers. Portamos Jinja2 3.1.6 a JavaScript: su analizador léxico, su analizador sintáctico, las reglas de qué variables son visibles y dónde, el plegado de constantes, el sandbox que usa transformers y todos los filtros y tests integrados, junto con el comportamiento propio de Python para cadenas, números, ordenación y mensajes de error. Encima de eso sigue apply_chat_template de transformers 5.22.2: tokens especiales como bos_token, la plantilla tool_use cuando se dan tools, add_generation_prompt, continue_final_message, documents, reasoning_content y los tramos {% generation %}. Renderizamos las plantillas de chat de 39 modelos abiertos (Qwen, Llama, Mistral, Gemma, Phi, DeepSeek, gpt-oss y otros) con 15 tipos de conversaciones, y los 585 resultados coincidieron con transformers. Más de 20.000 plantillas de prueba adicionales también coincidieron, incluidos los errores y los números de línea, salvo unas pocas que usan el filtro random, cuyo resultado también es aleatorio en Python.

Casos de uso

  • Ver el prompt exacto que recibe un modelo antes de hacer fine-tuning o de servirlo: tokens BOS y EOS, espacios, saltos de línea y el prompt de generación
  • Encontrar los interruptores que lee una plantilla, como enable_thinking, y ver qué cambian
  • Depurar una plantilla de chat que estás escribiendo, con errores y números de línea, tools, documents y continue_final_message

Cómo usarlo

  1. Pega una plantilla de chat, o el tokenizer_config.json o chat_template.json completo de un modelo, o elige un ejemplo.
  2. Edita messages y tools (las mismas listas JSON que pasas en Python) y configura add_generation_prompt y las demás opciones.
  3. Lee el texto del prompt y las variables que usa la plantilla, y copia el código Python para comprobar la misma entrada en transformers.

FAQ

¿El resultado es el mismo que el de apply_chat_template?

Es el mismo que el de apply_chat_template(..., tokenize=False), el texto antes de la tokenización. Los tokens especiales, add_generation_prompt, continue_final_message, tools y documents se tratan como en transformers 5.22.2. La herramienta no convierte el texto en token IDs.

¿De dónde vienen bos_token y eos_token?

En Python vienen del tokenizador. Cuando pegas tokenizer_config.json, la herramienta los lee de ahí. Si no, introdúcelos en Más opciones.

¿Qué hace {% generation %}?

Algunas plantillas envuelven las respuestas del asistente en {% generation %} … {% endgeneration %}. transformers usa estos tramos para return_assistant_tokens_mask, por ejemplo para entrenar solo con los tokens del asistente. La herramienta los resalta en la salida.

¿vLLM, llama.cpp u otros servidores darán el mismo texto?

Otros programas pueden renderizar la misma plantilla con un motor distinto o con otra configuración, así que su salida puede diferir. Esta herramienta sigue a transformers.

¿Por qué una variable como enable_thinking aparece en Otras?

La plantilla la lee, pero apply_chat_template no la define. Pásala como variable extra (por ejemplo {"enable_thinking": false}) para cambiar la salida, como pasarías enable_thinking=False en Python.

¿Mi plantilla se envía a algún sitio?

No. Todo se ejecuta en tu navegador.

Relacionados