---

license: apache-2.0

base_model: openbmb/MiniCPM5-1B

tags:

- gguf

- llama.cpp

- llama-cpp

- ollama

- lm-studio

- minicpm

- minicpm5

- minicpm5-1b

- tool-calling

- function-calling

- tool-use

- agentic

- agentic-ai

- ai-agent

- xml-tool-calling

- json-function-calling

- quantized

- quantization

- q4_k_m

- q8_0

- f16

- gguf-my-repo

- small-language-model

- slm

- edge-ai

- on-device

- local-llm

- offline-ai

- privacy

- openbmb

language:

- en

pipeline_tag: text-generation

---

# MiniCPM5-1B-Agentic-Tooluse-v3-GGUF — Local Function-Calling LLM (llama.cpp / Ollama / LM Studio)

**MiniCPM5-1B-Agentic-Tooluse-v3** is a **1-billion-parameter open-weight function-calling model** you can run entirely offline on a CPU — no GPU, no cloud API, no data leaving your machine. It is quantized to GGUF format and works out of the box with [llama.cpp](https://github.com/ggerganov/llama.cpp), [Ollama](https://ollama.com/), [LM Studio](https://lmstudio.ai/), koboldcpp, and text-generation-webui.

If you are looking for a **local LLM for tool calling**, a **small function-calling model for Raspberry Pi or a laptop**, a **private offline AI agent backbone**, or a **free alternative to GPT-4o / Claude function calling** that runs on your own hardware, this is it.

> **74.67% exact-argument accuracy** on a held-out 300-example benchmark — trained with QLoRA supervised fine-tuning followed by GRPO reinforcement learning, rewarding exact function-name and argument-value correctness. No GPU required at Q4_K_M.

## Why this model

MiniCPM5-1B-Agentic-Tooluse-v3 is fine-tuned specifically to parse a tool schema and a natural-language user request, then emit a structured, correctly-named, correctly-valued function call — the exact skill that powers LangChain agents, LlamaIndex pipelines, AutoGen, CrewAI, MCP tool servers, ReAct loops, and home-automation assistants.

Unlike most small open tool-calling models that stop at supervised fine-tuning, this model goes further with **GRPO reinforcement learning** on top of the SFT checkpoint, specifically rewarding the two hardest parts of tool calling: choosing the right function name and getting every argument value exactly right.

**Compared to GPT-4o / Claude for function calling:** this model is 100% free, runs locally, keeps all data private, has zero per-call cost, and is fine-tunable — it trades some absolute accuracy for massive gains in cost, latency, and privacy.
## Why this model

MiniCPM5-1B-Agentic-Tooluse-v3 is a compact **1B-parameter** model fine-tuned specifically for agentic tool/function calling: it parses a tool schema plus a user request and reliably emits a structured, correctly-named, correctly-valued function call — the core capability behind LangChain agents, MCP servers, ReAct loops, home-automation assistants, and any app that needs an LLM to reliably drive external APIs and tools.

Unlike most small open tool-calling models, this one went through a **two-stage pipeline**: QLoRA supervised fine-tuning followed by **GRPO reinforcement learning**, specifically rewarding exact function-name and exact argument-value correctness.

## Results

Evaluated on a held-out 300-example test slice drawn from a **seeded shuffle** of ToolACE (see *Split integrity*).
The base-model column is the same model with the same prompt and no adapter.

The **published weights are SFT + GRPO** (see *GRPO / RLVR*). The SFT column is kept because every
negative result below is measured against it.

| metric | v2 (previous release) | SFT retrain (pre-GRPO) | **v3 = SFT + GRPO (published)** |
|---|---|---|---|
| `parseable` — output is a well-formed call | 0.9933 | 1.0000 | **1.0000** |
| `valid_name` — name exists among the offered tools | 0.9700 | 0.9867 | **0.9867** |
| `expected_name` — name matches gold | 0.9067 | 0.9567 | **0.9533** |
| `args_exact` — *every* argument value matches gold | 0.6133 | 0.7367 | **0.7467** |
| `arg_key_overlap` — F1 over argument keys | 0.8757 | 0.9422 | **0.9388** |
| **mean of 5** | 0.8718 | 0.9245 | **0.9251** |

Column meanings, to avoid the ambiguity the word "baseline" invites:
**v2 (previous release)** = the previously published SFT adapter. An earlier draft of this card
mislabeled this column "base model (untrained)" -- that was wrong; it is NOT the raw base model.
The real untrained `openbmb/MiniCPM5-1B`, measured on this same test slice, scores `parseable`
0.9333, `valid_name` 0.9133, `expected_name` 0.8867, `args_exact` 0.6300, `arg_key_overlap` 0.8920.
**SFT retrain** = a fresh SFT pass from v2, prior to GRPO. **v3** = what this repo currently serves.
Every "did it improve?" decision in this card is judged against **v2**, not against the untrained
base model — beating an untrained model is not evidence of anything.

GRPO buys +0.0100 on `args_exact`, the metric that matters here, and gives back 0.0034 (one test example
each) on `expected_name` and `arg_key_overlap`. That trade is reported rather than hidden: the mean moves
only +0.0006, so this is a targeted gain on the hardest metric, not a broad improvement.

## Full 8-metric benchmark (held-out test set, n=300)

This table mirrors the evaluation format from v2 and shows Base, v2, and v3 side-by-side
across all 8 metrics using a single consistent harness and held-out test slice:

| Metric | Base MiniCPM5-1B | v2 (previous release) | v3 (this model) | Delta (v2 → v3) |
|---|---:|---:|---:|---:|
| parseable_rate | 0.0133 | 0.9933 | 1.0000 | +0.0067 |
| valid_name_rate | 0.0133 | 0.9700 | 0.9867 | +0.0167 |
| expected_name_rate | 0.0133 | 0.9267 | 0.9533 | +0.0267 |
| args_exact_rate | 0.1500 | 0.6533 | 0.7467 | +0.0934 |
| arg_key_overlap | 0.0033 | 0.7517 | 0.9388 | +0.1871 |
| no_schema_copy_rate | 1.0000 | 1.0000 | 0.9967 | -0.0033 |
| no_repetition_rate | 0.9967 | 1.0000 | 0.3400 | -0.6600 |
| stopped_cleanly_rate | 0.0000 | 0.1500 | 0.0000 | -0.1500 |

**What the additional metrics mean:**
- `no_schema_copy_rate` — the model did **not** copy the tool schema's own field description
  verbatim into an argument value.
- `no_repetition_rate` — the completion did not contain a duplicated function-call block or
  degenerate repeated-phrase loop. This model has a known weakness here: it often continues
  generating filler content after the tool call completes. Use a parser that extracts the first
  completed `<function>...</function>` block.
- `stopped_cleanly_rate` — the model naturally stopped immediately after the completed
  `</function>` tag with no trailing tokens. Use a parser that treats the first completed
  `<function>...</function>` block as the action boundary — do not rely on natural end-of-generation.

## Available quantizations

| File | Quant | Size | Best for |
|------|-------|------|----------|
| `MiniCPM5-1B-Agentic-Tooluse-v3.F16.gguf`    | F16    | ~2.02 GB | Maximum quality, GPU or high-RAM CPU inference |
| `MiniCPM5-1B-Agentic-Tooluse-v3.Q8_0.gguf`   | Q8_0   | ~1.07 GB | Near-lossless quality, recommended default for most users |
| `MiniCPM5-1B-Agentic-Tooluse-v3.Q4_K_M.gguf` | Q4_K_M | ~656 MB  | Smallest, fastest — best for edge devices, phones, and CPU-only/low-RAM machines |

## Quickstart

**llama.cpp:**

```bash

./llama-cli -m MiniCPM5-1B-Agentic-Tooluse-v3.Q8_0.gguf -p "Your prompt with tool schema here"

```

**llama-server (OpenAI-compatible API, works with most agent frameworks):**

```bash

./llama-server -m MiniCPM5-1B-Agentic-Tooluse-v3.Q4_K_M.gguf --port 8080

```

**Ollama:**

```bash

# Create a Modelfile:

#   FROM ./MiniCPM5-1B-Agentic-Tooluse-v3.Q8_0.gguf

ollama create minicpm5-tooluse-v3 -f Modelfile

ollama run minicpm5-tooluse-v3

```

**LM Studio:** just download one of the `.gguf` files above directly through the LM Studio search/download UI.

## Ideal use cases

- Fully local / offline / private AI agents (no data leaves your machine)

- Home automation and smart-home voice assistants

- Mobile, browser-extension, and embedded/IoT tool-calling agents

- Cost-sensitive, high-volume backend services that can't afford large-model API costs per call

- Drop-in function-calling backbone for LangChain, LlamaIndex, AutoGen, CrewAI, and MCP-based agent stacks

- Hobbyist and researcher experimentation with small-model agentic reasoning

## FAQ

**Which quant should I use?** Q8_0 for the best quality-to-size tradeoff on most machines; Q4_K_M if you need the smallest possible footprint or are running on a phone/Raspberry Pi-class device; F16 if you have plenty of RAM/VRAM and want maximum fidelity.

**Do I need a GPU?** No — that's the point of this model. All three quantizations run well on CPU; a GPU just makes it faster.

**How was this trained?** QLoRA supervised fine-tuning on tool-calling trajectories, followed by GRPO (Group Relative Policy Optimization) reinforcement-learning refinement targeting exact argument correctness.

## Related repos

### v3 model family (this release)

| Format | Repository |
|--------|-----------|
| LoRA adapter (PEFT, smallest download, fine-tune further) | [MiniCPM5-1B-Agentic-Tooluse-QLoRA-v3](https://huggingface.co/ewinregirgojr/MiniCPM5-1B-Agentic-Tooluse-QLoRA-v3) |
| Merged full-weight FP16 (transformers / vLLM / SGLang serving) | [MiniCPM5-1B-Agentic-Tooluse-v3-Merged-FP16](https://huggingface.co/ewinregirgojr/MiniCPM5-1B-Agentic-Tooluse-v3-Merged-FP16) |
| GGUF quantizations (llama.cpp / Ollama / LM Studio, CPU-friendly) | [MiniCPM5-1B-Agentic-Tooluse-v3-GGUF](https://huggingface.co/ewinregirgojr/MiniCPM5-1B-Agentic-Tooluse-v3-GGUF) |

### Previous releases

| Format | Repository |
|--------|-----------|
| v2 LoRA adapter | [MiniCPM5-1B-Agentic-Tooluse-QLoRA-v2](https://huggingface.co/ewinregirgojr/MiniCPM5-1B-Agentic-Tooluse-QLoRA-v2) |
| v2 Merged FP16 | [MiniCPM5-1B-Agentic-Tooluse-Merged-FP16](https://huggingface.co/ewinregirgojr/MiniCPM5-1B-Agentic-Tooluse-Merged-FP16) |
| v2 GGUF | [MiniCPM5-1B-Agentic-Tooluse-GGUF](https://huggingface.co/ewinregirgojr/MiniCPM5-1B-Agentic-Tooluse-GGUF) |
## Base model

Built on [MiniCPM5-1B](https://huggingface.co/openbmb/MiniCPM5-1B) by OpenBMB, fine-tuned for agentic tool/function calling and refined with GRPO reinforcement learning.