Zum Inhalt springen

Einen KI-Assistenten mit lokalen Modellen bauen · Teil 2 von 13 der Serie

Teil 2: Aus dem Code mit dem Modell sprechen

Schick deine erste Anfrage aus TypeScript an das lokale Modell, lern, wie ein Gespräch für ein Modell aussieht, und bau einen kleinen Chat im Terminal, der die Antwort zeigt, während sie geschrieben wird.

Quest-Ziele

  • Ein TypeScript-Projekt einrichten, das Node.js ohne Build-Schritt ausführt
  • Eine Anfrage an Ollama schicken und die Antwort lesen
  • Nachrichten und Rollen verstehen, und warum das Modell kein Gedächtnis hat
  • Eine Antwort Stück für Stück zeigen, während das Modell sie schreibt
  • Eine Chat-Schleife im Terminal bauen

Im ersten Teil hast du in Ollamas eigenem Chat mit dem Modell gesprochen. Jetzt schreibst du das Programm am anderen Ende selbst. Es ist weniger, als du vielleicht denkst: Das Modell sitzt hinter einer Webadresse auf deinem Rechner, und ein Gespräch ist eine Liste von Nachrichten, die du dorthin schickst.

Das Projekt

Du brauchst Node.js, Version 24 oder neuer. Prüf deine:

~
$ node --versionv26.13.0

Leg einen Ordner für den Assistenten an und installier TypeScript:

~/projects
$ mkdir pixel-assistant$ cd pixel-assistant$ mkdir src$ npm install --save-dev typescript @types/nodeadded 4 packages, and audited 5 packages in 1s

Die Serie verwendet TypeScript, also JavaScript mit Typen: Du sagst, welche Form deine Daten haben, und der Editor weist dich auf Fehler hin, bevor das Programm läuft. Node.js führt .ts-Dateien direkt aus, indem es die Typen ignoriert, es gibt also nichts zu kompilieren. Leg im Ordner die package.json an (falls npm schon eine geschrieben hat, ersetz alles außer den devDependencies):

package.json
{
  "name": "pixel-assistant",
  "private": true,
  "type": "module",
  "scripts": {
    "chat": "node src/chat.ts",
    "typecheck": "tsc"
  }
}

"type": "module" erlaubt den Dateien import und export. Die beiden Skripte sind Abkürzungen, die du gleich benutzt. Die Typprüfung braucht ein paar eigene Einstellungen, in der tsconfig.json:

tsconfig.json
{
  "compilerOptions": {
    "module": "nodenext",
    "target": "esnext",
    "types": ["node"],
    "strict": true,
    "noEmit": true,
    "allowImportingTsExtensions": true,
    "erasableSyntaxOnly": true,
    "verbatimModuleSyntax": true,
    "skipLibCheck": true
  },
  "include": ["src"]
}

Auswendig kennen musst du sie nicht. Sie sagen TypeScript, dass es den Code nur prüfen und nichts schreiben soll (noEmit), und dass es auf der Art von TypeScript bestehen soll, die Node.js so ausführen kann, wie sie ist.

Die erste Anfrage

Leg src/hello.ts an:

src/hello.ts
const response = await fetch('http://localhost:11434/api/chat', {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({
    model: 'qwen3:4b-instruct',
    messages: [{ role: 'user', content: 'Say hello in five words.' }],
    stream: false,
  }),
});

const data = await response.json();
console.log(data.message.content);
~/projects/pixel-assistant
$ node src/hello.tsHello there, nice to meet you!

Das ist ein vollständiges Programm, das mit einem Sprachmodell spricht. fetch schickt eine Anfrage an die Adresse von Ollama, so wie ein Browser an eine Website. Die Anfrage nennt das Modell und enthält das bisherige Gespräch, hier eine einzige Nachricht. stream: false bittet um die ganze Antwort in einem Stück. Zurück kommt JSON; das Programm hat ein Feld davon ausgegeben. Das hier ist alles:

json
{
  "model": "qwen3:4b-instruct",
  "created_at": "2026-11-17T08:12:45.416799Z",
  "message": {
    "role": "assistant",
    "content": "Hello there, nice to meet you!"
  },
  "done": true,
  "done_reason": "stop",
  "total_duration": 1191566416,
  "load_duration": 2154458,
  "prompt_eval_count": 16,
  "prompt_eval_duration": 83809000,
  "eval_count": 9,
  "eval_duration": 399921000
}

Die Antwort ist eine Nachricht wie die, die du geschickt hast, mit der Rolle assistant. Die Zahlen darunter sagen dir, was passiert ist: Das Modell hat 16 Tokens gelesen (prompt_eval_count) und 9 geschrieben (eval_count). Die Dauern stehen in Nanosekunden da, das Schreiben hat hier also 0,4 Sekunden gedauert. Teil die geschriebenen Tokens durch diese Zeit, und du hast die Geschwindigkeit des Modells auf deinem Rechner in Tokens pro Sekunde, die Zahl, auf die du achtest, wenn du ein anderes Modell ausprobierst.

Nachrichten und Rollen

Jede Nachricht hat eine Rolle, die sagt, wer spricht:

  • user: der Mensch, der mit dem Modell spricht.

  • assistant: die früheren Antworten des Modells selbst.

  • system: Anweisungen des Programms rund um das Modell. Damit machst du im nächsten Teil aus dem Modell Pixel.

Erinnere dich an den ersten Teil: Das Modell behält nichts zwischen zwei Anfragen. Soll es wissen, was vor einer Minute gesagt wurde, musst du es noch einmal schicken, jedes Mal, als Liste der Nachrichten. Ein Chat ist ein Programm, das diese Liste führt und sie mit jeder neuen Frage vollständig mitschickt.

Ein kleiner Client

Die Adresse und der Name des Modells sollten nicht über den Code verstreut sein. Schreib sie in src/config.ts:

src/config.ts
/** The settings of the assistant, in one place. An environment variable wins over the default. */
export const OLLAMA_URL = process.env.OLLAMA_URL ?? 'http://localhost:11434';
export const MODEL = process.env.MODEL ?? 'qwen3:4b-instruct';

process.env enthält die Umgebungsvariablen, du kannst also später mit MODEL=llama3.2:3b npm run chat ein anderes Modell ausprobieren, ohne den Code anzufassen. Jetzt der Teil, der mit Ollama spricht, src/ollama.ts:

src/ollama.ts
import { MODEL, OLLAMA_URL } from './config.ts';

export interface Message {
  role: 'system' | 'user' | 'assistant';
  content: string;
}

async function post(path: string, body: object): Promise<Response> {
  const response = await fetch(`${OLLAMA_URL}${path}`, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify(body),
  });
  if (!response.ok) throw new Error(`Ollama answered ${response.status}: ${await response.text()}`);
  return response;
}

/** Sends the conversation to the model and returns its whole answer. */
export async function chat(messages: Message[]): Promise<Message> {
  const response = await post('/api/chat', { model: MODEL, messages, stream: false, think: false });
  const data = (await response.json()) as { message: Message };
  return data.message;
}

/** Sends the conversation to the model and hands out its answer piece by piece. */
export async function* chatStream(messages: Message[]): AsyncGenerator<string> {
  const response = await post('/api/chat', { model: MODEL, messages, stream: true, think: false });
  const decoder = new TextDecoder();
  let rest = '';
  for await (const chunk of response.body!) {
    rest += decoder.decode(chunk, { stream: true });
    // one JSON object per line; the last line may still be incomplete
    const lines = rest.split('\n');
    rest = lines.pop()!;
    for (const line of lines) {
      if (!line.trim()) continue;
      const part = JSON.parse(line) as { message: Message };
      yield part.message.content;
    }
  }
}

Von oben nach unten:

  • Message beschreibt eine Nachricht. Ab jetzt meldet sich der Editor, wenn du eine Rolle falsch schreibst.

  • post schickt eine Anfrage und macht aus einer Fehlerantwort von Ollama, etwa bei einem Modell, das nicht heruntergeladen ist, einen Fehler, den du lesen kannst.

  • chat tut, was hello.ts getan hat: die Nachrichten schicken, die ganze Antwort bekommen.

  • chatStream bittet um die Antwort Stück für Stück, so wie du sie im ersten Teil hast erscheinen sehen.

So funktioniert Streaming

Mit stream: true wartet Ollama nicht, bis die Antwort fertig ist. Es schickt für jedes Stück eine Zeile JSON, sobald das Modell es geschrieben hat, und eine letzte Zeile mit "done": true und den Zahlen:

text
{"model":"qwen3:4b-instruct","created_at":"...","message":{"role":"assistant","content":"Hello"},"done":false}
{"model":"qwen3:4b-instruct","created_at":"...","message":{"role":"assistant","content":" there"},"done":false}
{"model":"qwen3:4b-instruct","created_at":"...","message":{"role":"assistant","content":","},"done":false}
...
{"model":"qwen3:4b-instruct","created_at":"...","message":{"role":"assistant","content":""},"done":true,"done_reason":"stop","eval_count":9,"eval_duration":399921000}

chatStream liest, was ankommt, zerschneidet es an den Zeilenumbrüchen und gibt den content jeder Zeile heraus. Eine Zeile kann in zwei Hälften ankommen, deshalb hebt die Funktion den unfertigen Rest für die nächste Runde auf. function* und yield machen sie zu einem Generator: einer Funktion, die viele Werte herausgibt, einen nach dem anderen, und der Aufrufer sammelt sie mit for await ein.

Der Chat

Leg src/chat.ts an:

src/chat.ts
import { createInterface } from 'node:readline/promises';
import { chatStream, type Message } from './ollama.ts';

const terminal = createInterface({ input: process.stdin, output: process.stdout });
// Ctrl+D closes the input: leave without an error
terminal.on('close', () => process.exit());
/** The whole conversation so far. The model sees all of it with every request. */
const messages: Message[] = [];

console.log('Talk to the model. /bye ends the chat.\n');

while (true) {
  const text = (await terminal.question('you> ')).trim();
  if (text === '/bye') break;
  if (!text) continue;

  messages.push({ role: 'user', content: text });
  process.stdout.write('model> ');
  let answer = '';
  for await (const piece of chatStream(messages)) {
    process.stdout.write(piece);
    answer += piece;
  }
  process.stdout.write('\n');
  messages.push({ role: 'assistant', content: answer });
}
terminal.close();

Die Schleife fragt dich nach einer Zeile, hängt sie an messages an, schickt die ganze Liste und gibt die Stücke aus, wie sie kommen. Dann hängt sie auch die Antwort des Modells an die Liste an, damit die nächste Anfrage sie mitnimmt. Teste das Gedächtnis des Modells:

~/projects/pixel-assistant
$ npm run chatTalk to the model. /bye ends the chat.you> Ich heiße Robin. Merk dir das.model> Freut mich, Robin! Das behalte ich für den Rest unseres Gesprächs im Kopf.you> Wie heiße ich?model> Du heißt Robin.you> /bye

Es kennt deinen Namen, weil die zweite Anfrage das ganze Gespräch enthielt. Schick stattdessen nur die neue Frage, indem du chatStream(messages) in chatStream([{ role: 'user', content: text }]) änderst, und es hat dich sofort vergessen.

Ein letzter Befehl. Er lässt die Typprüfung über deinen Code laufen, und wenn er nichts ausgibt, hat sie nichts gefunden:

~/projects/pixel-assistant
$ npm run typecheck

Du hast jetzt einen Chat mit einem Sprachmodell in fünfzig Zeilen. Es ist höflich, es ist wortreich, und es hat keine Ahnung, wer es ist. Im nächsten Teil wird es zu Pixel: Es bekommt eine Persona, erfährt das heutige Datum, und du ordnest den Prompt so an, dass die Antworten schnell bleiben.

Kommentare

Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.

Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.