---
title: "Formation nibiru-coder"
description: "Comment enregistrer un modèle de conversation à base de Nibiru sur votre propre Ollama. Un fichier Modelfile, un script shell, soixante secondes."
---

Le modèle de chat par défaut du framework est **`nibiru-coder:1.0`** — un Qwen 2.5 Coder 14B à la saveur Nibiru que vous enregistrez sur votre serveur Ollama. Le pipeline d'entraînement se trouve dans `application/module/ai/training/`.

## Ce que `nibiru-coder` est (et ce qu'il n'est pas)

`nibiru-coder:1.0` n'est **pas** une fine-tuning LoRA. C'est les mêmes poids `qwen2.5-coder:14b` enveloppés avec un système de prédiction intégré qui :

- explique MMVC, les modules, le dispatcheur, les singletons,
- impose les conventions de Nibiru (`pageAction`, `navigationAction`, `View::assign`, `Form::create`, l'orthographe de `Pageination`),
- pousse le modèle vers des réponses idiomatiques Nibiru au lieu d'advice générique Laravel / Symfony.

La personnalisation du système-prompt se fait **instantanément** — pas d'entraînement GPU, pas de préparation de jeu de données. Cela offre environ 80 % de la valeur d'un vrai LoRA à un coût d'entraînement nul. Lorsque vous avez un budget pour un entraînement réel, consultez le *chemin du LoRA réel* ci-dessous.

## Construisez-le
```bash
./application/module/ai/training/build.sh           # builds nibiru-coder:1.0
./application/module/ai/training/build.sh 1.1       # bump tag for iterations
```
Le script :

1. Lit le fichier Modelfile situé à côté de lui.
2. Envoie une requête POST à `${OLLAMA_BASE_URL}/api/create` (par défaut `https://api.neuronetz.ai`).
3. Exécute un test fumeur de conversation pour confirmer que le nouveau tag répond.

Après son succès, définissez le modèle dans `application/module/ai/settings/ai.ini` :
```ini
[AI]
chat.model          = "nibiru-coder:1.0"
chat.fallback_model = "qwen2.5-coder:14b"
```
…et chaque instance de `\Nibiru\Module\Ai\Ai` dans votre application communique avec elle. Le fallback assure que rien ne se casse si vous n'avez pas encore construit l'étiquette.

## Itérer sur le système d'invite

Le bloc `SYSTEM """ ... """` du Modelfile est la clé. Affinez les conventions, ajoutez de nouveaux exemples et citez des fichiers spécifiques du framework. Réexécutez `build.sh` avec un nouveau tag (`1.1`, `1.2`, …) et effectuez une comparaison A/B par rapport au tag précédent dans votre application.
```bash
./application/module/ai/training/build.sh 1.1
# Edit ai.ini → chat.model = "nibiru-coder:1.1"
# Compare answers in the Oracle widget or via smoke-test.php
```
## Chemin réel LoRA

Lorsque vous souhaitez un modèle dont les **poids** connaissent Nibiru — et non seulement son système de prédiction — l'exportateur de corpus est là pour vous aider.
```bash
cd docs
npm run build:corpus
```
Génère des fichiers JSONL dans `dist/corpus/` :

| Fichier | Format | Utilisation |
|---|---|---|
| `chat.jsonl` | messages de style sharegpt | Axolotl, LLaMA-Factory, Unsloth |
| `instructions.jsonl` | instruction/input/output | formateurs de type Alpaca |
| `completion.jsonl` | prompt/completion | fine-tunage legacy text-completion |
| `chunks.jsonl` | métadonnées de blocs | RAG / construction de l'ensemble d'évaluation |

Une recette pragmatique pour une base de 8B sur un seul A100 / 4090 :
```yaml
# axolotl.yml
base_model: meta-llama/Llama-3.1-8B-Instruct
adapter: lora
lora_r: 16
lora_alpha: 32
lora_dropout: 0.05
lora_target_modules: [q_proj, k_proj, v_proj, o_proj]

datasets:
  - path: docs/dist/corpus/chat.jsonl
    type: sharegpt

sequence_len: 4096
sample_packing: true
gradient_accumulation_steps: 4
micro_batch_size: 2
num_epochs: 3
optimizer: adamw_bnb_8bit
learning_rate: 0.0002
warmup_ratio: 0.05
bf16: true
```
Après l'entraînement :

1. Convertissez le LoRA en GGUF (`llama.cpp`'s `convert_hf_to_gguf.py`).
2. Créez un fichier Modelfile Ollama avec `FROM ./your-lora.gguf`.
3. `./build.sh 2.0` l'enregistre sous le nom de `nibiru-coder:2.0`.

Le code du framework ne change pas — remplacez `chat.model` dans `ai.ini` et vous utilisez les nouveaux poids.

## Test fumigatoire
```bash
php application/module/ai/training/smoke-test.php
```
Vérifie :

- Le serveur Ollama est accessible.
- Le modèle répond à une demande d'un seul tour.
- Le contexte de conversation multi-tours fonctionne.
- Les embeddings fonctionnent (ignorés avec un message clair si `nomic-embed-text` n'est pas tiré).

Exécutez après chaque modification du fichier Modelfile, avant le déploiement.

## Trucaments courants

- **Le système de `Modelfile` a un prompt trop long.** Certaines versions d'Ollama limitent les prompts système. Gardez-le sous ~3000 tokens.
- **Oublier de tirer le modèle FROM.** Le modèle `qwen2.5-coder:14b` doit déjà être sur le serveur. Utilisez `curl ${OLLAMA_BASE_URL}/api/tags` pour vérifier.
- **Collisions de tags.** Ré-exécuter `build.sh 1.0` écrase l'existing `nibiru-coder:1.0`. Utilisez des nouveaux tags pour les itérations ; épinglez des tags spécifiques dans `ai.ini` pour la production.
- **Confusion concernant `--no-stream`.** Le script de construction utilise `stream: false`, donc la réponse revient sous forme d'un seul JSON. Si vous passez à un flux, analysez ligne par ligne.
