# Running this model in Ollama

Every command and every output on this page was executed against the files in
this repository on **Ollama 0.32.5** before publication. Nothing here is written
from memory.

---

## 1. Get the files

You need the repository contents on disk — the `Modelfile` reads the GGUF from a
path **relative to itself**, so keep the layout intact.

```sh
huggingface-cli download OculusMindAI/OculusMind-ToolCall-8B-v1 \
  --local-dir ./OculusMind-ToolCall-8B-v1
cd ./OculusMind-ToolCall-8B-v1
```

To save bandwidth, fetch only the quantization you want:

```sh
# ~4.8 GB — Q4_K_M
huggingface-cli download OculusMindAI/OculusMind-ToolCall-8B-v1 \
  --local-dir ./OculusMind-ToolCall-8B-v1 \
  --include "Modelfile" "gguf/Q4_K_M/*"

# ~8.4 GB — Q8_0
huggingface-cli download OculusMindAI/OculusMind-ToolCall-8B-v1 \
  --local-dir ./OculusMind-ToolCall-8B-v1 \
  --include "Modelfile.Q8_0" "gguf/Q8_0/*"
```

**Verify what you downloaded** against `CHECKSUMS.sha256`:

```sh
shasum -a 256 -c CHECKSUMS.sha256
```

## 2. Create the model

Run from the directory containing the `Modelfile`. This matters: `FROM` is
resolved relative to the Modelfile's own location, not your shell's working
directory, and Ollama reports a mismatch as `400 Bad Request: invalid model
name` rather than a missing-file error.

```sh
ollama create pico -f Modelfile              # Q4_K_M
ollama create pico-q8 -f Modelfile.Q8_0      # Q8_0
```

`ollama create` copies the weights into Ollama's own store, so each build costs
its size again on disk (4.8 GB / 8.4 GB) on top of the download.

**Which one?** `Q8_0` is the more faithful build and the one this model card
leads with; `Q4_K_M` is ~40 % smaller and ~40 % faster to generate. Benchmark
scores for the two are within noise of each other — see the model card §3.

## 3. Use it

```sh
ollama run pico "Name three primary colors."
```
```
The three primary colors are red, blue, and yellow.
```

With no system prompt of your own, the model introduces itself from the default
embedded in the GGUF:

```sh
ollama run pico "Who are you? Answer in one sentence."
```
```
I am a large language model created by OculusMind.AI.
```

## 4. Tool calling — what this model is for

Pass tools through Ollama's OpenAI-shaped `tools` array on `/api/chat`:

```sh
curl -s http://127.0.0.1:11434/api/chat -d '{
  "model": "pico",
  "stream": false,
  "messages": [{"role": "user", "content": "What is the weather in San Francisco in celsius?"}],
  "tools": [{
    "type": "function",
    "function": {
      "name": "get_current_weather",
      "description": "Get the current weather for a city",
      "parameters": {
        "type": "object",
        "properties": {
          "city": {"type": "string", "description": "The city name"},
          "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
        },
        "required": ["city", "unit"]
      }
    }
  }]
}'
```

Returns a structured call with empty `content`:

```json
{"message": {"role": "assistant", "content": "",
  "tool_calls": [{"function": {
    "name": "get_current_weather",
    "arguments": {"city": "San Francisco", "unit": "celsius"}}}]}}
```

Feed the result back as a `tool` message to get the final answer:

```json
{"messages": [
  {"role": "user", "content": "What is the weather in San Francisco in celsius?"},
  {"role": "assistant", "content": "", "tool_calls": [{"function": {"name": "get_current_weather", "arguments": {"city": "San Francisco", "unit": "celsius"}}}]},
  {"role": "tool", "content": "{\"temp_c\": 14, \"conditions\": \"foggy\"}"}
]}
```
```
The current temperature in San Francisco is 14 degrees Celsius and it's foggy.
```

Both quantizations produce identical tool calls on this example.

## 5. Settings the Modelfile pins, and why

| Directive | Value | Reason |
|---|---|---|
| `stop` | `</s>`, `[INST]`, `[/INST]`, `[TOOL_RESULTS]` | Mistral control tokens. Without these the model can run past its turn and emit the next prompt's scaffolding as text. |
| `temperature` | `0.001` | BFCL's own default, which is what our published numbers were measured at. Near-deterministic, **not** greedy. |
| `num_ctx` | `32768` | Bounds memory. We *evaluated* at 65,536; raise it if your machine allows, especially with long tool schemas. |

No `SYSTEM` line is set, deliberately. A prompt telling the model when to call
tools and when to decline is the behaviour the benchmarks measure, so baking one
in would bias the very categories where this model is weakest. Supply your own agent prompt;
this model was fine-tuned on trajectories carrying real system prompts and tool
schemas, and performs best when given them.

## 6. Two honest warnings

**These are not the settings our benchmark numbers came from.** The published
BFCL figures were produced by a harness that renders prompts itself and calls
llama.cpp's raw `/completion` endpoint. Ollama uses the chat template embedded
in the GGUF and its own tool parser. Both work; they are **different
experiments**, and nothing in the output tells you which one you ran. Do not
expect to reproduce our numbers through Ollama — see
[`eval/reproduce.md`](eval/reproduce.md).

**This model is worse than its base at declining.** It regressed on
irrelevance detection (`live_irrelevance` −15.38 at `Q8_0`). If your workload
sends requests that should *not* produce a tool call, prefer the base model.
Details in the model card §3.2.

## 7. Cleaning up

```sh
ollama rm pico pico-q8
```