Instructions to use prithivMLmods/Bootes-Qwen3_Coder-Reasoning with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use prithivMLmods/Bootes-Qwen3_Coder-Reasoning with Transformers:

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

pipe = pipeline("text-generation", model="prithivMLmods/Bootes-Qwen3_Coder-Reasoning")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("prithivMLmods/Bootes-Qwen3_Coder-Reasoning")
model = AutoModelForCausalLM.from_pretrained("prithivMLmods/Bootes-Qwen3_Coder-Reasoning", 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 prithivMLmods/Bootes-Qwen3_Coder-Reasoning with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/prithivMLmods/Bootes-Qwen3_Coder-Reasoning

SGLang

How to use prithivMLmods/Bootes-Qwen3_Coder-Reasoning 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 "prithivMLmods/Bootes-Qwen3_Coder-Reasoning" \
    --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": "prithivMLmods/Bootes-Qwen3_Coder-Reasoning",
		"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 "prithivMLmods/Bootes-Qwen3_Coder-Reasoning" \
        --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": "prithivMLmods/Bootes-Qwen3_Coder-Reasoning",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use prithivMLmods/Bootes-Qwen3_Coder-Reasoning with Docker Model Runner:
```
docker model run hf.co/prithivMLmods/Bootes-Qwen3_Coder-Reasoning
```

Bootes-Qwen3_Coder-Reasoning / README.md

prithivMLmods

Update README.md

f201c81 verified 12 months ago

preview code

Raw

History Blame Contribute Delete

4.18 kB

	---
	license: apache-2.0
	base_model:
	- prithivMLmods/Qwen3-4B-ft-bf16
	datasets:
	- nvidia/OpenCodeReasoning
	- efficientscaling/Z1-Code-Reasoning-107K
	- HuggingFaceH4/CodeAlpaca_20K
	- mlabonne/FineTome-100k
	language:
	- en
	pipeline_tag: text-generation
	library_name: transformers
	tags:
	- moe
	- text-generation-inference
	- code
	- math
	- mot
	- coder
	- stem
	- trl
	---

	![1.png](https://cdn-uploads.huggingface.co/production/uploads/65bb837dbfb878f46c77de4c/ftS9pbo7aFJ6yvsqrr6Ua.png)

	# Bootes-Qwen3\_Coder-Reasoning

	> Bootes-Qwen3\_Coder-Reasoning is a fine-tuned variant of the Qwen3-4B architecture, optimized for high-accuracy code reasoning and structured logical task completion. Trained on the CodeAlpaca\_20K dataset and additional curated programming corpora, this model is designed to perform technical coding, reasoning, and instruction-following tasks with lightweight computational requirements.

	> [!note]
	GGUF : https://huggingface.co/prithivMLmods/Bootes-Qwen3_Coder-Reasoning-Q4_K_M-GGUF

	## Key Features

	1. Code Reasoning with CodeAlpaca\_20K and More
	Fine-tuned on CodeAlpaca\_20K and supplementary high-quality datasets focused on:

	* Multi-language programming tasks
	* Code explanation, completion, and debugging
	* Instruction-following with step-wise execution logic

	2. Cross-Language Code Understanding
	Handles Python, JavaScript, C++, and more. Ideal for code generation, transformation, bug-fixing, and logic validation.

	3. Structured Output Generation
	Delivers responses in Markdown, JSON, YAML, and structured code blocks. Optimized for IDE workflows, documentation tools, and reproducible computation notebooks.

	4. Instruction-Tuned for Developer Use Cases
	Maintains strong fidelity to user prompts, especially multi-turn or step-by-step technical instructions across engineering and data workflows.

	5. Multilingual Reasoning in Technical Domains
	Capable of technical comprehension and explanation in over 20 human languages, supporting global developer audiences.

	6. Efficient 4B Architecture
	Based on Qwen3-4B for a performance-efficient inference model that scales well on mid-range GPUs and cloud deployment setups.

	## Quickstart with Transformers🤗

	```python
	from transformers import AutoModelForCausalLM, AutoTokenizer

	model_name = "prithivMLmods/Bootes-Qwen3_Coder-Reasoning"

	model = AutoModelForCausalLM.from_pretrained(
	model_name,
	torch_dtype="auto",
	device_map="auto"
	)
	tokenizer = AutoTokenizer.from_pretrained(model_name)

	prompt = "Write a Python function to check whether a number is a palindrome. Explain each step."

	messages = [
	{"role": "system", "content": "You are a precise coding and reasoning assistant trained on CodeAlpaca and developer datasets."},
	{"role": "user", "content": prompt}
	]

	text = tokenizer.apply_chat_template(
	messages,
	tokenize=False,
	add_generation_prompt=True
	)

	model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

	generated_ids = model.generate(
	**model_inputs,
	max_new_tokens=512
	)
	generated_ids = [
	output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
	]

	response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
	print(response)
	```

	## Intended Use

	* Code generation, completion, and explanation
	* Multi-step algorithmic reasoning
	* Structured technical document generation (Markdown, JSON, YAML)
	* Debugging assistance and refactoring suggestions
	* Technical tutoring and developer assistant workflows
	* Cross-lingual programming education and translation

	## Limitations

	* May underperform on non-code-related creative writing
	* Limited context window versus larger models
	* Sensitive to prompt phrasing for ambiguous instructions
	* Occasionally over-justifies code when brevity is desired

	## References

	1. Qwen2.5 Technical Report – [https://arxiv.org/pdf/2412.15115](https://arxiv.org/pdf/2412.15115)
	2. CodeAlpaca Dataset – [https://github.com/sahil280114/codealpaca](https://github.com/sahil280114/codealpaca)
	3. YaRN: Context Window Extension for LLMs – [https://arxiv.org/pdf/2309.00071](https://arxiv.org/pdf/2309.00071)