Le module IA

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 votre Ollama, 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

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:

[AI]
ollama.base_url     = "https://your-ollama-host.example"
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

$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

$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 :

$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

$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

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
• Référence du module RAG
• Référence du module agent
• Formation nibiru-coder