~/tools / Archivos de modelo y plantillas de chat / Ollama Template Tester
Ollama Template Tester — Ejecuta un TEMPLATE de Ollama y mira el prompt exacto
Pega el TEMPLATE de un modelo de Ollama (de ollama show --template o de tu Modelfile), añade una conversación, herramientas o un prompt, y mira el texto exacto que Ollama entrega al modelo: tokens especiales, saltos de línea y todo. La herramienta ejecuta la plantilla como lo hace Ollama, con las reglas de plantillas de Go, los datos de Ollama (mensajes, tool calls, herramientas, think) y sus tres formas de ejecutar una plantilla. También te dice si Ollama usará tu TEMPLATE o la plantilla de chat que lleva el archivo GGUF, y cuándo Ollama rechaza una petición con herramientas o con thinking. Nada sale de tu navegador.
ollama show --template <model> imprime la plantilla de un modelo que tengas. También sirve el texto entre las comillas triples después de TEMPLATE en un Modelfile.
La misma forma que en /api/chat: role, content y, opcionalmente, thinking, tool_calls, tool_name e images.
La misma forma que tools en /api/chat. Déjalo vacío para no usar herramientas.
Avanzado: el SYSTEM del modelo y su plantilla de chat GGUF
La línea SYSTEM del Modelfile. Ollama la añade cuando el primer mensaje no es un mensaje de sistema (en /api/generate, cuando system está vacío).
Pégala para ver si Ollama usa TEMPLATE o esta. GGUF Metadata Viewer la muestra.
Lo que recibe el modelo
<|im_start|>system
You are a helpful assistant.
# Tools
You may call one or more functions to assist with the user query.
You are provided with function signatures within <tools></tools> XML tags:
<tools>
{"type": "function", "function": {get_weather Get the current weather for a city {object <nil> <nil> [city] {"city":{"type":"string","description":"City name"}}}}}
</tools>
For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:
<tool_call>
{"name": <function-name>, "arguments": <args-json-object>}
</tool_call><|im_end|>
<|im_start|>user
What is the weather in Tokyo?<|im_end|>
<|im_start|>assistant
<tool_call>
{"name": "get_weather", "arguments": {"city":"Tokyo"}}
</tool_call><|im_end|>
<|im_start|>user
<tool_response>
{"temperature": 20}
</tool_response><|im_end|>
<|im_start|>assistant
It is 20°C in Tokyo.<|im_end|>
<|im_start|>user
Thanks!<|im_end|>
<|im_start|>assistant
Sobre esta plantilla
- Cómo la ejecutó Ollama
- Una vez, con toda la conversación en .Messages
- Nombres que usa
- $, $i, $last, arguments, content, function, messages, name, prompt, response, role, system, toolcalls, tools
- Lo que admite (para Ollama)
- herramientas
Comprueba con tu propio Ollama
Sustituye MODEL por el nombre de tu modelo. _debug_render_only es una opción de depuración del código fuente de Ollama, no de la documentación de la API, así que puede cambiar. La respuesta trae el prompt en _debug_info.rendered_template.
curl -s http://localhost:11434/api/chat -d '{"model":"MODEL","messages":[{"role":"system","content":"You are a helpful assistant."},{"role":"user","content":"What is the weather in Tokyo?"},{"role":"assistant","content":"","tool_calls":[{"function":{"name":"get_weather","arguments":{"city":"Tokyo"}}}]},{"role":"tool","content":"{\"temperature\": 20}","tool_name":"get_weather"},{"role":"assistant","content":"It is 20°C in Tokyo."},{"role":"user","content":"Thanks!"}],"tools":[{"type":"function","function":{"name":"get_weather","description":"Get the current weather for a city","parameters":{"type":"object","properties":{"city":{"type":"string","description":"City name"}},"required":["city"]}}}],"stream":false,"_debug_render_only":true}'Los modelos con una línea RENDERER o PARSER en el Modelfile, y gpt-oss, usan renderizadores integrados en Ollama, no TEMPLATE.
Cuando la conversación es más larga que el contexto (num_ctx), Ollama descarta los mensajes más antiguos pero conserva los mensajes de sistema y el último mensaje. Esta herramienta no cuenta tokens, así que siempre muestra la conversación completa.
Para los modelos qwen3 y deepseek-r1, Ollama quita <think>…</think> de los mensajes del asistente anteriores al último mensaje del usuario. Esta herramienta no lo hace.
Imprimir un mensaje completo o {{ .Messages }} muestra direcciones de memoria en Ollama (0xc…), que cambian cada vez. La herramienta muestra un marcador de posición.
currentDate y yesterdayDate usan la fecha de hoy de tu ordenador. Ollama usa la fecha del servidor.
Comprobado el 2026-11-09 con el código fuente de Ollama (v0.40.15), el text/template de Go y Ollama 0.40.11: Ollama: Template · template.go
Todo se ejecuta en tu navegador. No se envía nada a ningún sitio.
Ollama convierte una conversación en el texto que lee un modelo con el TEMPLATE del modelo, escrito en el lenguaje de plantillas de Go: {{ range .Messages }}, {{ .Role }}, {{ .Content }}, {{ if .Tools }} y así sucesivamente. Un error pequeño, como un salto de línea que falta, un {{- que recorta de más o un nombre de campo que no existe, cambia lo que ve el modelo o hace fallar todas las peticiones. Esta herramienta ejecuta tu plantilla como lo hace Ollama. Sigue las reglas de text/template de Go (marcas de recorte, variables, range, with, comparaciones, printf, los mensajes de error), pasa los mismos datos que pasa Ollama (System, Messages con Role, Content, Thinking, ToolCalls, ToolName y ToolCallID, Tools, Think, ThinkLevel, IsThinkSet, Prompt, Suffix, Response) y tiene las funciones adicionales de Ollama (json, currentDate, yesterdayDate, toTypeScriptType). También copia cómo prepara Ollama los datos: los mensajes de sistema se unen en .System, los mensajes consecutivos del mismo rol se unen con una línea en blanco, el SYSTEM del modelo se añade cuando el primer mensaje no es un mensaje de sistema, y las imágenes pasan a ser [img-0], [img-1] y así sucesivamente. Una plantilla que nunca usa .Messages se ejecuta a la manera antigua, una vez por turno con .Prompt y .Response, y Ollama añade {{ .Response }} a una plantilla que no usa ni uno ni otro. Desde Ollama 0.40, un modelo también puede llevar una plantilla de chat dentro de su archivo GGUF (tokenizer.chat_template), y Ollama elige una de las dos según lo que puede hacer cada una: herramientas, thinking y fill-in-the-middle. Pega la plantilla de chat del GGUF en Avanzado y la herramienta te dice cuál usará Ollama. Comprobamos la herramienta de tres maneras: con el text/template propio de Go (Go 1.26.6) ejecutando el código de plantillas de Ollama en 243 casos, incluidas las 20 plantillas integradas de Ollama, cuyos resultados de prueba coinciden; con Ollama 0.40.11 en este ordenador con 330 peticiones a /api/generate; y con 49 peticiones a /api/chat a qwen2.5:7b y a modelos que hicimos con nuestros propios TEMPLATE. La salida y los mensajes de error coincidieron.
La lógica principal de esta herramienta es de código abierto, con licencia MIT. github.com/seigo5555/toolkitbox-lib/src/ollama-template.ts
Casos de uso
- Revisar un TEMPLATE que estás escribiendo para un Modelfile antes de ejecutar ollama create: saltos de línea, tokens especiales, el mensaje de sistema, las tool calls y sus resultados
- Averiguar por qué cambiar TEMPLATE no tiene efecto, y si Ollama usa ese TEMPLATE o la plantilla de chat del archivo GGUF
- Ver exactamente qué recibe un modelo en una conversación larga con herramientas, para depurar tool calls incorrectas o ausentes
Cómo usarlo
- Pega una plantilla en el cuadro (ollama show --template <model> imprime la plantilla de un modelo que tengas), o empieza con uno de los ejemplos.
- Elige /api/chat y edita los mensajes y las herramientas como JSON, con la misma forma que la API, o elige /api/generate y rellena prompt, system y suffix. Si usas think, configúralo.
- Lee el resultado, con los espacios en blanco visibles si los necesitas. Para comparar con tu propio Ollama, ejecuta el comando curl de abajo con el nombre de tu modelo.
FAQ
Cambié TEMPLATE, pero la salida no cambió. ¿Por qué?
Desde Ollama 0.40, un modelo puede tener dos plantillas: TEMPLATE del Modelfile y la plantilla de chat que lleva el archivo GGUF. Ollama elige la que puede hacer más (herramientas, thinking, fill-in-the-middle). En nuestra prueba con Ollama 0.40.11, un TEMPLATE sin herramientas se ignoró en un modelo creado a partir de qwen2.5:7b, porque la plantilla de chat GGUF de qwen2.5:7b admite herramientas. El registro del servidor muestra la elección en la línea "template selection" (selected=go_template o selected=gguf_chat_template), y si activas OLLAMA_GO_TEMPLATE=1 en el servidor, Ollama usa TEMPLATE siempre que un modelo tenga uno.
¿Cómo puedo ver el prompt que mi Ollama construye realmente?
El código fuente de Ollama tiene una opción de depuración, _debug_render_only, que devuelve el prompt en lugar de ejecutar el modelo (como _debug_info.rendered_template). La usamos para comprobar esta herramienta. No figura en la documentación de la API, así que puede cambiar. La herramienta te construye el comando curl.
¿Qué diferencia hay entre las plantillas con .Messages y las que usan .Prompt?
Si la plantilla usa .Messages, Ollama la ejecuta una vez con toda la conversación. Si no, la ejecuta una vez por turno con .System, .Prompt y .Response, y en el último turno corta la plantilla después de {{ .Response }}, de modo que el modelo continúa desde ahí. La herramienta muestra cuál de las dos formas se usó.
¿Por qué Ollama responde "does not support tools" o "does not support thinking"?
Ollama rechaza una petición con herramientas cuando la plantilla que usa no admite herramientas (un TEMPLATE las admite cuando usa .Tools), y una petición con think en true o con un nivel cuando la plantilla no tiene parte de thinking. Para una plantilla que sí tiene thinking, Ollama activa think cuando la petición no lo define. La herramienta muestra ambos casos.
Las herramientas de mi prompt no parecen JSON. ¿Es un error de la herramienta?
Probablemente no. En las plantillas de Go, un valor se imprime como JSON solo cuando su tipo lo indica. .Tools de Ollama, una herramienta completa y .Function.Arguments se imprimen como JSON, pero .Function se imprime en el formato propio de Go. En nuestra prueba, la plantilla de qwen2.5:7b usa {{ .Function }}, y Ollama 0.40.11 envió al modelo un texto como {get_weather Get the weather {object <nil> <nil> [city] {…}}}. Usa {{ json .Function }} si quieres JSON.
¿Mi plantilla se envía a algún sitio?
No. Todo se ejecuta en tu navegador.