Mein eigenes Programm konnte jetzt mit dem lokalen Sprachmodell sprechen. Ich gab eine Frage ein, mein Python-Skript schickte sie an Ollama, das Modell generierte eine Antwort und mein Programm gab sie auf dem Bildschirm aus. Das funktionierte tatsächlich.
Aber sobald ich das Programm beendete, war im Grunde wieder alles weg. Jede Unterhaltung begann bei Null. Das ärgerte mich schnell – und es weckte eine neue Frage:
Wie bringe ich meinem System bei, sich Informationen zu merken?
Der erste Gedanke: eine normale Datenbank
Für mich lag die Lösung zunächst auf der Hand: Wenn ein Programm sich etwas merken soll, dann speichert man es in einer Datenbank. Also begann ich mit MySQL. Kein besonderer Grund, außer dass ich damit schon ein wenig Erfahrung hatte und es überall verfügbar ist.
Und nein, ich will MySQL hier nicht schlechtreden. Im Gegenteil: Für normale strukturierte Daten ist eine relationale Datenbank ein sehr gutes Werkzeug. Ich konnte Informationen speichern, Datensätze anlegen, sie später wieder abrufen – und damit zum ersten Mal so etwas wie ein dauerhaftes Gedächtnis aufbauen. Genau das, was ich wollte.
Was plötzlich möglich wurde
Mit der Datenbank veränderte sich mein System grundlegend. Es konnte jetzt:
- Informationen dauerhaft speichern,
- vorhandene Einträge gezielt wiederfinden,
- Daten verändern oder ergänzen,
- unterscheiden, was bereits gespeichert war,
- und den gesamten Gesprächsverlauf auch nach einem Neustart behalten.
Das war ein echter Fortschritt. Zum ersten Mal blieb etwas außerhalb des Sprachmodells erhalten – mein System begann, eine eigene Geschichte zu haben.
Modellwissen und eigenes Wissen unterscheiden
Dabei fiel mir etwas Wichtiges auf: Ein Sprachmodell bringt bereits eine Menge Wissen aus seinem Training mit. Dieses Wissen kann ich aber nicht direkt beeinflussen. Es ist gewissermaßen eingefroren in den Gewichten der Modells. Die Datenbank war etwas anderes. Dort konnte ich selbst bestimmen, welche Informationen gespeichert werden, wie sie strukturiert werden und wann sie wieder verwendet werden. Damit entstand zum ersten Mal etwas, das wirklich zu meinem eigenen System gehörte – ein eigener Wissensbestand, unabhängig von dem allgemeingültigen Wissen des Modells.
Die erste Ernüchterung
Doch dieser schöne Fortschritt hatte auch eine Schattenseite. Eine klassische Datenbank kann Informationen sehr gut speichern – aber Speichern und Wiederfinden ist nicht dasselbe wie Verstehen.
Ein Beispiel: Wenn ich einen Datensatz unter dem Begriff „Python“ ablege, finde ich ihn später wieder, indem ich nach „Python“ suche. Das funktioniert einwandfrei. Aber Menschen stellen Fragen selten mit exakt denselben Wörtern. Sie sagen vielleicht „Programmiersprache“ oder „Skriptsprache“ oder sie fragen nach einem Zusammenhang, ohne denselben Begriff zu benutzen. In einer relationalen Datenbank gibt es dafür keine einfache Lösung. Entweder ich kenne den exakten Suchbegriff, oder ich versuche, mit komplizierten Suchabfragen und unzähligen Verknüpfungen dem Problem zu entkommen. Das wird schnell mühsam.
Kein Vektoren-Vorausblick – nur ein leiser Hinweis
An dieser Stelle hatte ich noch keine Ahnung von Vektorsuche oder Embeddings. Ich wusste nur: So wie es war, konnte es nicht weitergehen. Eine Datenbank löst das Problem der dauerhaften Speicherung – aber sie löst nicht automatisch das Problem, die richtige Information zu einer frei formulierten Frage wiederzufinden. Diese Erkenntnis musste erst reifen.
Mein damaliger Denkfehler
Anfangs dachte ich nämlich: Wenn ich genug Informationen speichere, wird mein System automatisch immer besser. Also legte ich fleißig Gesprächsprotokolle und Notizen in MySQL ab. Irgendwann merkte ich jedoch: Die Menge der gespeicherten Daten ist nicht das Entscheidende. Wenn ich später nicht zuverlässig herausfinden kann, welche Information gerade gebraucht wird, habe ich zwar viele Daten – aber noch lange kein brauchbares Wissenssystem.
Das war ein wichtiger Unterschied für mich: Daten besitzen ist nicht dasselbe wie Wissen sinnvoll benutzen zu können.
Der Beginn des Lernens
An diesem Punkt stellte sich für mich auch grundsätzlich die Frage: Was bedeutet „Lernen“ in meinem eigenen System überhaupt? Ich wollte nicht behaupten, dass die Datenbank selbst lernt. Für mich war Lernen zunächst etwas viel Einfacheres:
- Eine neue Information erkennen,
- sie sinnvoll speichern,
- und sie später wiederverwenden können.
Damit entstand langsam eine Trennung zwischen Wissen, Lernen, Sprachmodell und eigener Programmlogik. Eine fertige Architektur war das noch nicht – es war eher ein erstes Bewusstsein dafür, dass diese Teile verschiedene Aufgaben haben.
Noch war alles überschaubar
In dieser Phase wirkte das Ganze noch relativ simpel. Python konnte mit Ollama sprechen, MySQL konnte Informationen speichern. Ich konnte anfangen, eigene Regeln darum herum zu bauen – etwa: Nach welchen Gesprächen soll etwas gespeichert werden? Welche Teile sind wichtig? Wie ordne ich Informationen einem Thema zu? Es fühlte sich an, als müsste ich jetzt nur noch immer mehr Wissen hinzufügen. Doch genau dieser Gedanke führte mich direkt zum nächsten Problem.
Der nächste Lernschritt
Je mehr Informationen ich speichern wollte, desto wichtiger wurde die Frage: Wie findet mein System später genau die Information wieder, die zu einer Frage passt? Und zwar nicht nur dann, wenn exakt dieselben Wörter verwendet werden – sondern auch dann, wenn zwei Formulierungen dasselbe oder etwas sehr Ähnliches meinen.
Damit kam ich zum ersten Mal damit in Berührung, was Vektoren, Embeddings und eine Vektorsuche bedeuten. Aber das ist bereits die Geschichte für Schritt 6. An dieser Stelle reicht die Erkenntnis, dass eine klassische Datenbank allein nicht reicht – und dass der nächste große Schritt das Wiederfinden von Bedeutung ist.
Schritt 5 ist geschafft, wenn …
Keine Installations-Checkliste – sondern ein paar Erkenntnisse, die du aus diesem Schritt mitnehmen solltest:
- Ein Sprachmodell und mein eigenes gespeichertes Wissen sind zwei verschiedene Dinge.
- Eine normale Datenbank kann Informationen dauerhaft speichern – das ist ein echter Meilenstein.
- MySQL war für meine ersten Versuche völlig sinnvoll, auch wenn ich heute andere Werkzeuge benutze.
- Speichern allein macht aus Daten noch kein brauchbares Wissenssystem.
- Die entscheidende Frage wird später sein: Wie finde ich die richtige Information wieder?
Du arbeitest bereits mit einer eigenen Wissensdatenbank und kennst das Problem, ähnliche Inhalte wiederzufinden? Dann kannst du direkt mit Schritt 6 weitermachen – dort beginnt das Thema Vektoren und semantische Suche.