Add F16 GGUF + tool-aware Modelfile for local runtimes (Ollama/LM Studio/llama.cpp)

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 tokenizer.json filter=lfs diff=lfs merge=lfs -text
+gguf/Ze1.5-1.5B-Automotive-Embedded-Instruct-F16.gguf filter=lfs diff=lfs merge=lfs -text

gguf/Modelfile

@@ -0,0 +1,69 @@
+FROM ./Ze1.5-1.5B-Automotive-Embedded-Instruct-F16.gguf
+# Tool-aware ChatML template. Two reasons it must reference .Tools:
+#   1) Ollama sets the model's "tools" capability ONLY if the template has a .Tools node — that's
+#      what makes GitHub Copilot (and other clients) show Tools / agent mode for this model.
+#   2) When a client passes tools, they're rendered into the system `# Tools` block in the exact
+#      format this model expects.
+# NOTE: this model emits tool calls as a ```json code block (not a special tool-call token), so the
+# tool instruction AND the assistant .ToolCalls rendering use a ```json fence, and tool results
+# come back as <tool_response> in a user turn.
+TEMPLATE """{{- if .Messages }}
+{{- 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>
+
+To call a function, output a ```json code block containing a JSON object with the function name and arguments, then stop:
+```json
+{"name": <function-name>, "arguments": <args-json-object>}
+```
+{{- 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 .Content }}{{ .Content }}
+{{- else if .ToolCalls }}```json
+{{ range .ToolCalls }}{"name": "{{ .Function.Name }}", "arguments": {{ .Function.Arguments }}}
+{{ 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
+{{ end }}
+{{- end }}
+{{- else }}
+{{- if .System }}<|im_start|>system
+{{ .System }}<|im_end|>
+{{ end }}{{ if .Prompt }}<|im_start|>user
+{{ .Prompt }}<|im_end|>
+{{ end }}<|im_start|>assistant
+{{ end }}{{ .Response }}"""
+SYSTEM """You are Ze1.5, an embedded-systems and automotive firmware specialist: C/C++, MCUs, RTOS, drivers/peripherals (UART/SPI/I2C/CAN/LIN/Ethernet), ISRs, UDS/OBD diagnostics, MISRA C, and AUTOSAR (Classic and Adaptive Platform). Answer precisely and, when a tool is provided and useful, call it."""
+PARAMETER temperature 0.7
+PARAMETER top_p 0.8
+PARAMETER top_k 20
+PARAMETER repeat_penalty 1.1
+# Copilot/agent clients send large prompts (system + tool defs + file context). Default num_ctx
+# 4096 truncates those; 16384 fits a typical agent turn on 8 GB (weights ~3GB + KV ~0.5GB).
+PARAMETER num_ctx 16384
+PARAMETER stop "<|im_end|>"
+PARAMETER stop "<|im_start|>"

gguf/README.md

@@ -0,0 +1,53 @@
+# Anyze Ze1.5 Instruct — GGUF (Ollama / LM Studio / llama.cpp)
+
+This folder contains the model in GGUF for local runtimes:
+
+- `Ze1.5-1.5B-Automotive-Embedded-Instruct-F16.gguf` — F16 weights (~3.1 GB).
+- `Modelfile` — tool-aware ChatML template + default system prompt and sampling.
+
+Ze1.5 is a 1.5B automotive/embedded specialist (C/C++, MCUs, RTOS, CAN/LIN, UDS,
+MISRA, AUTOSAR) that also handles everyday Python, Linux/systems, and shell work,
+with agentic tool calling. Context window 128k (YaRN); a large KV-cache needs several
+GB, so size `num_ctx` to your hardware.
+
+## Ollama
+
+From this folder:
+
+```bash
+ollama create ze1_5-embedded -f Modelfile
+ollama run ze1_5-embedded "Write a ring buffer in C for a UART RX ISR"
+```
+
+The `Modelfile` template exposes the model's **tools** capability, so agent clients
+(e.g. GitHub Copilot) can pass tool definitions and get `json`-fenced tool calls back.
+Override the default system prompt with `/set system "..."` in a running session.
+
+## LM Studio
+
+Load the GGUF directly — the ChatML chat template is embedded, so no manual
+prompt-format setup is needed. Set the system prompt to match your task; suggested
+sampling is `temperature 0.7, top_p 0.8, top_k 20, repeat_penalty 1.1`.
+
+## Rebuild / quantize with llama.cpp
+
+To regenerate the GGUF from the `../huggingface` export, or make a smaller quant:
+
+```bash
+git clone https://github.com/ggerganov/llama.cpp
+pip install -r llama.cpp/requirements.txt
+
+# F16 GGUF from the HF export
+python llama.cpp/convert_hf_to_gguf.py ../huggingface \
+    --outfile Ze1.5-1.5B-Automotive-Embedded-Instruct-F16.gguf --outtype f16
+
+# optional: quantize (build llama.cpp tools first)
+./llama.cpp/build/bin/llama-quantize \
+    Ze1.5-1.5B-Automotive-Embedded-Instruct-F16.gguf \
+    Ze1.5-1.5B-Automotive-Embedded-Instruct-Q4_K_M.gguf Q4_K_M
+```
+
+Then point the `Modelfile` `FROM` at whichever GGUF you built.
+
+Licensed under Apache-2.0 (see `../huggingface/LICENSE`). Always review generated
+code before flashing to hardware.

gguf/Ze1.5-1.5B-Automotive-Embedded-Instruct-F16.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2632d19c1abeabfbf4134bc48b94f49c699988455a5e91592e2b75f5d2a44be9
+size 3093669280