Instructions to use Open4bits/granite-4.0-micro-mlx-3Bit with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Open4bits/granite-4.0-micro-mlx-3Bit with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="Open4bits/granite-4.0-micro-mlx-3Bit")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Open4bits/granite-4.0-micro-mlx-3Bit")
model = AutoModelForCausalLM.from_pretrained("Open4bits/granite-4.0-micro-mlx-3Bit")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

MLX

How to use Open4bits/granite-4.0-micro-mlx-3Bit with MLX:

# Make sure mlx-lm is installed
# pip install --upgrade mlx-lm

# Generate text with mlx-lm
from mlx_lm import load, generate

model, tokenizer = load("Open4bits/granite-4.0-micro-mlx-3Bit")

prompt = "Write a story about Einstein"
messages = [{"role": "user", "content": prompt}]
prompt = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True
)

text = generate(model, tokenizer, prompt=prompt, verbose=True)

Notebooks
Google Colab
Kaggle
Local Apps
LM Studio

vLLM

How to use Open4bits/granite-4.0-micro-mlx-3Bit with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Open4bits/granite-4.0-micro-mlx-3Bit"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Open4bits/granite-4.0-micro-mlx-3Bit",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/Open4bits/granite-4.0-micro-mlx-3Bit

SGLang

How to use Open4bits/granite-4.0-micro-mlx-3Bit with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Open4bits/granite-4.0-micro-mlx-3Bit" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Open4bits/granite-4.0-micro-mlx-3Bit",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Open4bits/granite-4.0-micro-mlx-3Bit" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Open4bits/granite-4.0-micro-mlx-3Bit",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Pi new

How to use Open4bits/granite-4.0-micro-mlx-3Bit with Pi:

Start the MLX server

# Install MLX LM:
uv tool install mlx-lm
# Start a local OpenAI-compatible server:
mlx_lm.server --model "Open4bits/granite-4.0-micro-mlx-3Bit"

Configure the model in Pi

# Install Pi:
npm install -g @mariozechner/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "mlx-lm": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "Open4bits/granite-4.0-micro-mlx-3Bit"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Hermes Agent new

How to use Open4bits/granite-4.0-micro-mlx-3Bit with Hermes Agent:

Start the MLX server

# Install MLX LM:
uv tool install mlx-lm
# Start a local OpenAI-compatible server:
mlx_lm.server --model "Open4bits/granite-4.0-micro-mlx-3Bit"

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default Open4bits/granite-4.0-micro-mlx-3Bit

Run Hermes

hermes

MLX LM

How to use Open4bits/granite-4.0-micro-mlx-3Bit with MLX LM:

Generate or start a chat session

# Install MLX LM
uv tool install mlx-lm
# Interactive chat REPL
mlx_lm.chat --model "Open4bits/granite-4.0-micro-mlx-3Bit"

Run an OpenAI-compatible server

# Install MLX LM
uv tool install mlx-lm
# Start the server
mlx_lm.server --model "Open4bits/granite-4.0-micro-mlx-3Bit"
# Calling the OpenAI-compatible server with curl
curl -X POST "http://localhost:8000/v1/chat/completions" \
   -H "Content-Type: application/json" \
   --data '{
     "model": "Open4bits/granite-4.0-micro-mlx-3Bit",
     "messages": [
       {"role": "user", "content": "Hello"}
     ]
   }'

Docker Model Runner
How to use Open4bits/granite-4.0-micro-mlx-3Bit with Docker Model Runner:
```
docker model run hf.co/Open4bits/granite-4.0-micro-mlx-3Bit
```

Open4bits / Granite-4.0-Micro-MLX-3Bit

This repository provides the Granite-4.0 Micro model quantized to 3-bit in MLX format, published by Open4bits to enable efficient local inference with low memory usage and broad hardware compatibility.

The underlying Granite-4.0 model and architecture are developed and owned by their original authors. This repository contains only a 3-bit quantized MLX conversion of the original model weights.

The model is designed for lightweight, high-performance text generation and instruction-following tasks, making it suitable for local and resource-constrained environments.

Open4bits has started supporting MLX models to broaden compatibility with emerging quantization formats and efficient runtimes.

Model Overview

Granite-4.0 Micro is a compact variant of the Granite-4.0 architecture optimized for efficient inference and lower resource footprints. This release provides a 3-bit quantized checkpoint in MLX format, enabling fast inference on CPUs and supported accelerators with reduced memory demands.

Model Details

Base Model: Granite-4.0
Variant: Micro
Quantization: 3-bit
Format: MLX
Task: Text generation, instruction following
Weight tying: Preserved
Compatibility: MLX-enabled inference engines and supported runtimes

This quantized format balances inference performance with lower resource requirements while preserving core architectural design.

Intended Use

This model is intended for:

Local text generation and chat applications
CPU-based or resource-efficient deployments
Research, experimentation, and prototyping
Offline or self-hosted AI systems

Limitations

Reduced performance compared to full-precision variants
Output quality depends on prompt engineering and inference settings
Not fine-tuned for highly domain-specific tasks

License

This model follows the Apache licence 2.0 of the base Granite-4.0 model. Users must comply with the licensing conditions defined by the original creators.

Support

If you find this model useful, please consider supporting the project. Your support encourages Open4bits to continue releasing and maintaining efficient open models for the community.

Downloads last month: 26

Safetensors

Model size

0.4B params

Tensor type

BF16

U32

MLX

Hardware compatibility

3-bit

Model tree for Open4bits/granite-4.0-micro-mlx-3Bit

Base model

ibm-granite/granite-4.0-micro

Quantized

(24)

this model