KI selber bauen – Schritt 4: Mein erstes eigenes Programm spricht mit der KI

Im letzten Schritt war der entscheidende Moment erreicht: Ich konnte direkt mit Ollama sprechen, und das lokale Modell auf meinem Rechner hat geantwortet. Das war eindrucksvoll – aber ehrlich gesagt: Ich habe dabei nur ein fertiges Programm bedient.

Jetzt beginnt Schritt 4. Diesmal möchte ich mein erstes eigenes Python-Programm zwischen mich und Ollama schalten. Das Ziel ist bewusst klein:

Ich schreibe eine Frage in mein eigenes Python-Programm.
Mein Programm schickt die Frage an Ollama.
Das Modell erzeugt die Antwort.
Mein Programm bekommt die Antwort zurück und zeigt sie an.

Ganz wichtig: Die Antwort kommt weiterhin vom Sprachmodell. Unser Python-Programm ist noch nicht selbst intelligent. Es übernimmt zunächst nur die Steuerung: Frage entgegennehmen, an Ollama schicken, auf Antwort warten, Antwort anzeigen.

Serien-Navigation: Wenn du Schritt 4 durchgearbeitet hast, hast du genau den Stand erreicht, mit dem Schritt 5 startet. Python und Ollama laufen bei dir, dein eigenes Programm spricht das Modell an. Dann kannst du direkt mit Schritt 5 weitermachen. Die URL trage ich ein, sobald sie feststeht.

Was wir jetzt eigentlich bauen

Unser erster eigener Ablauf sieht so aus:

Ich
↓
mein Python-Programm
↓
Ollama
↓
lokales Modell
↓
Ollama
↓
mein Python-Programm
↓
Antwort

Das ist bewusst überschaubar. Das Modell bleibt das Herzstück. Aber unser Programm übernimmt jetzt die Kontrolle davor und danach. Es entscheidet, wann eine Frage an das Modell geht, und es bekommt die Antwort zurück. Dadurch entsteht langsam ein eigenes System.

Python ist nicht die KI. Ollama ist nicht die KI. Unser Programm erzeugt die Antwort auch nicht selbst. Das Sprachmodell erzeugt sie weiterhin. Unser Programm beginnt nur, den Ablauf zu kontrollieren.

Arbeitsordner vorbereiten

Für Ubuntu legen wir zuerst einen einfachen Projektordner an:

mkdir -p ~/ki-selber-bauen/schritt4
cd ~/ki-selber-bauen/schritt4

Dann erstellen wir eine virtuelle Python-Umgebung:

python3 -m venv venv

Aktivieren:

source venv/bin/activate

Die virtuelle Umgebung hält die Python-Pakete dieses kleinen Projekts von anderen Python-Projekten getrennt. Das ist kein Hexenwerk, sondern einfach Ordnung. Wenn du später andere Python-Sachen ausprobierst, stört dieses Projekt sie nicht.

Requests installieren

Wir wollen Ollama über seine lokale Schnittstelle ansprechen. Dafür nutzen wir das Python-Paket requests.

pip install requests

Damit kann unser Python-Programm eine Anfrage an Ollama senden. Mehr brauchen wir an dieser Stelle nicht.

Prüfen, welches Modell vorhanden ist

Bevor wir Code schreiben, schauen wir nach, welches Modell bei dir überhaupt vorhanden ist. Im Terminal:

ollama list

Dort steht der genaue Name des Modells, das du in Schritt 3 geladen hast. Diesen Namen brauchen wir gleich im Python-Programm. Nimm also nicht irgendeinen Modellnamen aus dem Internet, sondern den Namen, der bei dir in der Liste erscheint.

Das erste eigene Python-Programm

Jetzt legen wir eine Python-Datei an. Du kannst dazu nano im Terminal benutzen oder einen normalen Texteditor:

nano erste_ki.py

Dann tragen wir diesen Code ein:

import requests

MODEL = "DEIN_MODELL"

def frage_modell(frage):
    response = requests.post(
        "http://127.0.0.1:11434/api/chat",
        json={
            "model": MODEL,
            "messages": [
                {
                    "role": "user",
                    "content": frage
                }
            ],
            "stream": False
        },
        timeout=120
    )

    response.raise_for_status()

    daten = response.json()

    return daten["message"]["content"]


frage = input("Meine Frage: ")

antwort = frage_modell(frage)

print()
print("Antwort:")
print(antwort)

Wichtig: DEIN_MODELL ist nur ein Platzhalter. Ersetze diesen Text durch den genauen Namen aus ollama list.

Was passiert in diesem Code?

Wir müssen nicht jede Python-Zeile wie in einem Programmierkurs durchgehen. Aber die wichtigsten Schritte solltest du erkennen:

MODEL legt fest, welches lokale Modell wir benutzen.
input() nimmt unsere Frage entgegen.
requests.post() schickt die Frage an Ollama.
Ollama übergibt die Nachricht an das ausgewählte Modell.
Das Modell erzeugt die Antwort.
Ollama gibt diese Antwort an unser Python-Programm zurück.
print() zeigt den Text auf dem Bildschirm an.

Besonders wichtig: Die eigentliche sprachliche Antwort erzeugt weiterhin das Modell. Unser Programm kontrolliert bisher nur den Weg der Informationen.

Programm starten

Stelle sicher, dass Ollama läuft. Dann kannst du das Programm starten:

python erste_ki.py

Zum Beispiel so:

Meine Frage: Warum fällt ein Apfel auf den Boden?

Antwort:
...

Die tatsächliche Antwort hängt von deinem verwendeten Modell ab. Sie kann bei dir anders aussehen. Das ist völlig normal.

Der für mich wichtige Aha-Moment

Für mich kam dieser Moment, als die Antwort zum ersten Mal wieder in meinem eigenen Programm auftauchte. Vorher hatte ich direkt mit Ollama gesprochen. Jetzt stand mein Code dazwischen.

Ich habe nichts an Ollama verändert. Das Modell war dasselbe wie vorher. Aber plötzlich lief die Anfrage durch mein Programm. Das fühlt sich anders an, weil man beginnt, die Kontrolle zu übernehmen.

Genau an diesem Punkt wird aus „Ollama benutzen“ langsam „ein eigenes System bauen“.

Was wir jetzt schon kontrollieren können

Unser Programm ist noch klein, aber die Weiche ist gestellt. Weil Anfrage und Antwort jetzt durch unseren Code laufen, könnten wir zum Beispiel:

eine Frage verändern, bevor sie an das Modell geht
zusätzliche Anweisungen mitsenden
eine Antwort prüfen
eine Antwort speichern
entscheiden, ob überhaupt ein Modell gefragt werden soll
später Informationen aus anderen Quellen hinzufügen

Das bauen wir jetzt noch nicht ein. Aber es zeigt: Hier beginnt der Raum für unsere eigene Logik.

Noch keine eigene KI im großen Sinn

Damit wir nicht abheben, eine kurze Einordnung.

Wir haben jetzt:

einen eigenen Programmablauf
ein lokales Modell
eine Verbindung zwischen beiden

Wir haben noch nicht:

eigenes Wissen
eigenes Gedächtnis
eigene Recherche
eine Datenbank
Lernen
eine ausgearbeitete Entscheidungslogik

Das ist völlig in Ordnung. Wir bauen das System Schritt für Schritt.

Schritt 4 ist geschafft, wenn …

Ollama läuft.
das lokale Modell vorhanden ist.
Python in einer virtuellen Umgebung läuft.
requests installiert ist.
erste_ki.py startet.
eine Frage aus unserem Python-Programm an Ollama geschickt wird.
die Antwort wieder in unserem Programm erscheint.
du verstehst, dass das Modell die Antwort erzeugt und dein Programm bisher den Ablauf steuert.

Ausblick auf Schritt 5

Im nächsten Schritt geben wir unserem System eigene Regeln beziehungsweise Anweisungen. Noch sprechen wir nicht über Datenbanken, Gedächtnis oder Lernen. Aber wir zeigen, dass unser eigenes Programm beeinflussen kann, wie eine Anfrage an das Modell gestellt wird und was anschließend mit der Antwort passiert.

Damit gehen wir den nächsten Schritt von „Mein Programm benutzt ein Modell“ zu „Mein Programm bestimmt zunehmend, wie das gesamte System arbeitet“.

Weiter geht es mit Schritt 5.