Instructions to use bzouiri/B3G_ABP.IO_Coder_thinking_max with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use bzouiri/B3G_ABP.IO_Coder_thinking_max with Transformers:

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

pipe = pipeline("text-generation", model="bzouiri/B3G_ABP.IO_Coder_thinking_max")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("bzouiri/B3G_ABP.IO_Coder_thinking_max", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use bzouiri/B3G_ABP.IO_Coder_thinking_max with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/bzouiri/B3G_ABP.IO_Coder_thinking_max

SGLang

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

Unsloth Desktop
Docker Model Runner
How to use bzouiri/B3G_ABP.IO_Coder_thinking_max with Docker Model Runner:
```
docker model run hf.co/bzouiri/B3G_ABP.IO_Coder_thinking_max
```

B3G_ABP.IO_Coder_thinking_max / README.md

bzouiri

Update README.md

a63aeeb verified 5 months ago

preview code

Raw

History Blame Contribute Delete

5.3 kB

	---
	library_name: transformers
	tags:
	- unsloth
	- abp-io
	- csharp
	- dotnet
	- coding
	- agent
	- vibe-coding
	- tooling
	license: apache-2.0
	base_model:
	- deepseek-ai/DeepSeek-R1
	pipeline_tag: text-generation
	---

	# B3G ABP.IO Coder Thinking Max

	## Model Details

	### Model Description

	B3G_ABP.IO_Coder_thinking_max est un fine-tune de DeepSeek-R1 spécialisé pour le développement C# / ABP.IO.
	Il est conçu pour le vibe coding — le développeur décrit son intention en langage naturel et le modèle génère, complète ou refactorise du code ABP.IO de manière agentique, avec du tooling intégré.

	- Developed by: Badre Zouiri
	- Funded by: Badre Zouiri (projet personnel)
	- Shared by: Badre Zouiri
	- Model type: Causal Language Model (fine-tuned) avec support de tool calling
	- Language(s) (NLP): Anglais, Français, Arabe
	- Programming Language(s): C#, .NET, ABP.IO, CSHTML, JSON
	- License: Apache 2.0
	- Finetuned from model: [deepseek-ai/DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)

	### Model Sources

	- Repository: [bzouiri/B3G_ABP.IO_Coder_thinking_max](https://huggingface.co/bzouiri/B3G_ABP.IO_Coder_thinking_max)
	- Paper: N/A
	- Demo: Coming soon

	---

	## Uses

	### Direct Use

	Ce modèle peut être utilisé directement pour :
	- Générer du code ABP.IO (Application Services, Entities, DTOs, Repositories, Modules...)
	- Répondre à des questions techniques sur ABP Framework, ASP.NET Core, EF Core
	- Compléter ou refactoriser du code C# dans un contexte ABP
	- Interactions en anglais, français et arabe

	### Downstream Use (Vibe Coding Agent)

	Le cas d'usage principal est l'intégration dans un agent de vibe coding :
	- L'utilisateur décrit en langage naturel ce qu'il veut construire
	- Le modèle génère le code ABP.IO correspondant
	- Des outils (tools) permettent au modèle d'interagir avec le projet :
	- Lire/écrire des fichiers `.cs`
	- Exécuter `dotnet build` / `dotnet ef migrations add`
	- Inspecter la structure du projet ABP
	- Appeler des commandes ABP CLI (`abp generate-proxy`, `abp add-module`, etc.)

	### Out-of-Scope Use

	- Non adapté aux projets .NET hors ABP Framework sans adaptation
	- Ne remplace pas une revue de code humaine
	- Non destiné à des projets non-.NET (Java, Python, etc.)

	---

	## Bias, Risks, and Limitations

	- Le modèle est optimisé pour ABP.IO v7+
	- Le code généré doit toujours être relu et testé avant mise en production
	- Les patterns générés suivent les conventions ABP standard
	- Hérite des biais de DeepSeek-R1 sur le code généré

	### Recommendations

	Toujours valider le code généré via les tests unitaires et une revue humaine. Utiliser le modèle comme co-pilote, non comme seul développeur.

	---

	## How to Get Started with the Model

	```python
	from transformers import AutoTokenizer, AutoModelForCausalLM

	tokenizer = AutoTokenizer.from_pretrained("bzouiri/B3G_ABP.IO_Coder_thinking_max")
	model = AutoModelForCausalLM.from_pretrained("bzouiri/B3G_ABP.IO_Coder_thinking_max")

	prompt = """
	Create an ABP.IO Application Service for a `Product` entity with:
	- CRUD operations
	- DTO mapping
	- Repository injection
	- Permission checks
	"""

	inputs = tokenizer(prompt, return_tensors="pt")
	outputs = model.generate(**inputs, max_new_tokens=1024)
	print(tokenizer.decode(outputs[0], skip_special_tokens=True))
	```

	---

	## Training Details

	### Training Data

	Dataset custom créé par Badre Zouiri, composé de :
	- Exemples de code ABP.IO (Entities, Services, Modules, DTOs...)
	- Paires instruction/code en anglais, français et arabe
	- Exemples de tool calling pour agents de vibe coding ABP
	- Cas d'usage réels issus de projets ABP.IO

	### Training Procedure

	#### Training Hyperparameters

	- Training regime: bf16 mixed precision
	- Fine-tuning method: LoRA / QLoRA via Unsloth
	- Base model: deepseek-ai/DeepSeek-R1

	#### Speeds, Sizes, Times

	- Hardware: NVIDIA RTX 4090
	- Hours used: 50h – 100h
	- Year: 2025

	---

	## Environmental Impact

	- Hardware Type: NVIDIA RTX 4090
	- Hours used: 50 – 100 heures
	- Cloud Provider: Local (on-premise)
	- Compute Region: Morocco 🇲🇦
	- Carbon Emitted: Estimable via [ML Impact Calculator](https://mlco2.github.io/impact#compute)

	---

	## Technical Specifications

	### Model Architecture and Objective

	Basé sur DeepSeek-R1 (Transformer décodeur).
	Objectif : génération de code C# / ABP.IO avec capacités de tool calling pour l'intégration dans des pipelines agentiques de vibe coding.

	### Software

	- `transformers`
	- `unsloth`
	- `torch`
	- `peft`
	- `dotnet SDK` (côté runtime agent)
	- `ABP CLI` (côté runtime agent)

	---

	## Citation

	BibTeX:
	```bibtex
	@misc{B3G_ABP.IO_Coder_thinking_max,
	title = {B3G ABP.IO Coder Thinking Max},
	author = {Badre Zouiri},
	year = {2025},
	publisher = {HuggingFace},
	url = {https://huggingface.co/bzouiri/B3G_ABP.IO_Coder_thinking_max},
	license = {Apache 2.0},
	note = {Fine-tuned from DeepSeek-R1 using Unsloth for ABP.IO C# vibe coding}
	}
	```

	---

	## Model Card Authors

	Badre Zouiri — [bzouiri](https://huggingface.co/bzouiri)

	## Model Card Contact

	HuggingFace: [bzouiri](https://huggingface.co/bzouiri)