---
license: apache-2.0
base_model: Qwen/Qwen2.5-3B-Instruct
tags:
- tool-use
- function-calling
- qwen2.5
- mlx
- lora
- openclaw
- localclaw
- vllm
- agent
language:
- en
library_name: transformers
pipeline_tag: text-generation
---
# qwen25-3b-openclaw
A **Qwen2.5-3B-Instruct** model fine-tuned for exceptional tool/function calling ability, purpose-built as the local agent model for [OpenClaw](https://github.com/openclaw/openclaw) / LocalClaw served via vLLM.
## Model Summary
| Property | Value |
|----------|-------|
| **Base model** | [Qwen/Qwen2.5-3B-Instruct](https://huggingface.co/Qwen/Qwen2.5-3B-Instruct) |
| **Fine-tuning method** | LoRA (rank=16, alpha=32, all 32 layers) |
| **Training framework** | [mlx-lm](https://github.com/ml-explore/mlx-lm) on Apple M4 Max |
| **Training data** | ~57k tool-call examples (hermes-function-calling-v1 + glaive-function-calling-v2) |
| **Training steps** | 600 |
| **Tool format** | `` / `` (Qwen/Hermes convention) |
| **Serving target** | vLLM with `--enable-auto-tool-choice --tool-call-parser hermes` |
## Evaluation
Evaluated on a held-out set of 50 tool-calling examples from the training distribution.
| Metric | Score |
|--------|-------|
| **tool_score** (composite) | **0.989** |
| name_accuracy | 1.000 |
| arg_f1 | 0.983 |
| parse_rate | 0.980 |
| val_loss | 0.010 |
- **name_accuracy**: fraction of examples where the correct function name was called
- **arg_f1**: token-level F1 between predicted and ground-truth arguments
- **parse_rate**: fraction of outputs that contained a valid, parseable `` block
- **tool_score**: `name_accuracy × 0.4 + arg_f1 × 0.4 + parse_rate × 0.2`
## What It's Good For
- **OpenClaw / LocalClaw agent** — drop-in local model for the tool-calling tier; handles calendars, email, web search, browser control, and custom skill tools
- **Any OpenAI-compatible tool-use pipeline** — responds to the standard `tools` parameter and produces structured function calls
- **Offline / privacy-first deployments** — 3B parameters runs fast on Apple Silicon or a modest GPU; no cloud dependency
- **Multi-tool selection** — trained on examples with multiple available tools; reliably selects the right one
- **Argument extraction** — near-perfect extraction of typed arguments from natural-language queries
## What It's Not Good For
- Long multi-turn reasoning chains (consider a larger model for orchestration)
- Tasks requiring no tools — the model is biased toward calling tools when they're available
- Languages other than English (training data is English-only)
## Tool Call Format
The model outputs tool calls using the Hermes `` convention:
```
{"name": "function_name", "arguments": {"arg1": "value1", "arg2": 42}}
```
Multiple parallel calls are output sequentially, each in its own block.
The system prompt should include available tools in `` XML tags:
```
You are a function calling AI model. You are provided with function signatures
within XML tags. You may call one or more functions to assist
with the user query.
{"type": "function", "function": {"name": "get_weather", "description": "...", "parameters": {...}}}
For each function call return a json object within tags.
```
## Quick Start with vLLM
```bash
pip install vllm
vllm serve sunkencity/qwen25-3b-openclaw \
--enable-auto-tool-choice \
--tool-call-parser hermes \
--port 8000
```
This exposes an OpenAI-compatible API at `http://localhost:8000/v1` with structured `tool_calls` in responses.
## Integration with OpenClaw / LocalClaw
LocalClaw auto-discovers models from a running vLLM server. After starting the server above, add to `~/.localclaw/openclaw.local.json`:
```json
{
"agents": {
"defaults": {
"model": {
"primary": "vllm/sunkencity/qwen25-3b-openclaw"
}
}
}
}
```
LocalClaw will route tool-calling tasks to this model automatically via the three-tier routing system.
## Python Usage (mlx-lm)
```python
from mlx_lm import load, generate
model, tokenizer = load("sunkencity/qwen25-3b-openclaw")
messages = [
{
"role": "system",
"content": (
"You are a function calling AI model.\n\n"
"\n"
'{"type": "function", "function": {"name": "get_weather", '
'"description": "Get current weather", "parameters": {"type": "object", '
'"properties": {"location": {"type": "string"}}, "required": ["location"]}}}\n'
"\n\n"
"For each function call return a json object within tags."
),
},
{"role": "user", "content": "What is the weather in San Francisco?"},
]
prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
response = generate(model, tokenizer, prompt=prompt, max_tokens=256, verbose=False)
print(response)
#
# {"name": "get_weather", "arguments": {"location": "San Francisco"}}
#
```
## Training Details
**Datasets:**
- [NousResearch/hermes-function-calling-v1](https://huggingface.co/datasets/NousResearch/hermes-function-calling-v1) — 1,883 examples, already in `` format
- [glaiveai/glaive-function-calling-v2](https://huggingface.co/datasets/glaiveai/glaive-function-calling-v2) — 55,000 examples converted from `` format
**Preprocessing:**
- Conversations truncated to the first tool-call turn (system + user + assistant) to ensure tool call output is always within the sequence budget
- `` → `` normalization including balanced-brace extraction and single-quoted argument repair
- 90/5/5 train/valid/eval split
**LoRA config:**
```yaml
fine_tune_type: lora
num_layers: 32 # all transformer layers
lora_parameters:
rank: 16
alpha: 32
dropout: 0.0
scale: 10.0
optimizer: adamw
learning_rate: 2e-4
batch_size: 4
iters: 600
max_seq_length: 2048
mask_prompt: true # loss only on assistant turns
grad_checkpoint: true
```
**Hardware:** Apple M4 Max (128 GB unified memory), ~34 minutes wall-clock
## Training Code
Training was performed using the [tool-tuner](https://github.com/sunkencity/tool-tuner) framework — an autoresearch-inspired autonomous LoRA experiment loop built with mlx-lm.
## License
Apache 2.0 — same as base model.