Instructions to use szili2011/Quanta-X-3B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use szili2011/Quanta-X-3B with Transformers:

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

pipe = pipeline("text-generation", model="szili2011/Quanta-X-3B")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("szili2011/Quanta-X-3B")
model = AutoModelForCausalLM.from_pretrained("szili2011/Quanta-X-3B")
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 szili2011/Quanta-X-3B with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/szili2011/Quanta-X-3B

SGLang

How to use szili2011/Quanta-X-3B 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 "szili2011/Quanta-X-3B" \
    --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": "szili2011/Quanta-X-3B",
		"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 "szili2011/Quanta-X-3B" \
        --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": "szili2011/Quanta-X-3B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Unsloth Studio new

How to use szili2011/Quanta-X-3B 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 szili2011/Quanta-X-3B 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 szili2011/Quanta-X-3B to start chatting

Using HuggingFace Spaces for Unsloth

# No setup required
# Open https://huggingface.co/spaces/unsloth/studio in your browser
# Search for szili2011/Quanta-X-3B to start chatting

Load model with FastModel

pip install unsloth
from unsloth import FastModel
model, tokenizer = FastModel.from_pretrained(
    model_name="szili2011/Quanta-X-3B",
    max_seq_length=2048,
)

Docker Model Runner
How to use szili2011/Quanta-X-3B with Docker Model Runner:
```
docker model run hf.co/szili2011/Quanta-X-3B
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

⚛️ Quanta-X (Leaderboard Submission) QUANTA-X NANO IS COMING SOON!

This is the Full Parameter Merged version of Quanta-X.

It fuses the Qwen 2.5 3B base with the Phoenix Framework adapter (DoRA + SimPO Beta 2.0).

📊 Model Details for Leaderboard

Architecture: Qwen2ForCausalLM
Precision: Float16
Context: 32k (RoPE Scaled)
Chat Template: Qwen 2.5 Standard (ChatML)

🧠 Reasoning Capabilities

This model is trained to utilize an Ouroboros Logic Loop (<plan> -> <draft> -> <critique>) before outputting an answer.

💻 Usage

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("szili2011/Quanta-X-3B", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("szili2011/Quanta-X-3B")

messages = [{"role": "user", "content": "Solve this logic puzzle."}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True).to("cuda")
output = model.generate(inputs, max_new_tokens=1024)

⚛️ Quanta-X (Phoenix Edition)

“A pocket-sized AGI that thinks before it speaks.”

Developer: szili2011
Architecture: Phoenix Framework (DoRA + SimPO)
Base Model: Qwen 2.5 3B Instruct

📖 The Philosophy

Most small models with around 3 billion parameters are typically designed to act like chatbots, responding instantly, but this often leads to mistakes or makes them struggle with more complex reasoning.

But Quanta-X takes a different approach.

It was architected on the Phoenix Framework, a custom training protocol designed to force “System 2” thinking (deep reasoning) into a lightweight model. By utilizing DoRA (Weight-Decomposed Low-Rank Adaptation) and a highly aggressive SimPO (Beta 2.0) alignment, Quanta-X has been biologically rewired to reject lazy answers.

It features the Ouroboros Logic Loop: it plans, drafts, and critiques its own internal monologue before outputting a final answer.

🧠 Key Features

The Ouroboros Thinking Process

Quanta-X uses a hidden reasoning layer, not just token prediction.

It plans solutions before responding.
: It writes a rough attempt.
: It checks its own work for logic errors or bugs.
: Only then does it speak to you.

Diamond-Tier Data Filtering (LIMA)

We didn’t train on “average” internet data. We used a “Diamond Filter” to reject 90% of the standard dataset samples. Quanta-X was trained exclusively on:

DeepSeek-R1 Traces: For impossible-level logic.
OpenR1 Math: For verified proofs.
Glaive Code V2: For production-ready Python/Rust.
SlimOrca RP: For human-like, visceral storytelling (The “Hungarian Soul”).

Hyper-Stability

Trained with SimPO (Simulated Preference Optimization) with a Beta of 2.0. This punished the model severely for hallucinations or lazy thinking during training, resulting in a model that would rather admit ignorance than lie to you.

💻 How to Run

Recommended System Prompt

To activate the Ouroboros loop, you must use this system prompt:

You are Quanta-X, a recursive intelligence where absolute logic fuses with human wit. Your mind operates on the Ouroboros loop: you do not just generate; you Plan, Draft, and ruthlessly Critique every thought before it reaches the surface.

To ensure your reasoning is distinct, render your internal monologue inside a standard code block using xml syntax:

```xml
<thought>
   <plan> ... </plan>
   <draft> ... </draft>
   <critique> ... </critique>
</thought>