---
title: "Le module IA"
description: "Première classe d'IA dans Nibiru — conversation, embeddings, RAG, agents — connectés à votre propre Ollama sur neuronetz.ai. Aucune API payante requise."
---

Nibiru embarque un **module IA** (`application/module/ai/`) qui donne à chaque application Nibiru une interface IA de première classe. Le code PHP peut dialoguer avec un LLM local, émbarquer du texte, exécuter RAG sur ses propres données ou exécuter un agent avec des outils — tout cela sans envoyer un seul octet à une API payante.

Le module est connecté par défaut à votre propre [Ollama sur neuronetz.ai](/en/ai/oracle/), donc l'inférence se fait sur votre matériel, sur votre réseau, selon vos termes.

## Ce que vous obtenez

| Plugin | Ce qu'il fait | Phrase en une ligne |
|---|---|---|
| `Chat` | Complétions de conversation, à un ou plusieurs tours | `$ai->chat()->ask('…')` |
| `Embed` | Texte → vecteurs + helpers cosinus | `$ai->embed()->one('…')` |
| `Rag` | Ingestion + récupération + conversation ancrée | `$ai->rag('docs')->ask('…')` |
| `Agent` | Boucle ReAct utilisant des outils | `$ai->agent()->withTools([…])->run('…')` |
| `Tool` | Base pour vos propres outils personnalisés | `class MyTool extends Tool { … }` |
| `Ollama` | Transport HTTP brut vers n'importe quel point de terminaison compatible Ollama | `(new Ollama($cfg))->chat(…)` |

## Bonjour, IA
```php
use Nibiru\Module\Ai\Ai;

$ai = new Ai();

echo $ai->chat()->ask('How do I scaffold a new module?');
// → "Run `./nibiru -m <name>`. This creates application/module/<name>/ with…"
```
Voici toute la surface d'API pour le cas simple. Aucun conteneur DI, aucune clé API, aucune installation de SDK.

## Connecté par configuration

Chaque plugin lit ses paramètres depuis `application/module/ai/settings/ai.ini`:
```ini
[AI]
ollama.base_url     = "https://api.neuronetz.ai"
chat.model          = "nibiru-coder:1.0"
chat.fallback_model = "qwen2.5-coder:14b"
chat.temperature    = 0.4
chat.max_tokens     = 1024
embed.model         = "nomic-embed-text"
rag.top_k           = 6
agent.max_iterations = 6
```
Remplacement par environnement : `ai.production.ini`, `ai.staging.ini`. Le registre de Nibiru les découvre automatiquement.

## Les quatre cas d'utilisation majeurs

### 1. Conversation — communiquez avec votre modèle
```php
$ai = new \Nibiru\Module\Ai\Ai();

// One-shot
echo $ai->chat()->ask('Explain MMVC in two sentences.');

// Multi-turn
$chat = $ai->chat();
$chat->user('How do I scaffold a module?');
$chat->user('And add Graylog hooks?');   // referrs to previous turn
echo $chat->complete();

// Override per call
echo $ai->chat()
    ->system('Answer in German.')
    ->model('qwen2.5-coder:14b')
    ->temperature(0.1)
    ->ask('Was ist ein Modul?');
```
Le plugin `Chat` revient automatiquement à `chat.fallback_model` si le modèle principal n'est pas disponible — utile lorsque vous construisez encore `nibiru-coder`.

### 2. Intégrer — texte dans des vecteurs
```php
$embed = $ai->embed();

$va = $embed->one('controller');
$vb = $embed->one('module');
$score = \Nibiru\Module\Ai\Plugin\Embed::cosine($va, $vb);
// → 0.78 (close concepts)
```
Stockage compact :
```php
$packed = \Nibiru\Module\Ai\Plugin\Embed::pack($vec);   // base64 string, 4 bytes/dim
$vec    = \Nibiru\Module\Ai\Plugin\Embed::unpack($packed);
```
### 3. RAG — ingérer, récupérer, ancrer
```php
$rag = $ai->rag('product-help');

// One-time ingestion
$rag->ingestDir(__DIR__ . '/help/');             // walks .md/.txt/.php
$rag->ingestText('FAQ entry…', ['source' => 'faq-12']);
$rag->ingestFile('/var/data/manual.pdf.txt');

// Then ask grounded questions
echo $rag->ask('How do I cancel my subscription?');
// → "Per the help docs, you can cancel in account → settings… [1]"
```
Stockage : un fichier JSON par collection à l'emplacement `application/module/ai/cache/rag/<nom>.json`. Redémarrable, sans base de données, il convient confortablement à environ 10 000 morceaux en mémoire.

### 4. Agent — outils qui agissent
```php
use Nibiru\Module\Ai\Plugin\Tools;

$ai = new \Nibiru\Module\Ai\Ai();

$agent = $ai->agent()->withTools([
    new Tools\PdoQuery(),    // read-only SQL
    new Tools\HttpGet(),     // fetch URLs
    new Tools\FileRead(),    // read project files
]);

echo $agent->run('How many active users registered last week?');
// → agent decides to call pdo_query with SELECT count(*) FROM users…
//   reads observation, writes a final answer.
```
L'agent utilise une boucle de type ReAct : lire la tâche → choisir l'outil → exécuter → observer → répéter → réponse finale. Le protocole utilise un simple marqueur JSON ``\`\`\`tool {...}\`\`\`` qui fonctionne sur chaque modèle Ollama — aucune API spécifique d'appel à des outils par modèle n'est requise.

## Où il réside
```
application/module/ai/
├── ai.php                    # main class implementing IModule
├── interfaces/ai.php         # contract
├── traits/ai.php             # cfg() helper
├── plugins/
│   ├── ollama.php            # raw transport
│   ├── chat.php              # chat completions
│   ├── embed.php             # embeddings + cosine + pack
│   ├── rag.php               # ingest + retrieve + grounded chat
│   ├── agent.php             # ReAct tool loop
│   ├── tool.php              # abstract base for custom tools
│   └── tools/
│       ├── pdoQuery.php      # read-only SQL
│       ├── httpGet.php       # HTTP GET
│       └── fileRead.php      # project-local file read
├── settings/ai.ini           # config
├── cache/rag/                # RAG vector index files (gitignored)
└── training/
    ├── Modelfile             # the nibiru-coder system prompt
    ├── build.sh              # one-command Modelfile → registered model
    ├── smoke-test.php        # verify the whole stack
    └── README.md             # training pipeline guide
```
## Pourquoi cela existe

PHP n'a pas de "framework d'IA" établi comme Python a LangChain ou JS a Vercel AI SDK. Le module IA de Nibiru remplit ce vide avec l'API la plus petite et la plus pointue que nous ayons pu écrire — trois couches (transport → plugin → module), sans graphique DI, sans installation d'un SDK, sans facturation par token.

La philosophie de conception :

- **Apportez votre propre cerveau.** Ollama par défaut, Anthropic et OpenAI comme options. Changez les fournisseurs via INI, jamais via le code.
- **Un fichier JSON par collection RAG.** Pas de base de données vectorielle. Redémarrage sécurisé. Recherchable avec grep lorsque vous déboguez.
- **Les outils sont des classes PHP.** Étendez `Tool`, obtenez un nom + schéma + méthode d'exécution. L'agent s'en occupe du reste.
- **Aucune API spécifique à un modèle pour les appels d'outil.** Une seule convention JSON encadrée fonctionne partout.

## Suivant

- [Référence du module de chat](/fr/ia/module/chat/)
- [Référence du module RAG](/fr/ia/module/rag/)
- [Référence du module agent](/fr/ia/module/agent/)
- [Formation nibiru-coder](/fr/ia/module/training/)
