[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/hashtag",{"_7":8,"_9":10,"_11":12},"articles",[13],"authors",{},"tag","qwen-coder",{"_14":15,"_16":17,"_18":19,"_20":21,"_22":23,"_24":25,"_26":27},"content","# Créer un LLM Spécialiste de Votre Code pour Roo Code\n\nCe 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.\n\n---\n\n## Prérequis\n\n- **Matériel :** GPU avec au moins 8 Go de VRAM (pour le fine-tuning du modèle 7B quantifié en 4-bit).\n- **Logiciels :** Python 3.10+, [Ollama](https://ollama.com/), [Docker](https://www.docker.com/), Git, VSCodium + extension Roo Code.\n- **Données :** Votre code source et un fichier `dataset.jsonl` généré à l'étape 1.\n\n---\n\n## Étape 1 : Génération du Dataset (`dataset.jsonl`)\n\nCopiez votre code avec `cpcode` (https://github.com/papiche/Astroport.ONE/blob/master/cpcode)\n\nUtilisez un LLM puissant (Gemini, GPT-4, Claude) pour créer les exemples d'entraînement. Uploadez vos fichiers source et soumettez ce prompt :\n\n```\nTu es un générateur de dataset pour fine-tuning LLM sur mon projet.\nFichiers uploadés : [Dart, Python, MD, HTML du projet].\n\nGÉNÈRE 100 exemples d'entraînement au format JSONL (Alpaca) :\n- 40% Q&A sur architecture/codebase (citer fichiers/lignes)\n- 30% code completion (fonctions partielles → complètes)\n- 20% explications design decisions\n- 10% bug fixes / refactoring\n\nChaque exemple :\n{\"instruction\": \"question/prompt\", \"output\": \"réponse/code exact du projet\", \"metadata\": {\"files\": [\"list\"], \"type\": \"qa/completion/explain\"}}\n\nPriorité : réponses 100% fidèles au code uploadé, jamais d'invention.\n```\n\nSauvegardez le résultat dans `dataset.jsonl` à la racine du projet.\n\n---\n\n## Étape 2 : Installation des dépendances\n\n```bash\npip install torch transformers accelerate peft trl datasets bitsandbytes scipy sentencepiece\n```\n\n---\n\n## Étape 3 : Fine-Tuning LoRA\n\nCréez `train_lora.py` :\n\n```python\nimport torch\nfrom datasets import load_dataset\nfrom peft import LoraConfig, get_peft_model, TaskType\nfrom transformers import (\n AutoModelForCausalLM,\n AutoTokenizer,\n BitsAndBytesConfig,\n)\nfrom trl import SFTTrainer, SFTConfig\n\nmodel_name = \"Qwen/Qwen2.5-Coder-7B-Instruct\"\ndataset_path = \"./dataset.jsonl\"\noutput_dir = \"./qwen_coder_lora\"\n\n# Quantisation 4-bit pour réduire la mémoire GPU\nbnb_config = BitsAndBytesConfig(\n load_in_4bit=True,\n bnb_4bit_use_double_quant=True,\n bnb_4bit_quant_type=\"nf4\",\n bnb_4bit_compute_dtype=torch.bfloat16,\n)\n\nmodel = AutoModelForCausalLM.from_pretrained(\n model_name,\n quantization_config=bnb_config,\n device_map=\"auto\",\n trust_remote_code=True,\n low_cpu_mem_usage=True,\n dtype=torch.bfloat16,\n)\ntokenizer = AutoTokenizer.from_pretrained(model_name)\nif tokenizer.pad_token is None:\n tokenizer.pad_token = tokenizer.eos_token\n\nlora_config = LoraConfig(\n r=32,\n lora_alpha=64,\n target_modules=[\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\", \"gate_proj\", \"up_proj\", \"down_proj\"],\n lora_dropout=0.05,\n bias=\"none\",\n task_type=TaskType.CAUSAL_LM,\n)\nmodel = get_peft_model(model, lora_config)\nmodel.print_trainable_parameters()\n\ndataset = load_dataset(\"json\", data_files=dataset_path, split=\"train\")\ndef format_instruction(example):\n return {\n \"text\": f\"<|im_start|>user\\n{example['instruction']}<|im_end|>\\n<|im_start|>assistant\\n{example['output']}<|im_end|>\\n\"\n }\ndataset = dataset.map(format_instruction)\n\n# SFTConfig remplace TrainingArguments pour trl >= 0.9\ntraining_args = SFTConfig(\n output_dir=output_dir,\n num_train_epochs=3,\n per_device_train_batch_size=2,\n gradient_accumulation_steps=4,\n learning_rate=1e-4,\n fp16=False,\n bf16=True,\n logging_steps=5,\n save_steps=250,\n save_total_limit=2,\n warmup_steps=50,\n max_length=4096,\n dataset_text_field=\"text\",\n)\n\ntrainer = SFTTrainer(\n model=model,\n train_dataset=dataset,\n args=training_args,\n)\n\ntrainer.train()\nmodel.save_pretrained(output_dir)\ntokenizer.save_pretrained(output_dir)\nprint(f\"✅ Fine-tuning terminé ! Modèle sauvegardé dans {output_dir}\")\n```\n\n**Exécutez :** `python train_lora.py` (comptez 1-2 heures selon votre GPU).\n\n---\n\n## Étape 4 : Fusion du LoRA\n\nCréez `merge_lora.py` :\n\n```python\nfrom peft import PeftModel\nfrom transformers import AutoModelForCausalLM, AutoTokenizer\nimport torch\n\nbase_model_name = \"Qwen/Qwen2.5-Coder-7B-Instruct\" # Doit correspondre au modèle entraîné\nlora_path = \"./qwen_coder_lora\"\noutput_path = \"./qwen_coder_fused\"\n\nprint(\"Chargement du modèle de base...\")\nmodel = AutoModelForCausalLM.from_pretrained(\n base_model_name,\n dtype=torch.bfloat16,\n device_map=\"auto\"\n)\ntokenizer = AutoTokenizer.from_pretrained(base_model_name)\n\nprint(\"Fusion des adaptateurs LoRA...\")\nmodel = PeftModel.from_pretrained(model, lora_path)\nmodel = model.merge_and_unload()\n\nprint(\"Sauvegarde du modèle fusionné...\")\nmodel.save_pretrained(output_path)\ntokenizer.save_pretrained(output_path)\nprint(f\"✅ Modèle fusionné sauvegardé dans {output_path}\")\n```\n\n**Exécutez :** `python merge_lora.py`\n\n---\n\n## Étape 5 : Conversion en GGUF pour Ollama\n\n```bash\n# 1. Clonez et compilez llama.cpp\ngit clone https://github.com/ggerganov/llama.cpp\ncd llama.cpp\ncmake -B build\ncmake --build build --config Release -j4\n\n# 2. Convertir en f16 (~14 Go temporairement)\npython convert_hf_to_gguf.py ../qwen_coder_fused --outtype f16 --outfile ../qwen_coder_f16.gguf\n\n# 3. Quantifier en q4_k_m (~4.5 Go final)\n./build/bin/llama-quantize ../qwen_coder_f16.gguf ../qwen_coder_q4_k_m.gguf q4_k_m\n\n# 4. Supprimer le fichier intermédiaire\nrm ../qwen_coder_f16.gguf\ncd ..\n```\n\n> **Note :** `convert_hf_to_gguf.py` nécessite `sentencepiece` : `pip install sentencepiece`\n\n---\n\n## Étape 6 : Créer le modèle Ollama\n\nCréez un dossier `ollama_model/` avec un fichier `Modelfile` :\n\n```dockerfile\nFROM ../qwen_coder_q4_k_m.gguf\n\nTEMPLATE \"\"\"{{ if .System }}<|im_start|>system\n{{ .System }}<|im_end|>\n{{ end }}{{ if .Tools }}Available tools: {{ .Tools }}{{ end }}<|im_start|>user\n{{ .Prompt }}<|im_end|>\n<|im_start|>assistant\n\"\"\"\n\nPARAMETER stop \"<|im_end|>\"\nPARAMETER stop \"<|endoftext|>\"\nPARAMETER temperature 0.1\nPARAMETER top_p 0.9\nPARAMETER top_k 40\n\nSYSTEM \"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.\"\n```\n\n```bash\ncd ollama_model\nollama create qwen-coder-monprojet -f Modelfile\nollama run qwen-coder-monprojet \"Bonjour, comment fonctionne l'authentification ?\"\n```\n\n---\n\n## Étape 7 : RAG avec Roo Code (indexation native)\n\n> **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.\n\n### 7.1 Lancer Qdrant\n\n```bash\ndocker run -d \\\n --name qdrant \\\n --restart unless-stopped \\\n -p 6333:6333 \\\n -v qdrant_data:/qdrant/storage \\\n qdrant/qdrant\n```\n\n### 7.2 Obtenir une clé d'embeddings (gratuite)\n\nRoo Code a besoin d'un fournisseur d'embeddings pour vectoriser votre code. L'option **100% gratuite** recommandée :\n\n1. Allez sur [Google AI Studio](https://aistudio.google.com/apikey)\n2. Créez une clé API gratuite\n3. Notez-la pour l'étape suivante\n\n> Alternatives disponibles dans Roo Code : OpenAI, Ollama (local/gratuit), Mistral, Bedrock, OpenRouter.\n\n### 7.3 Configurer l'indexation dans Roo Code\n\n1. Ouvrez VSCodium avec votre projet\n2. Cliquez sur l'**icône de statut d'indexation** en bas à droite de la zone de chat (cercle gris)\n3. Dans le panneau de configuration :\n - **Embedder Provider** : `Google Gemini`\n - **API Key** : votre clé Google AI Studio\n - **Model** : `gemini-embedding-001`\n - **Qdrant URL** : `http://localhost:6333`\n - **Qdrant API Key** : laisser vide (instance locale)\n4. Cliquez **Save** puis **Start Indexing**\n\nL'icône passe en **jaune** pendant l'indexation, puis en **vert** quand c'est prêt.\n\n### 7.4 Ce que fait Roo Code en coulisses\n\n- Parse votre code avec **Tree-sitter** (fonctions, classes, méthodes)\n- Crée des embeddings de chaque bloc (100-1000 caractères)\n- Stocke les vecteurs dans Qdrant\n- Met à jour automatiquement quand vous modifiez des fichiers\n- Utilise l'outil `codebase_search` pour trouver le contexte pertinent à chaque requête\n\n### 7.5 Configurer Roo Code pour utiliser votre modèle Ollama\n\n1. Dans les **Paramètres** de Roo Code, section **Provider**\n2. Sélectionnez **Ollama**\n3. **URL Ollama** : `http://localhost:11434`\n4. **Model** : `qwen-coder-monprojet`\n5. Sauvegardez\n\n---\n\n## Étape 8 : Utilisation\n\n### Depuis la ligne de commande\n\n```bash\nollama run qwen-coder-monprojet \"Explique le rôle du fichier lib/auth/auth_service.dart\"\n```\n\n### Dans Roo Code\n\nOuvrez un fichier de votre projet et utilisez `Ctrl+I` (ou `Cmd+I`). Roo Code va automatiquement :\n\n1. Rechercher dans l'index Qdrant les fichiers pertinents à votre question\n2. Injecter ces extraits de code comme contexte\n3. Envoyer la requête enrichie à votre modèle Ollama finetuné\n\n**Exemples de requêtes efficaces :**\n\n- `\"Comment fonctionne l'authentification utilisateur ?\"` ✅\n- `\"Montre-moi la gestion des erreurs pour les appels API\"` ✅\n- `\"Complète cette fonction de connexion à la base de données\"` ✅\n\n> **Conseil :** Utilisez des descriptions en langage naturel plutôt que des noms de fonctions exacts. La recherche est sémantique, pas textuelle.\n\n---\n\n## Résumé de l'architecture\n\n```\nVotre code\n │\n ▼\n[Roo Code Indexer]\n │ Tree-sitter parsing\n │ Embeddings (Gemini/Ollama/...)\n ▼\n[Qdrant local] ←──── vecteurs stockés localement\n │\n │ codebase_search (contexte pertinent)\n ▼\n[Roo Code]\n │ prompt enrichi avec contexte\n ▼\n[Ollama] ←──── votre modèle finetuné qwen-coder-monprojet\n │\n ▼\nRéponse précise sur votre codebase\n```\n\n---\n\n## Dépannage\n\n**Qdrant ne démarre pas**\n```bash\ndocker ps -a # vérifier l'état du conteneur\ndocker logs qdrant\n```\n\n**Indexation bloquée en rouge**\n- Vérifiez que Qdrant est accessible : `curl http://localhost:6333/health`\n- Vérifiez votre clé API d'embeddings\n- Cliquez \"Clear Index Data\" dans le panneau Roo Code et relancez\n\n**Modèle Ollama non trouvé**\n```bash\nollama list # vérifier que qwen-coder-monprojet apparaît\nollama run qwen-coder-monprojet \"test\" # test rapide\n```\n\n**Erreur `size mismatch` dans merge_lora.py**\nVé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`.\n\n---\n\n**Votre assistant IA spécialiste de votre code est prêt !** 🎉","created_at",1772017879,"id","1b4c8827a904b1d9b8b7d49ce099a3c0c8d2e69f7cbc73204d8fafcfc8a56ead","kind",30023,"pubkey","9da638f3ff87f550efb32ca0d363f53047ead410e6748c19eb8ccb81ba3aff27","sig","dc062bbb3ac79ed9db96197decc23f48d6b8353b66be8a952faec7ead0cb3c31b80226020eeeaa343c939262d1c6a97488f7091d42acec75aef92400ea89e92a","tags",[28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48],[72,73],[70,71],[68,69],[66,67],[49,65],[49,64],[49,63],[49,62],[49,61],[49,60],[49,59],[49,58],[49,12],[49,57],[49,56],[49,55],[49,54],[49,53],[49,52],[49,51],[49,50],"t","custom-llm","ai-coding","deep-learning","machine-learning","vscodium","vector-database","rag","dataset-generation","lora","peft","ollama","qdrant","roo-code","code-assistant","fine-tuning","llm","image","https://ipfs.copylaradio.com/ipfs/QmQumMpu97uGDmKciZoCHhUB6cs3nMAxLiiV9diH6mJzdj/code_Specialist_LLM.jpg","summary","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.\n","title","Créer un LLM Spécialiste de Votre Code pour Roo Code","d","ff8f296c-d730-4831-ab80-197ffd416fd2"]