Modelfile: enable Ollama tool calling via TEMPLATE directive

Ollama's tool-capability detector reads the Modelfile TEMPLATE for
.Tools / .ToolCalls references. Without one, /api/chat and
/v1/chat/completions reject any request carrying a `tools` array with
"<model> does not support tools" — even though the GGUF's embedded
jinja handles tool calls fine.

Ship the same Qwen 3.6 ChatML (Go-template form) the 35B sibling uses,
including the JSON-in-<tool_call> envelope Ollama's parser understands.
After `make build`, `ollama show janus-27b` lists `tools` and
`thinking` under Capabilities, and the existing
`examples/ollama_chat.py:tool_round_trip` helper now completes the
model -> tool -> model loop end-to-end against Ollama.

Drop the now-stale "[skip]" path from the demo, the docstring warning
on the helper, the README "Known limitations" bullet, and the
matching CHANGELOG entry that documented the gap.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

CHANGELOG.md

@@ -7,17 +7,18 @@ and documentation**, not the underlying base model.
 
 ## [Unreleased]
 
-### Documented
-- Tool calling via Ollama is currently rejected with `does not support
-  tools` because the Modelfile has no `TEMPLATE` directive exposing the
-  Qwen 3.6 tool-jinja blocks. Verified against both `/api/chat` and
-  `/v1/chat/completions`. README "Tool / function calling" + Known
-  limitations updated to reflect reality. `examples/ollama_chat.py:
-  tool_round_trip` keeps the helper as a reference shape but adds a
-  docstring warning, and the demo wraps the call in a try/except so it
-  prints `[skip]` instead of crashing.
-
 ### Fixed
+- `Modelfile`: ship a `TEMPLATE` directive mirroring Qwen 3.6 ChatML in
+  Ollama Go-template form, so Ollama's tool-capability detector sees
+  `.Tools` / `.ToolCalls` references. After `make build`, `ollama show
+  janus-27b` now lists `tools` and `thinking` under Capabilities, and
+  both `/api/chat` and `/v1/chat/completions` accept a `tools` array
+  (previously rejected with `does not support tools`). Same template as
+  the 35B sibling — both share the Qwen 3.6 chat format. Verified
+  end-to-end with `examples/ollama_chat.py:tool_round_trip` (model
+  emits a `<tool_call>`, helper executes the stub, model produces final
+  answer). README "Tool / function calling" rewritten and the
+  corresponding Known-limitations bullet removed.
 - `Modelfile`: added explicit `PARAMETER stop` directives for `<|im_end|>`,
   `<|endoftext|>`, and `<|im_start|>`. Ollama was only picking up
   `<|im_end|>` from the GGUF metadata, so when the model emitted

Modelfile

@@ -1,9 +1,9 @@
 # Janus-27B — Ollama wrapper around Qwen 3.6 27B (dense)
 #
-# Text-only. Vision via Ollama is currently broken for this architecture
-# (ollama/ollama#15898 — the vendored llama.cpp fork is missing the
-# qwen35 arch entries). Use llama.cpp directly for image input, or wait
-# for the fix. See the Vision section in README.md.
+# Text + tool calling. Vision via Ollama is currently broken for this
+# architecture (ollama/ollama#15898 — the vendored llama.cpp fork is
+# missing the qwen35 arch entries). Use llama.cpp directly for image
+# input, or wait for the fix. See the Vision section in README.md.
 #
 # This repo does not redistribute weights. Edit the FROM line below to
 # point at a local Qwen 3.6 27B GGUF, then:
@@ -20,6 +20,64 @@
 
 FROM ./Qwen3.6-27B-Q4_K_M.gguf
 
+# Chat template — Qwen 3.6 ChatML in Ollama Go-template form, with the
+# tool-calling blocks Ollama's capability detector looks for. Without a
+# TEMPLATE that references .Tools and .ToolCalls, /api/chat and
+# /v1/chat/completions reject any request carrying a `tools` array with
+# `<model> does not support tools`. Same template as the 35B sibling —
+# both share the Qwen 3.6 chat format.
+TEMPLATE """{{- $lastUserIdx := -1 -}}
+{{- range $idx, $msg := .Messages -}}
+{{- if eq $msg.Role "user" }}{{ $lastUserIdx = $idx }}{{ end -}}
+{{- end }}
+{{- if or .System .Tools }}<|im_start|>system
+{{ if .System }}{{ .System }}
+
+{{ end }}
+{{- if .Tools }}# 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>
+{{- range .Tools }}
+{"type": "function", "function": {{ .Function }}}
+{{- end }}
+</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>
+{{- end -}}<|im_end|>
+{{ end }}
+{{- range $i, $_ := .Messages }}
+{{- $last := eq (len (slice $.Messages $i)) 1 -}}
+{{- if eq .Role "user" }}<|im_start|>user
+{{ .Content }}<|im_end|>
+{{ else if eq .Role "assistant" }}<|im_start|>assistant
+{{ if (and $.IsThinkSet (and .Thinking (or $last (gt $i $lastUserIdx)))) -}}
+<think>{{ .Thinking }}</think>
+{{ end -}}
+{{ if .Content }}{{ .Content }}{{ end }}
+{{- if .ToolCalls }}
+{{- range .ToolCalls }}
+<tool_call>
+{"name": "{{ .Function.Name }}", "arguments": {{ .Function.Arguments }}}
+</tool_call>
+{{- end }}
+{{- end }}{{ if not $last }}<|im_end|>
+{{ end }}
+{{- else if eq .Role "tool" }}<|im_start|>user
+<tool_response>
+{{ .Content }}
+</tool_response><|im_end|>
+{{ end }}
+{{- if and (ne .Role "assistant") $last }}<|im_start|>assistant
+<think>
+{{ end }}
+{{- end }}"""
+
 # Sampling tuned for reasoning + general use. See README "Recommended sampling"
 # for creative/RP alternatives.
 PARAMETER temperature 0.6

README.md

@@ -306,40 +306,40 @@ client doesn't.
 
 #### Tool / function calling
 
-Qwen 3.6's chat template uses Qwen's XML format:
+The Modelfile ships with a `TEMPLATE` directive that exposes Qwen 3.6's
+tool-calling blocks to Ollama. After `make build`, `ollama show
+janus-27b` lists `tools` (and `thinking`) under **Capabilities**, and
+both `/api/chat` and `/v1/chat/completions` accept a `tools` array.
+
+The template prompts the model to emit tool calls as JSON inside
+`<tool_call>` XML tags — the format Ollama's tool-call extractor parses:
 
 ```text
 <tool_call>
-<function=get_current_weather>
-<parameter=city>Paris</parameter>
-<parameter=unit>celsius</parameter>
-</function>
+{"name": "get_current_weather", "arguments": {"city": "Paris", "unit": "celsius"}}
 </tool_call>
 ```
 
-> **Tool calling via Ollama is currently disabled for this Modelfile.**
-> Both `/api/chat` and `/v1/chat/completions` reject requests with
-> `"<model> does not support tools"` because Ollama's tool-capability
-> detection requires an explicit Modelfile `TEMPLATE` directive
-> containing tool-jinja blocks, and we currently fall back to the
-> trivial `{{ .Prompt }}` template (the GGUF's embedded jinja isn't
-> picked up by Ollama's detector). Plain chat, streaming, and
-> system-prompt overrides all work — only the `tools` array is
-> rejected.
->
-> If you need tool calling, use **llama.cpp** / **llama-cpp-python**
-> directly (they read the GGUF's embedded chat template), or write a
-> Modelfile `TEMPLATE` mirroring the official Qwen 3.6 chat template.
-> The reference Python helper `examples/ollama_chat.py:tool_round_trip`
-> is shipped for documentation but raises `HTTPError 400` against
-> Ollama until the above is fixed.
+(The Qwen 3.6 base was trained on a more verbose XML form with
+`<function=...>` / `<parameter=...>` blocks; the JSON-in-XML envelope
+above is what Ollama's parser understands and what the sibling 35B
+Modelfile uses in production.)
+
+End-to-end exercise:
+
+```bash
+python examples/ollama_chat.py        # section 3 runs a real round-trip now
+```
+
+If you'd rather drive llama.cpp / llama-cpp-python directly (no Ollama
+in the loop) they read the GGUF's embedded jinja and accept either
+format.
 
 ## Known limitations
 
 - **Slower per token than the 35B-A3B sibling.** Dense 27B beats sparse 35B/3B-active on steps-per-second benchmarks because every parameter contributes; if you optimize for tokens-per-second, the MoE wins.
 - **No mmproj in this release**, and **vision via Ollama is broken upstream** (qwen35/qwen35moe arch entries missing from Ollama's vendored llama.cpp fork — see the [Vision](#vision) section). For image input use llama.cpp directly until that's fixed.
 - **Q4_K_M quality loss** is real. Use Q5_K_M or Q6_K if you have the VRAM (~20-22 GB).
-- **Tool calling via Ollama is currently disabled** because the Modelfile has no `TEMPLATE` directive exposing the Qwen 3.6 tool-jinja blocks; Ollama returns `does not support tools` for any request with a `tools` array. Use llama.cpp directly for tool calling, or contribute a Modelfile `TEMPLATE`. See [Tool / function calling](#tool--function-calling).
 - **No formal evaluation in this card.** Numbers above are estimates.
 
 ## Related models

examples/ollama_chat.py

@@ -109,15 +109,7 @@ def fake_weather(city: str, unit: str) -> str:
 
 
 def tool_round_trip(prompt: str) -> str:
-    """Single-shot tool call: model -> tool -> model -> final answer.
-
-    NOTE: Currently fails against Ollama with HTTPError 400
-    "<model> does not support tools" because the project Modelfile has
-    no TEMPLATE directive exposing the Qwen 3.6 tool-jinja blocks. The
-    function is shipped as a reference for the request shape — wire it
-    against llama-cpp-python or a custom-templated Modelfile to actually
-    run it. See README "Tool / function calling".
-    """
+    """Single-shot tool call: model -> tool -> model -> final answer."""
     history: list[dict[str, Any]] = [{"role": "user", "content": prompt}]
     r = requests.post(
         f"{HOST}/api/chat",
@@ -191,14 +183,7 @@ def _demo() -> None:
     print()
 
     print("\n=== 3. tool round-trip ===")
-    try:
-        print(tool_round_trip("What is the weather in Paris in celsius?"))
-    except requests.HTTPError as e:
-        if e.response is not None and "does not support tools" in e.response.text:
-            print("[skip] Ollama refuses tools for this Modelfile (no TEMPLATE).")
-            print("       See README 'Tool / function calling' for context.")
-        else:
-            raise
+    print(tool_round_trip("What is the weather in Paris in celsius?"))
 
     print("\n=== 4. OpenAI-compat ===")
     print(openai_chat("Say 'OpenAI endpoint OK' and nothing else."))