Instructions to use 169Pi/Alpie_seed with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use 169Pi/Alpie_seed with Transformers:

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

pipe = pipeline("image-text-to-text", model="169Pi/Alpie_seed")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("169Pi/Alpie_seed")
model = AutoModelForMultimodalLM.from_pretrained("169Pi/Alpie_seed", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.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=256)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use 169Pi/Alpie_seed with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "169Pi/Alpie_seed"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "169Pi/Alpie_seed",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/169Pi/Alpie_seed

SGLang

How to use 169Pi/Alpie_seed 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 "169Pi/Alpie_seed" \
    --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": "169Pi/Alpie_seed",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

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 "169Pi/Alpie_seed" \
        --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": "169Pi/Alpie_seed",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use 169Pi/Alpie_seed with Docker Model Runner:
```
docker model run hf.co/169Pi/Alpie_seed
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

🌱 Alpie Seed 9B

A 9B open-weight vision-language model for reasoning, coding, and multimodal understanding.

A short demo of Alpie Seed running fully offline on a mobile device, tested on PocketPal. It shows the quantized model generating responses on-device with no cloud connection.

▶️ Watch the demo video

📄 Technical Report

The Alpie Seed Technical Report documents the model in detail: lineage and architecture, the SFT and GRPO post-training pipeline, reward design, quantization and inference profiling, offline results on real devices (desktop GPU, Apple Silicon, mobile, and CPU-only), benchmark results across reasoning, coding, multimodal, and Indic-language tasks, safety evaluation, and limitations.

Get Alpie Seed

Alpie Seed 9B is a multimodal model developed by 169Pi AI, built on the Qwen3.5-9B architecture and post-trained to strengthen reasoning, instruction following, coding, and visual understanding. It brings together text, image, and video understanding with a 262K context window and multiple quantized formats for deployment across different hardware.

Alpie Seed Highlights

Unified vision-language model: text, image, and video input on the Qwen3.5-9B architecture.
Reasoning and coding: post-trained with supervised fine-tuning and GRPO; supports thinking and non-thinking modes.
262K native context for long documents and extended conversations.
Flexible deployment: FP16 weights plus 2-bit, 3-bit, and 4-bit GGUF builds.
Open license: Apache 2.0.

Available On

Platform	Link
Hugging Face (GGUF)	169Pi/Alpie_Seed_GGUF
Ollama	ollama.com/169pi/alpie-seed
Kaggle	kaggle.com/models/alpie/alpie-seed-9b

Ollama

Run Alpie Seed directly from the Ollama library:

ollama run 169pi/alpie-seed

Available tags:

Name	Size	Context	Input
`alpie-seed:latest`	5.6 GB	256K	Text
`alpie-seed:q2`	3.8 GB	256K	Text
`alpie-seed:q3`	4.6 GB	256K	Text
`alpie-seed:vision`	6.6 GB	256K	Text, Image

To run a specific tag:

ollama run 169pi/alpie-seed:q2
ollama run 169pi/alpie-seed:vision

Kaggle

Alpie Seed 9B is available on Kaggle Models: https://www.kaggle.com/models/alpie/alpie-seed-9b

Model Overview

Type: Causal Language Model with Vision Encoder
Training Stage: Post-training (SFT + GRPO) on Qwen3.5-9B
Language Model
- Number of Parameters: 9B
- Hidden Dimension: 4096
- Token Embedding: 248320 (Padded)
- Number of Layers: 32
- Hidden Layout: 8 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN))
- Gated DeltaNet:
  - Number of Linear Attention Heads: 32 for V and 16 for QK
  - Head Dimension: 128
- Gated Attention:
  - Number of Attention Heads: 16 for Q and 4 for KV
  - Head Dimension: 256
  - Rotary Position Embedding Dimension: 64
- Feed Forward Network:
  - Intermediate Dimension: 12288
- LM Output: 248320 (Padded)
- MTP: trained with multi-steps
Vision Encoder: 27-layer Vision Transformer
Context Length: 262,144 tokens

The architecture is retained from Qwen3.5-9B; Alpie Seed's adaptation is carried out through post-training rather than a structural redesign.

Training

Alpie Seed uses a two-stage post-training pipeline.

Supervised fine-tuning (SFT): a DORA adapter is trained to improve instruction following, response quality, and task performance.
Group Relative Policy Optimization (GRPO): a trainable DoRA adapter is optimized while the SFT adapter is kept as a frozen reference policy. The GRPO stage uses a 4-bit NF4 base with double quantization and BF16 computation, and the trained adapter is merged into the base model at its original precision for release.

Benchmark Results

Evaluation Settings Note: All benchmarks were evaluated with extended thinking enabled (enable_thinking: true), a maximum generation length of max_tokens: 65536, and temperature: 0.0.

Alpie Seed scores are from the FP16 model and do not apply to the 2-bit, 3-bit, or 4-bit variants. Bold indicates the best score in each row. Comparison-model scores are taken from published model cards and reports (including the Qwen3.5-9B model card).

Language

Benchmark	Qwen3.5 9B	Gemma 4 12B	Ministral 3 8B	GPT-OSS 20B	Sarvam 30B	Nemotron 3.5 Lightning	Alpie Seed 9B
Knowledge & STEM
MMLU	--	--	76.1	85.3	85.1	78.63	87.30
MMLU-Pro	82.5	77.2	75.00	77.2	80.0	81.94	82.54
GPQA Diamond	81.7	78.8	38.6	71.5	66.5	75.44	84.32
Mathematics
AIME 2026	69.4	77.5	--	--	--	--	83.33
Coding & Software Engineering
LiveCodeBench v6	65.6	72.0	61.6	61.0	70.0	--	72.99
SWE-Bench Verified	60.0	52.0	--	60.7	34.0	51.56	61.20

Vision Language

Benchmark	GPT-5-Nano 2025-08-07	Gemini-2.5 Flash-Lite	Qwen3-VL 30B-A3B	Qwen3.5 9B	Gemma 4 12B	Alpie Seed 9B
STEM and Puzzle
MMMU-Pro	57.2	59.7	63.0	70.1	69.1	68.70
MathVision	62.2	52.1	65.7	78.9	79.7	76.76
General VQA
RealWorldQA	71.8	72.2	77.4	80.3	--	80.39
MMStar	68.6	69.1	75.5	79.7	--	78.87
HallusionBench	58.4	64.5	66.0	69.3	--	79.88
Text Recognition & Document Understanding
OCRBench	75.3	82.5	83.9	89.2	--	90.30

SWE-Bench Verified: resolved rate using Mini-SWE-agent, with retries disabled.
Comparison-model scores were not re-run by 169Pi, and harnesses, prompts, and benchmark versions differ, so cross-model comparisons are indicative rather than strictly like-for-like. Scores vary with dataset versions, prompts, evaluation harnesses, and inference settings.
Empty cells (--) indicate scores not yet available or not applicable.
Sources: Ministral 3 8B model card, NVIDIA Nemotron 3.5 Lightning evaluation, Qwen3.5-9B model card, Gemma 4 model card, GPT-OSS evaluation, and Sarvam-30B model card.

Quickstart

Install dependencies

Alpie Seed support requires a recent Transformers release (Transformers 5 or later).

pip install -U "transformers>=5.2.0" torch torchvision pillow accelerate

Serve with vLLM (OpenAI-compatible API)

Start the standard Alpie Seed 9B server:

vllm serve 169Pi/Alpie_seed \
  --port 8000 \
  --max-model-len 262144 \
  --reasoning-parser qwen3

To enable automatic tool-call parsing, use this command instead:

vllm serve 169Pi/Alpie_seed \
  --port 8000 \
  --max-model-len 262144 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder

The API is available at http://localhost:8000/v1. The tool-calling options enable vLLM to parse model-generated tool calls; your application is still responsible for executing the requested tools and returning their results.

Run with Transformers

The following examples load the full vision-language checkpoint using AutoModelForImageTextToText and AutoProcessor. They retain the model's multimodal architecture. The enable_thinking argument is passed to the chat template to select the response mode.

1. Thinking mode (`enable_thinking=True`)

import torch
from transformers import AutoModelForImageTextToText, AutoProcessor

MODEL_ID = "169Pi/Alpie_seed"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForImageTextToText.from_pretrained(
    MODEL_ID,
    torch_dtype="auto",
    device_map="auto",
)
model.eval()

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Explain why the sky appears blue."}
        ],
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    enable_thinking=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

with torch.inference_mode():
    output_ids = model.generate(
        **inputs,
        max_new_tokens=4096,
        do_sample=True,
        temperature=0.7,
        top_p=0.8,
    )

new_tokens = output_ids[0, inputs["input_ids"].shape[1]:]
response = processor.decode(new_tokens, skip_special_tokens=True)
print(response)

2. Non-thinking mode (`enable_thinking=False`)

import torch
from transformers import AutoModelForImageTextToText, AutoProcessor

MODEL_ID = "169Pi/Alpie_seed"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForImageTextToText.from_pretrained(
    MODEL_ID,
    torch_dtype="auto",
    device_map="auto",
)
model.eval()

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Explain why the sky appears blue in two sentences."}
        ],
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    enable_thinking=False,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

with torch.inference_mode():
    output_ids = model.generate(
        **inputs,
        max_new_tokens=512,
        do_sample=True,
        temperature=0.7,
        top_p=0.8,
    )

new_tokens = output_ids[0, inputs["input_ids"].shape[1]:]
response = processor.decode(new_tokens, skip_special_tokens=True)
print(response)

3. Tool calling with Transformers

Transformers can format the available tool definitions into the prompt. The model generates a tool-call request; your application must parse the request, execute the corresponding function, append the tool result, and ask the model to continue. This example demonstrates generating and inspecting a tool call; it does not execute external tools automatically.

import json
import torch
from transformers import AutoModelForImageTextToText, AutoProcessor

MODEL_ID = "169Pi/Alpie_seed"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForImageTextToText.from_pretrained(
    MODEL_ID,
    torch_dtype="auto",
    device_map="auto",
)
model.eval()

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "The city to check.",
                    }
                },
                "required": ["city"],
            },
        },
    }
]

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "What is the weather like in Patna?"}
        ],
    }
]

inputs = processor.apply_chat_template(
    messages,
    tools=tools,
    tokenize=True,
    add_generation_prompt=True,
    enable_thinking=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

with torch.inference_mode():
    output_ids = model.generate(
        **inputs,
        max_new_tokens=1024,
        do_sample=True,
        temperature=0.7,
        top_p=0.8,
    )

new_tokens = output_ids[0, inputs["input_ids"].shape[1]:]
generated_text = processor.decode(new_tokens, skip_special_tokens=False)
print("Model output:")
print(generated_text)

# Tool execution is application-side. Inspect the generated tool-call
# structure, validate its arguments, and dispatch only to tools you trust.

For image or video inputs, provide the corresponding image/video content items in the user message and use the same AutoProcessor + AutoModelForImageTextToText loading pattern. See the upstream Qwen3.5 documentation for multimodal message examples and framework-specific details.

Citation

If you use Alpie Seed 9B in your work, please cite:

@misc{alpie_seed_9b_2026,
  title        = {Alpie Seed 9B},
  author       = {{169Pi AI}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/169Pi/Alpie_seed}}
}

Downloads last month: 64

Safetensors

Model size

9B params

Tensor type

BF16

Model tree for 169Pi/Alpie_seed

Base model

Qwen/Qwen3.5-9B-Base

Finetuned

Qwen/Qwen3.5-9B