Créer un LLM Spécialiste de Votre Code pour Roo Code

By (f‿-) coucou.yopmail.com ++ February 25, 2026

Ce guide vous permet de construire un assistant IA sur-mesure, basé sur le modèle **Qwen2.5-Coder-14B-Instruct**, finement ajusté sur votre propre codebase puis intégré à Roo Code via Ollama et Qdrant.

Créer un LLM Spécialiste de Votre Code pour Roo Code

Créer un LLM Spécialiste de Votre Code pour Roo Code

Ce guide vous permet de construire un assistant IA sur-mesure, basé sur Qwen2.5-Coder-7B-Instruct, finement ajusté sur votre propre codebase et intégré à Roo Code via Ollama. Le RAG sémantique est géré nativement par Roo Code grâce à Qdrant et un fournisseur d’embeddings.

Prérequis

Matériel : GPU avec au moins 8 Go de VRAM (pour le fine-tuning du modèle 7B quantifié en 4-bit).
Logiciels : Python 3.10+, Ollama, Docker, Git, VSCodium + extension Roo Code.
Données : Votre code source et un fichier dataset.jsonl généré à l’étape 1.

Étape 1 : Génération du Dataset (`dataset.jsonl`)

Copiez votre code avec cpcode (https://github.com/papiche/Astroport.ONE/blob/master/cpcode)

Utilisez un LLM puissant (Gemini, GPT-4, Claude) pour créer les exemples d’entraînement. Uploadez vos fichiers source et soumettez ce prompt :

Tu es un générateur de dataset pour fine-tuning LLM sur mon projet.
Fichiers uploadés : [Dart, Python, MD, HTML du projet].

GÉNÈRE 100 exemples d'entraînement au format JSONL (Alpaca) :
- 40% Q&A sur architecture/codebase (citer fichiers/lignes)
- 30% code completion (fonctions partielles → complètes)
- 20% explications design decisions
- 10% bug fixes / refactoring

Chaque exemple :
{"instruction": "question/prompt", "output": "réponse/code exact du projet", "metadata": {"files": ["list"], "type": "qa/completion/explain"}}

Priorité : réponses 100% fidèles au code uploadé, jamais d'invention.

Sauvegardez le résultat dans dataset.jsonl à la racine du projet.

Étape 2 : Installation des dépendances

pip install torch transformers accelerate peft trl datasets bitsandbytes scipy sentencepiece

Étape 3 : Fine-Tuning LoRA

Créez train_lora.py :

import torch
from datasets import load_dataset
from peft import LoraConfig, get_peft_model, TaskType
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
)
from trl import SFTTrainer, SFTConfig

model_name = "Qwen/Qwen2.5-Coder-7B-Instruct"
dataset_path = "./dataset.jsonl"
output_dir = "./qwen_coder_lora"

# Quantisation 4-bit pour réduire la mémoire GPU
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
    low_cpu_mem_usage=True,
    dtype=torch.bfloat16,
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

lora_config = LoraConfig(
    r=32,
    lora_alpha=64,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM,
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

dataset = load_dataset("json", data_files=dataset_path, split="train")
def format_instruction(example):
    return {
        "text": f"<|im_start|>user\n{example['instruction']}<|im_end|>\n<|im_start|>assistant\n{example['output']}<|im_end|>\n"
    }
dataset = dataset.map(format_instruction)

# SFTConfig remplace TrainingArguments pour trl >= 0.9
training_args = SFTConfig(
    output_dir=output_dir,
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=1e-4,
    fp16=False,
    bf16=True,
    logging_steps=5,
    save_steps=250,
    save_total_limit=2,
    warmup_steps=50,
    max_length=4096,
    dataset_text_field="text",
)

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    args=training_args,
)

trainer.train()
model.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)
print(f"✅ Fine-tuning terminé ! Modèle sauvegardé dans {output_dir}")

Exécutez : python train_lora.py (comptez 1-2 heures selon votre GPU).

Étape 4 : Fusion du LoRA

Créez merge_lora.py :

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

base_model_name = "Qwen/Qwen2.5-Coder-7B-Instruct"  # Doit correspondre au modèle entraîné
lora_path = "./qwen_coder_lora"
output_path = "./qwen_coder_fused"

print("Chargement du modèle de base...")
model = AutoModelForCausalLM.from_pretrained(
    base_model_name,
    dtype=torch.bfloat16,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(base_model_name)

print("Fusion des adaptateurs LoRA...")
model = PeftModel.from_pretrained(model, lora_path)
model = model.merge_and_unload()

print("Sauvegarde du modèle fusionné...")
model.save_pretrained(output_path)
tokenizer.save_pretrained(output_path)
print(f"✅ Modèle fusionné sauvegardé dans {output_path}")

Exécutez : python merge_lora.py

Étape 5 : Conversion en GGUF pour Ollama

# 1. Clonez et compilez llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build
cmake --build build --config Release -j4

# 2. Convertir en f16 (~14 Go temporairement)
python convert_hf_to_gguf.py ../qwen_coder_fused --outtype f16 --outfile ../qwen_coder_f16.gguf

# 3. Quantifier en q4_k_m (~4.5 Go final)
./build/bin/llama-quantize ../qwen_coder_f16.gguf ../qwen_coder_q4_k_m.gguf q4_k_m

# 4. Supprimer le fichier intermédiaire
rm ../qwen_coder_f16.gguf
cd ..

Note : convert_hf_to_gguf.py nécessite sentencepiece : pip install sentencepiece

Étape 6 : Créer le modèle Ollama

Créez un dossier ollama_model/ avec un fichier Modelfile :

FROM ../qwen_coder_q4_k_m.gguf

TEMPLATE """{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Tools }}Available tools: {{ .Tools }}{{ end }}<|im_start|>user
{{ .Prompt }}<|im_end|>
<|im_start|>assistant
"""

PARAMETER stop "<|im_end|>"
PARAMETER stop "<|endoftext|>"
PARAMETER temperature 0.1
PARAMETER top_p 0.9
PARAMETER top_k 40

SYSTEM "Tu es un expert de la base de code du projet. Réponds avec précision en citant les fichiers et les lignes de code pertinents."

cd ollama_model
ollama create qwen-coder-monprojet -f Modelfile
ollama run qwen-coder-monprojet "Bonjour, comment fonctionne l'authentification ?"

Étape 7 : RAG avec Roo Code (indexation native)

Bonne nouvelle : Roo Code gère nativement le RAG sémantique via Qdrant. Pas besoin d’un script externe ni d’un serveur intermédiaire. Roo Code indexe votre codebase automatiquement et injecte le contexte pertinent dans chaque requête.

7.1 Lancer Qdrant

docker run -d \
  --name qdrant \
  --restart unless-stopped \
  -p 6333:6333 \
  -v qdrant_data:/qdrant/storage \
  qdrant/qdrant

7.2 Obtenir une clé d’embeddings (gratuite)

Roo Code a besoin d’un fournisseur d’embeddings pour vectoriser votre code. L’option 100% gratuite recommandée :

Allez sur Google AI Studio
Créez une clé API gratuite
Notez-la pour l’étape suivante

Alternatives disponibles dans Roo Code : OpenAI, Ollama (local/gratuit), Mistral, Bedrock, OpenRouter.

7.3 Configurer l’indexation dans Roo Code

Ouvrez VSCodium avec votre projet
Cliquez sur l’icône de statut d’indexation en bas à droite de la zone de chat (cercle gris)
Dans le panneau de configuration :
- Embedder Provider : Google Gemini
- API Key : votre clé Google AI Studio
- Model : gemini-embedding-001
- Qdrant URL : http://localhost:6333
- Qdrant API Key : laisser vide (instance locale)
Cliquez Save puis Start Indexing

L’icône passe en jaune pendant l’indexation, puis en vert quand c’est prêt.

7.4 Ce que fait Roo Code en coulisses

Parse votre code avec Tree-sitter (fonctions, classes, méthodes)
Crée des embeddings de chaque bloc (100-1000 caractères)
Stocke les vecteurs dans Qdrant
Met à jour automatiquement quand vous modifiez des fichiers
Utilise l’outil codebase_search pour trouver le contexte pertinent à chaque requête

7.5 Configurer Roo Code pour utiliser votre modèle Ollama

Dans les Paramètres de Roo Code, section Provider
Sélectionnez Ollama
URL Ollama : http://localhost:11434
Model : qwen-coder-monprojet
Sauvegardez

Étape 8 : Utilisation

Depuis la ligne de commande

ollama run qwen-coder-monprojet "Explique le rôle du fichier lib/auth/auth_service.dart"

Dans Roo Code

Ouvrez un fichier de votre projet et utilisez Ctrl+I (ou Cmd+I). Roo Code va automatiquement :

Rechercher dans l’index Qdrant les fichiers pertinents à votre question
Injecter ces extraits de code comme contexte
Envoyer la requête enrichie à votre modèle Ollama finetuné

Exemples de requêtes efficaces :

"Comment fonctionne l'authentification utilisateur ?" ✅
"Montre-moi la gestion des erreurs pour les appels API" ✅
"Complète cette fonction de connexion à la base de données" ✅

Conseil : Utilisez des descriptions en langage naturel plutôt que des noms de fonctions exacts. La recherche est sémantique, pas textuelle.

Résumé de l’architecture

Votre code
    │
    ▼
[Roo Code Indexer]
    │  Tree-sitter parsing
    │  Embeddings (Gemini/Ollama/...)
    ▼
[Qdrant local]  ←──── vecteurs stockés localement
    │
    │  codebase_search (contexte pertinent)
    ▼
[Roo Code]
    │  prompt enrichi avec contexte
    ▼
[Ollama]  ←──── votre modèle finetuné qwen-coder-monprojet
    │
    ▼
Réponse précise sur votre codebase

Dépannage

Qdrant ne démarre pas

docker ps -a  # vérifier l'état du conteneur
docker logs qdrant

Indexation bloquée en rouge

Vérifiez que Qdrant est accessible : curl http://localhost:6333/health
Vérifiez votre clé API d’embeddings
Cliquez “Clear Index Data” dans le panneau Roo Code et relancez

Modèle Ollama non trouvé

ollama list  # vérifier que qwen-coder-monprojet apparaît
ollama run qwen-coder-monprojet "test"  # test rapide

Erreur size mismatch dans merge_lora.py Vérifiez que base_model_name dans merge_lora.py est identique au model_name utilisé dans train_lora.py. Les deux doivent pointer vers Qwen/Qwen2.5-Coder-7B-Instruct.

Votre assistant IA spécialiste de votre code est prêt ! 🎉

#llm #fine-tuning #code-assistant #roo-code #qdrant #ollama #peft #lora #qwen-coder #dataset-generation #rag #vector-database #vscodium #machine-learning #deep-learning #ai-coding #custom-llm

No comments yet.

Créer un LLM Spécialiste de Votre Code pour Roo Code

§Créer un LLM Spécialiste de Votre Code pour Roo Code

§Prérequis

§Étape 1 : Génération du Dataset (dataset.jsonl)

§Étape 2 : Installation des dépendances

§Étape 3 : Fine-Tuning LoRA

§Étape 4 : Fusion du LoRA

§Étape 5 : Conversion en GGUF pour Ollama

§Étape 6 : Créer le modèle Ollama

§Étape 7 : RAG avec Roo Code (indexation native)

§7.1 Lancer Qdrant

§7.2 Obtenir une clé d’embeddings (gratuite)

§7.3 Configurer l’indexation dans Roo Code

§7.4 Ce que fait Roo Code en coulisses

§7.5 Configurer Roo Code pour utiliser votre modèle Ollama

§Étape 8 : Utilisation

§Depuis la ligne de commande

§Dans Roo Code

§Résumé de l’architecture

§Dépannage

Créer un LLM Spécialiste de Votre Code pour Roo Code

Prérequis

Étape 1 : Génération du Dataset (`dataset.jsonl`)

Étape 2 : Installation des dépendances

Étape 3 : Fine-Tuning LoRA

Étape 4 : Fusion du LoRA

Étape 5 : Conversion en GGUF pour Ollama

Étape 6 : Créer le modèle Ollama

Étape 7 : RAG avec Roo Code (indexation native)

7.1 Lancer Qdrant

7.2 Obtenir une clé d’embeddings (gratuite)

7.3 Configurer l’indexation dans Roo Code

7.4 Ce que fait Roo Code en coulisses

7.5 Configurer Roo Code pour utiliser votre modèle Ollama

Étape 8 : Utilisation

Depuis la ligne de commande

Dans Roo Code

Résumé de l’architecture

Dépannage