Instructions to use joelauge/RecourseLLM_Q0.6b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use joelauge/RecourseLLM_Q0.6b with Transformers:

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

pipe = pipeline("text-generation", model="joelauge/RecourseLLM_Q0.6b")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("joelauge/RecourseLLM_Q0.6b")
model = AutoModelForCausalLM.from_pretrained("joelauge/RecourseLLM_Q0.6b", device_map="auto")
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]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use joelauge/RecourseLLM_Q0.6b with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/joelauge/RecourseLLM_Q0.6b

SGLang

How to use joelauge/RecourseLLM_Q0.6b 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 "joelauge/RecourseLLM_Q0.6b" \
    --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": "joelauge/RecourseLLM_Q0.6b",
		"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 "joelauge/RecourseLLM_Q0.6b" \
        --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": "joelauge/RecourseLLM_Q0.6b",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

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

RecourseLLM-Optimized Qwen3-0.6B

This model is a derivative of Qwen/Qwen3-0.6B, licensed under Apache 2.0.
Original model by the Qwen Team. See license and attribution below.

About RecourseLLM

RecourseLLM is focused on Token Optimization — enabling developers, enterprises, and AI systems to:

Analyze token usage efficiency
Reduce inference cost per task
Improve reasoning-to-output compression ratios
Benchmark thinking vs non-thinking tradeoffs
Optimize prompt-to-token efficiency
Measure token utilization during agentic workflows
Improve cost-performance alignment in LLM deployments

This fork has been adapted to support advanced token optimization research and applied analysis workflows.

What Has Been Modified

This derivative version of Qwen3-0.6B has been adapted for:

Token usage instrumentation
Output length analysis
Think-block efficiency benchmarking
Prompt compression experimentation
Response-token density measurement
Cost-performance optimization experiments
Structured token logging compatibility

No architectural claims are made beyond those of the original Qwen3-0.6B base model. Core weights originate from the Apache-licensed base model.

Purpose of This Fork

This fork is intended for:

Token efficiency benchmarking
Prompt engineering optimization
Inference cost reduction experiments
Agent workflow token analysis
Research into reasoning verbosity vs outcome accuracy
SaaS cost control modeling

The focus is not on altering model capabilities, but on optimizing and analyzing how tokens are generated and consumed.

Base Model Attribution

This model is based on:

Qwen3-0.6B

License: Apache 2.0
Authors: Qwen Team
Original Repository: https://huggingface.co/Qwen/Qwen3-0.6B

Please see the original license here:
https://huggingface.co/Qwen/Qwen3-0.6B/blob/main/LICENSE

All original copyrights and license terms remain in effect.

Model Overview (Inherited from Qwen3-0.6B)

Type: Causal Language Model
Parameters: 0.6B
Non-Embedding Parameters: 0.44B
Layers: 28
Attention Heads (GQA): 16 Q / 8 KV
Context Length: 32,768
Training Stage: Pretraining & Post-training

For full architectural details, please refer to the original Qwen documentation:

Blog: https://qwenlm.github.io/blog/qwen3/
GitHub: https://github.com/QwenLM/Qwen3
Docs: https://qwen.readthedocs.io/en/latest/

Token Optimization Analysis Capabilities

This fork enables:

1️ Think vs Non-Think Efficiency Comparison

Measure:

Reasoning token overhead
Final answer compression ratio
Token-to-accuracy delta
Marginal token cost per reasoning step

2️ Token Density Profiling

Analyze:

Tokens per semantic unit
Redundancy rate
Repetition metrics
Cost-per-response benchmarks
Verbosity distribution

3️ Cost Modeling

Supports:

Per-request cost estimation
Token budget simulation
Inference efficiency tuning
Throughput-to-token modeling
Agent loop token amplification analysis

4️ Prompt Compression Experiments

Evaluate:

Minimal prompt vs verbose prompt performance
System prompt token footprint
Multi-turn token growth
Prompt entropy vs output quality

Intended Use

This model is intended for:

AI cost optimization research
Enterprise LLM deployment analysis
Prompt efficiency benchmarking
Agent pipeline token diagnostics
Controlled inference environments

It is not intended as a drop-in production conversational system without further tuning.

Licensing

This repository includes Apache 2.0 licensed components from the original Qwen3-0.6B model.

Your use of this model must comply with the Apache 2.0 License.

Additional modifications introduced by RecourseLLM are distributed in compliance with Apache 2.0 and may include additional usage terms where applicable.

Citation

If you find the original Qwen3 work helpful, please cite:

@misc{qwen3technicalreport,
  title={Qwen3 Technical Report},
  author={Qwen Team},
  year={2025},
  eprint={2505.09388},
  archivePrefix={arXiv},
  primaryClass={cs.CL},
  url={https://arxiv.org/abs/2505.09388}
}