---
title: "Das KI-Modul"
description: "Erster-Klasse KI auf Nibiru – Chat, Embeddings, RAG, Agenten – verbunden mit Ihrem eigenen Ollama auf neuronetz.ai. Keine bezahlten APIs erforderlich."
---

Nibiru bietet ein **KIM-Modul** (`application/module/ai/`), das jeder Nibiru-Anwendung eine erstklassige KI-Oberfläche gibt. PHP-Code kann mit einem lokalen LLM chatten, Text einbetten, RAG über eigene Daten ausführen oder einen Agenten mit Tools starten – alles ohne einen Byte an eine bezahlte API zu senden.

Das Modul ist standardmäßig mit Ihrem eigenen [Ollama auf neuronetz.ai](/de/kuenstliche-intelligenz/orakel/) verbunden, sodass die Inferenz auf Ihrer Hardware, in Ihrem Netzwerk und Ihren Bedingungen erfolgt.

## Was Sie erhalten

| Plugin | Was es macht | Einzeiler |
|---|---|---|
| `Chat` | Chat-Vervollständigungen, ein- oder mehrfach | `$ai->chat()->ask('…')` |
| `Embed` | Text → Vektoren + Kosinus-Hilfsprogramme | `$ai->embed()->one('…')` |
| `Rag` | Aufnehmen + Abrufen + angebundener Chat | `$ai->rag('docs')->ask('…')` |
| `Agent` | Werkzeugnutzender ReAct-Schleife | `$ai->agent()->withTools([…])->run('…')` |
| `Tool` | Grundlage für Ihre eigenen benutzerdefinierten Tools | `class MyTool extends Tool { … }` |
| `Ollama` | Roher HTTP-Transport zu jedem Ollama-kompatiblen Endpunkt | `(new Ollama($cfg))->chat(…)` |

## Hallo, KI
```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…"
```
Dies ist die gesamte API-Oberfläche für den einfachen Fall. Kein Dependency Injection-Container, keine API-Schlüssel, kein SDK-Installieren.

## Über Konfiguration verbunden

Jedes Plugin liest seine Einstellungen aus `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
```
Umgebungsspezifische Überschreibungen: `ai.production.ini`, `ai.staging.ini`. Der Nibiru-Registrierungsmechanismus erkennt diese automatisch.

## Die vier Hauptanwendungsfälle

### 1. Chat — sprechen Sie mit Ihrem Modell
```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?');
```
Der `Chat`-Plugin wechselt automatisch zu `chat.fallback_model`, wenn das primäre Modell nicht verfügbar ist – nützlich, während Sie noch an `nibiru-coder` arbeiten.

### 2. Einbetten — Text in Vektoren
```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)
```
Kompakte Speicherung:
```php
$packed = \Nibiru\Module\Ai\Plugin\Embed::pack($vec);   // base64 string, 4 bytes/dim
$vec    = \Nibiru\Module\Ai\Plugin\Embed::unpack($packed);
```
### 3. RAG — Ingestieren, Abrufen, Verankern
```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]"
```
Speicherung: Eine einzelne JSON-Datei pro Sammlung unter `application/module/ai/cache/rag/<name>.json`. Wiederholbar, ohne Datenbank, passt bequem ~10.000 Chunks im Speicher.

### 4. Agent — Werkzeuge, die handeln
```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.
```
Der Agent verwendet eine ReAct-stilige Schleife: Lesen der Aufgabe → Auswahl des Tools → Ausführen → Beobachten → Wiederholen → Endantwort. Das Protokoll verwendet einen einfachen JSON-Sentinel `\`\`\`tool {...}\`\`\`` , der bei jedem Ollama-Modell funktioniert – keine modellspezifischen Tool-Aufruf-APIs erforderlich.

## Wo es lebt
```
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
```
## Warum dies existiert

PHP hat keine etablierte "Künstliche-Intelligenz-Frameworks" wie Python mit LangChain oder JS mit Vercel AI SDK. Das Nibiru-AI-Modul füllt diesen Lücke mit der kleinsten und schärfsten API, die wir schreiben konnten – drei Ebenen (Transport → Plugin → Modul), kein DI-Grafik, keine SDK-Installation, keine pro-Token-Rechnung.

Die Gestaltungsentfernung:

- **Bring your own brain.** Ollama ist standardmäßig aktiviert, Anthropic und OpenAI können als Ersatzmodule verwendet werden. Providerwechsel erfolgt über INI-Dateien, nicht über den Code.
- **Eine JSON-Datei pro RAG-Sammlung.** Keine Vektordatenbank erforderlich. Wiederherstellungsicher nach einem Neustart. Grep-fähig bei der Fehlerbehebung.
- **Tools sind PHP-Klassen.** Erweitern Sie `Tool`, erhalten Sie einen Namen + Schema + eine Ausführungsmethode. Der Agent kümmert sich um den Rest.
- **Keine modellspezifischen Tool-Aufruf-APIs.** Eine einzige eingerahmte JSON-Konvention funktioniert überall.

## Nächste

- [Chat-Plugin-Referenz](/de/kI/modul/chat/)
- [RAG-Plugin-Referenz](/de/kI/modul/rag/)
- [Agent-Plugin-Referenz](/de/kI/modul/agent/)
- [Training nibiru-coder](/de/kI/modul/training/)
