Mit den einzelnen Modulen wurde mein System übersichtlicher. Wissen war nicht mehr dasselbe wie Lernen. Zustand war nicht dasselbe wie Recherche. Nicht jede Funktion brauchte Ollama. Und je mehr Aufgaben mein eigenes Programm übernehmen konnte, desto öfter stellte ich mir eine neue Frage:
Warum lasse ich das Sprachmodell eigentlich noch so viel entscheiden?
Du bist direkt hier eingestiegen? Dann lohnt sich der Weg zurück zu Schritt 1, denn Schritt 12 ist das Ergebnis vieler kleiner Umwege und Erkenntnisse.
Das ursprüngliche Prinzip
Am Anfang war der Ablauf sehr einfach:
- Frage
- Ollama
- Sprachmodell
- Antwort
Das Modell bekam eine Frage und sollte im Grunde alles selbst erledigen. Verstehen. Wissen benutzen. Entscheiden. Antwort formulieren. Für erste Versuche war das völlig ausreichend. Aber für mein eigentliches Ziel war mir das irgendwann zu wenig kontrollierbar.
Warum mich das störte
Wenn eine Antwort falsch war, konnte ich oft nur schwer erkennen, warum. Lag es an falschem Wissen? An einem schlechten Prompt? An fehlendem Kontext? Einer falschen Quelle? Oder einfach daran, dass das Modell eine plausible Antwort erzeugt hatte, die inhaltlich danebenlag?
Je mehr Verantwortung beim Sprachmodell lag, desto schwieriger wurde es für mich, den Weg zur Antwort nachzuvollziehen. Ich hatte das Gefühl, einem Blackbox-System zu vertrauen, ohne wirklich zu wissen, worauf sich seine Aussagen stützen.
Mein eigentliches Ziel
Ich wollte nicht, dass Ollama mir sagt, was mein System wissen soll. Ich wollte selbst bestimmen:
- welche Informationen überhaupt verwendet werden
- welche Quelle dafür zugelassen wird
- welche Aussage zur Frage passt
- was gespeichert werden darf
- was verworfen wird
- welche Regeln gelten
- wann überhaupt ein Sprachmodell gebraucht wird
Das sollte meine eigene Programmlogik übernehmen. Nicht das Modell.
Die neue Rolle von Ollama
Wenn mein eigenes System diese Arbeit bereits erledigt, muss das Sprachmodell am Ende nicht mehr alles selbst entscheiden. Es bekommt die Frage, die bereits ausgewählten Informationen, den passenden Auftrag und die Regeln für die gewünschte Antwort. Daraus soll es eine verständliche Formulierung erzeugen.
Sehr wichtig: Das ist keine Garantie, dass das Modell nie Fehler macht. Aber die Grundlage der Antwort kommt nicht mehr einfach aus dem freien Modellwissen. Sie kommt aus meinem System.
Vorher und nachher
Vorher:
- Frage
- Ollama
- Modell entscheidet weitgehend selbst
- Antwort
Später:
- Frage
- eigenes System
- Aufgabe erkennen
- Wissen suchen
- Informationen prüfen
- relevante Fakten auswählen
- Regeln anwenden
- Ollama formuliert
- Antwort
Ich erkläre hier bewusst keine fertige Eureka-Pipeline im Detail. Es geht um den Unterschied im Denken: Das Sprachmodell ist nicht mehr der Mittelpunkt, sondern ein Teil des Ablaufs.
Warum das für mich ein großer Unterschied war
Bis dahin hatte ich häufig versucht, Ollama mit besseren Prompts zuverlässiger zu machen. Jetzt änderte sich die Frage. Nicht mehr: „Wie bringe ich Ollama dazu, besser zu entscheiden?“ Sondern: „Warum soll Ollama diese Entscheidung überhaupt treffen?“
Wenn eine Entscheidung mit normaler Programmlogik, Regeln oder geprüften Daten getroffen werden kann, soll mein eigenes System sie übernehmen. So einfach war das für mich plötzlich.
Das Sprachmodell wurde vom Entscheider zum Werkzeug
Ollama beziehungsweise das lokale Sprachmodell war damit nicht mehr das Zentrum meines Systems. Es wurde ein Werkzeug. Ein sehr wichtiges Werkzeug. Aber eben nur ein Teil. So wie die Datenbank. So wie die Suche. So wie meine Module. Das eigentliche System entstand aus dem Zusammenspiel dieser Teile.
Was mein System selbst übernehmen sollte
Mein eigenes System sollte zunehmend selbst übernehmen:
- Recherche
- Auswahl von Informationen
- Prüfung von Informationen
- Zuordnung zur Frage
- Regeln
- Speicherentscheidungen
- Zustände
- Ablaufsteuerung
Ollama sollte möglichst erst danach ins Spiel kommen.
Warum das besser zu meiner ursprünglichen Idee passte
Ganz am Anfang wollte ich eine eigene KI, bei der ich verstehen kann, was auf meinem Rechner passiert. Mit einem Sprachmodell, das selbst fast alles entscheidet, war ich davon eigentlich wieder weit entfernt. Mit der neuen Architektur konnte ich immer mehr Entscheidungen sichtbar und nachvollziehbar in meinem eigenen Code treffen. Und genau deshalb fühlte sich das System für mich erstmals wirklich wie mein eigenes an.
An diesem Punkt begann Eureka meinen Vorstellungen zu entsprechen
Eureka war natürlich noch nicht fertig. Es gab weiterhin Fehler, offene Fragen und Dinge, die ich verbessern wollte. Aber die Richtung stimmte. Zum ersten Mal hatte ich nicht mehr das Gefühl, nur ein fertiges Sprachmodell mit immer mehr Zubehör zu benutzen. Ich hatte ein eigenes System, das ein Sprachmodell gezielt als Werkzeug einsetzen konnte. Und genau das war eigentlich das, was ich von Anfang an gesucht hatte.
Was daraus später noch entstand
Aus dieser Richtung entwickelten sich später weitere Themen: Recherche, Quellenbewertung, Speicherung, Prüfungen, Entscheidungspfade, Debugging und ein Admin-Dashboard. Aber diese Geschichte muss an dieser Stelle noch nicht vollständig weitererzählt werden. Der Leser soll verstehen: Ab hier beginnt für jeden sein eigener Weg.
Ab hier beginnt das eigene System
Wer bis hierher gekommen ist, muss nicht Eureka nachbauen. Genau das wäre sogar am Ziel vorbei. Ab diesem Punkt kann jeder entscheiden: Welche Fähigkeiten braucht mein System?
- ein Gedächtnis?
- Recherche?
- Automatisierung?
- Sprachsteuerung?
- eigene Daten?
- Sensoren?
- eine Weboberfläche?
- besondere Regeln?
Die Grundidee bleibt dieselbe: Baue nicht alles auf einmal. Baue eine Fähigkeit. Teste sie. Dann den nächsten Baustein.
Der persönliche Schlusspunkt
Ich bin damals ziemlich blauäugig gestartet mit dem Gedanken: „Ich baue mir meine eigene KI.“ Unterwegs musste ich immer wieder feststellen, dass vieles ganz anders funktioniert, als ich es mir vorgestellt hatte. Aber genau aus diesen Irrwegen entstand mein eigenes System. Nicht ChatGPT. Nicht irgendeine Kopie. Sondern etwas, das meinen eigenen Vorstellungen immer näher kam.
Schritt 12 ist geschafft, wenn …
- du verstanden hast, dass das Sprachmodell nicht das Zentrum deines Systems sein muss,
- du Entscheidungen in deine eigene Programmlogik legen kannst,
- Recherche, Wissen und Speicherung eigene Aufgaben sind,
- Ollama am Ende hauptsächlich zum Formulieren genutzt werden kann,
- der Weg zur Antwort dadurch besser kontrollierbar wird,
- dir klar ist, dass ein eigenes KI-System keine Kopie von ChatGPT sein muss,
- und du weißt: Ab diesem Punkt beginnt der individuelle Aufbau.
Abschluss der Story
Die Geschichte von Eureka geht natürlich weiter. Aber ab diesem Punkt beginnt eine andere Geschichte: die deines eigenen Systems.