Instructions to use Loom-Labs/Apollo-1-2B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Loom-Labs/Apollo-1-2B with Transformers:

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

pipe = pipeline("text-generation", model="Loom-Labs/Apollo-1-2B")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Loom-Labs/Apollo-1-2B")
model = AutoModelForCausalLM.from_pretrained("Loom-Labs/Apollo-1-2B")
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]:]))

Inference
Notebooks
Google Colab
Kaggle
Local Apps

vLLM

How to use Loom-Labs/Apollo-1-2B with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/Loom-Labs/Apollo-1-2B

SGLang

How to use Loom-Labs/Apollo-1-2B 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 "Loom-Labs/Apollo-1-2B" \
    --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": "Loom-Labs/Apollo-1-2B",
		"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 "Loom-Labs/Apollo-1-2B" \
        --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": "Loom-Labs/Apollo-1-2B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Unsloth Studio new

How to use Loom-Labs/Apollo-1-2B with Unsloth Studio:

Install Unsloth Studio (macOS, Linux, WSL)

curl -fsSL https://unsloth.ai/install.sh | sh
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for Loom-Labs/Apollo-1-2B to start chatting

Install Unsloth Studio (Windows)

irm https://unsloth.ai/install.ps1 | iex
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for Loom-Labs/Apollo-1-2B to start chatting

Using HuggingFace Spaces for Unsloth

# No setup required
# Open https://huggingface.co/spaces/unsloth/studio in your browser
# Search for Loom-Labs/Apollo-1-2B to start chatting

Load model with FastModel

pip install unsloth
from unsloth import FastModel
model, tokenizer = FastModel.from_pretrained(
    model_name="Loom-Labs/Apollo-1-2B",
    max_seq_length=2048,
)

Docker Model Runner
How to use Loom-Labs/Apollo-1-2B with Docker Model Runner:
```
docker model run hf.co/Loom-Labs/Apollo-1-2B
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

Apollo-1-2B

Apollo-1-2B is a 2 billion parameter instruction-tuned model developed by Noema Research.
It is based on Qwen3-1.7B and optimized for general reasoning, language understanding, and lightweight deployment.

This model is the first release in the Apollo series, intended as a foundation for scalable experimentation and real-world applications in constrained environments.

Model Overview

Base model: Qwen3-1.7B
Architecture: Decoder-only transformer
Parameters: ~2B
Context length: up to 32k tokens (inherits Qwen3 long-context support)
Domain: General-purpose reasoning and instruction following
Primary applications:
- Conversational AI
- Lightweight reasoning tasks
- Education and tutoring
- Prototype agents and assistants
License: anvdl-1.0

Key Features

Instruction tuned: More reliable responses in conversational and task-oriented settings
Lightweight deployment: Optimized for environments with limited compute or memory resources
Extended context: Inherits long-context capability from Qwen3 base
Balanced outputs: Improved refusal behaviors and reduced hallucinations compared to the base model
Multilingual ability: Retains multilingual knowledge from Qwen3 family

Usage

The model is available in Hugging Face Transformers format. Example:

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "NoemaResearch/Apollo-1-2B"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

messages = [
    {"role":"system", "content":"You are Apollo, a reasoning assistant."},
    {"role":"user", "content":"Explain the difference between supervised and unsupervised learning."}
]

inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.7, top_p=0.9)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Recommended settings:

temperature=0.5–0.9
top_p=0.85–0.95
For structured outputs (e.g. JSON), use lower temperatures for stability

Evaluation

Apollo-1-2B has been evaluated internally on a range of reasoning and language tasks. Key findings:

Improved instruction following relative to Qwen3-1.7B
More concise and accurate responses in structured tasks
Maintains multilingual performance from the base model
Effective for lightweight assistant applications

Future work will include publishing comprehensive benchmark comparisons against other models in the 1–3B parameter range.

Limitations

Reasoning depth: As a 2B parameter model, Apollo cannot match larger-scale LLMs on complex reasoning tasks
Knowledge coverage: May lack depth in specialized or low-resource domains
Hallucinations: Although reduced, the model may still generate incorrect or fabricated information
Sensitivity to prompts: Outputs vary with prompt phrasing; careful prompt design recommended

Responsible Use

Do not rely on Apollo for critical decision-making without human oversight
Generated outputs may contain inaccuracies; verification is required for factual or sensitive use cases
Avoid providing personal, private, or sensitive information in prompts
This model should not be used to generate disallowed, unsafe, or harmful content

Model Variants

Full precision (safetensors) — research and full-fidelity inference
bf16 / fp16 — optimized for inference on GPUs/TPUs
Quantized versions (int8 / int4) — for deployment in constrained hardware environments

Citation

If you use this model, please cite both Apollo-1-2B and the Qwen3 base model:

@misc{noema2025apollo,
  title={Apollo-1-2B},
  author={Noema Research},
  year={2025},
  howpublished={\url{https://huggingface.co/NoemaResearch/Apollo-1-2B}}
}

Acknowledgements

Apollo-1-2B builds upon the Qwen3 series of models. We thank the Qwen team for making their work openly available under permissive terms, which enabled this derivative research.