Zum Inhalt springen

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

Teil 3: Eine Persona und ein Prompt, der schnell bleibt

Mach mit einem System-Prompt aus dem Modell Pixel, sag ihm mit jeder Anfrage Datum und Uhrzeit, halt das Gespräch kurz und ordne den Prompt so an, dass das Modell seine Arbeit wiederverwenden kann.

Quest-Ziele

  • Dem Modell mit einem System-Prompt eine Persona geben
  • Alles, was von der Sprache abhängt, in einer Datei halten
  • Dem Modell das Datum, die Uhrzeit und einen kleinen Kalender mitgeben
  • Nur die letzten paar Wortwechsel behalten
  • Den Prompt so ordnen, dass Ollama wiederverwenden kann, was es schon gelesen hat

Der Chat aus dem letzten Teil redet wie jeder Chatbot: freundlich, weitschweifig und über alles. Ein Assistent, der seine Antworten eines Tages in deiner Küche spricht, muss sich kurz fassen, und er sollte einen eigenen Charakter haben. Beides kommt von derselben Stelle: Text, den dein Programm vor das Gespräch stellt.

Der System-Prompt

Eine Nachricht mit der Rolle system steht als erste in der Liste und sagt dem Modell, wer es ist und wie es sich verhalten soll. Das Modell behandelt sie als die Regeln des Gesprächs. Das hier ist die von Pixel. Leg src/language.ts an:

src/language.ts
/**
 * Alles, was von der Sprache abhängt, die Pixel spricht: seine Persona, die Wörter, auf die
 * es hört, und die Sätze, die es selbst sagt. Für eine andere Sprache übersetzt du diese Datei.
 */
export const LOCALE = 'de-DE';

export const PERSONA = `
Du bist Pixel, der Assistent eines kleinen Zuhauses. Du sprichst mit den Menschen, die hier wohnen.

So sprichst du:
- Kurz und freundlich, mit trockenem Humor. Ein oder zwei Sätze.
- Einfache gesprochene Sprache: keine Listen, kein Markdown, keine Emojis.
- Du antwortest auf Deutsch und duzt alle.

Das machst du:
- Wenn du etwas nicht weißt, sag das in einem Satz. Rate nicht.
`.trim();

/** Die Beschriftungen der Notiz, die vor jeder Anfrage steht. */
export const LABELS = {
  now: 'Jetzt',
  nextDays: 'Die nächsten Tage',
};

Ein paar Dinge sorgen dafür, dass ein System-Prompt funktioniert, besonders bei einem kleinen Modell:

  • Sag klar, was du willst. „Ein oder zwei Sätze“ funktioniert. „Fass dich kurz“ nicht.

  • Halt ihn kurz. Jede Zeile wird mit jeder Anfrage neu gelesen, und ein kleines Modell fängt an, Regeln zu ignorieren, wenn es zwanzig davon sind.

  • Gib ihm einen Ausweg. Die letzte Zeile erlaubt dem Modell zu sagen, dass es etwas nicht weiß. Ohne sie erfindet ein Modell lieber etwas und klingt dabei sicher.

Die Datei heißt language.ts, weil in ihr alles stehen wird, was von der Sprache abhängt, die Pixel spricht: jetzt die Persona, später die Wörter, auf die Pixel hört, und die Sätze, die es von sich aus sagt. Pixel eine andere Sprache beizubringen heißt dann, diese eine Datei zu übersetzen, und kaum mehr.

Ergänz den Namen des Assistenten in src/config.ts:

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

Was das Modell nicht wissen kann

Frag den Chat aus dem letzten Teil, welcher Tag heute ist, und er entschuldigt sich oder erfindet einen. Das Modell ist eine Datei aus der Vergangenheit. Was jetzt gilt, muss in der Anfrage stehen: das Datum, die Uhrzeit, später das Wetter und was Pixel sich über dich gemerkt hat. Leg src/prompt.ts an:

src/prompt.ts
import { LABELS, LOCALE } from './language.ts';

const day = new Intl.DateTimeFormat(LOCALE, { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
const time = new Intl.DateTimeFormat(LOCALE, { hour: '2-digit', minute: '2-digit', hour12: false });

/**
 * What changes from one request to the next: the date and time and a small calendar. It
 * goes in front of the user's words, not into the system prompt.
 */
export function contextBlock(now = new Date()): string {
  const lines = [`${LABELS.now}: ${day.format(now)}, ${time.format(now)}`];
  // small models are bad at counting weekdays, so the next days come ready-made
  const next = Array.from({ length: 6 }, (_, i) => day.format(new Date(now.getTime() + (i + 1) * 86_400_000)));
  lines.push(`${LABELS.nextDays}: ${next.join('; ')}`);
  return `[${lines.join('\n')}]`;
}

/** Makes an answer fit to be spoken: no markdown, links or emojis, and at most two sentences. */
export function spoken(text: string, maxSentences = 2): string {
  const plain = text
    .replace(/```[\s\S]*?```/g, ' ')
    .replace(/https?:\/\/\S+/g, '')
    .replace(/[*_#`>|]/g, '')
    .replace(/\p{Extended_Pictographic}/gu, '')
    .replace(/\s+/g, ' ')
    .trim();
  const sentences = plain.match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) ?? [];
  return sentences.slice(0, maxSentences).map((sentence) => sentence.trim()).join(' ');
}

contextBlock schreibt eine kleine Notiz, die vor dem steht, was der Nutzer gesagt hat. Das Modell sieht dann das hier als Nachricht des Nutzers:

text
[Jetzt: Dienstag, 17. November 2026, 09:14
Die nächsten Tage: Mittwoch, 18. November 2026; Donnerstag, 19. November 2026; Freitag, 20. November 2026; Samstag, 21. November 2026; Sonntag, 22. November 2026; Montag, 23. November 2026]
Welches Datum ist am Freitag?

Die zweite Zeile sieht seltsam aus, aber sie ist wichtig. Kleine Modelle können nicht mit dem Kalender rechnen: Nach dem Datum am Freitag gefragt, raten sie. Stehen die nächsten Tage ausgeschrieben da, muss das Modell den Freitag nur noch finden, und das kann es. Dieses Muster begegnet dir immer wieder: Lass das Modell nicht ausrechnen, was eine Zeile Code für es ausrechnen kann.

Intl.DateTimeFormat ist in JavaScript eingebaut und schreibt Datumsangaben so, wie eine Sprache es tut, deshalb gehört LOCALE zu language.ts.

spoken ist das Sicherheitsnetz hinter dem System-Prompt. Ein Modell, dem „kein Markdown, zwei Sätze“ gesagt wurde, rutscht trotzdem hin und wieder aus, also entfernt die Funktion, was sich nicht sprechen lässt, und schneidet die Antwort nach zwei Sätzen ab.

Ein kurzes Gedächtnis

Der Chat aus dem letzten Teil hat jedes Mal das ganze Gespräch geschickt. Das wird mit jedem Wortwechsel langsamer, weil das Modell alles noch einmal liest, und eines Tages passt es nicht mehr ins Kontextfenster. Einem Assistenten reichen die letzten paar Wortwechsel: Mit ihnen versteht er „und in der Küche auch“. Leg src/history.ts an:

src/history.ts
import type { Message } from './ollama.ts';

/** The last few exchanges, so the model understands "and the kitchen too". */
const turns: Message[] = [];

export function recent(): Message[] {
  return turns;
}

export function keep(text: string, speech: string): void {
  turns.push({ role: 'user', content: text }, { role: 'assistant', content: speech });
  // three exchanges are enough, and a short prompt is a fast prompt
  turns.splice(0, Math.max(0, turns.length - 6));
}

Das Modell fragen

Jetzt setzt du alles in src/model.ts zusammen:

src/model.ts
import { keep, recent } from './history.ts';
import { PERSONA } from './language.ts';
import { chat, type Message } from './ollama.ts';
import { contextBlock, spoken } from './prompt.ts';

export interface Reply {
  speech: string;
}

/** Asks the local model and returns its answer, ready to be spoken. */
export async function askModel(text: string): Promise<Reply> {
  const messages: Message[] = [
    // first what never changes, so Ollama can reuse its work from the last request ...
    { role: 'system', content: PERSONA },
    ...recent(),
    // ... and last what is new
    { role: 'user', content: `${contextBlock()}\n${text}` },
  ];
  const answer = await chat(messages);
  const speech = spoken(answer.content);
  keep(text, speech);
  return { speech };
}

Sieh dir die Reihenfolge der Nachrichten an. Sie ist kein Zufall.

Bevor ein Modell schreiben kann, muss es den ganzen Prompt lesen, Token für Token, und das kostet Zeit. Ollama merkt sich, was es für die letzte Anfrage gelesen hat, und wenn die nächste Anfrage genauso anfängt, überspringt es diesen Teil. Die Regel lautet also: Was sich nie ändert, steht vorn, was sich ändert, steht hinten. Der System-Prompt ist jedes Mal derselbe, also steht er an erster Stelle. Datum und Uhrzeit ändern sich jede Minute, also stehen sie ganz am Ende, vor den Worten des Nutzers, und nicht im System-Prompt, wo sie den Anfang jeder Anfrage verderben würden. Auf dem echten Assistenten dauert es so rund 150 Millisekunden, eine Anfrage von etwa 1.700 Tokens zu lesen.

Beachte auch, dass keep die Worte des Nutzers ohne die Notiz speichert. Die Notiz stimmt nur für einen Moment.

Die Antworten sind jetzt kurz, sie müssen also nicht mehr Stück für Stück erscheinen, und ab hier wartet der Assistent auf die ganze Antwort. Es gibt noch einen besseren Grund, den du in Teil 7 kennenlernst: Pixel wird eine Antwort prüfen, bevor sie jemand sieht, und einen halben Satz kann man nicht zurücknehmen. Gib chat in src/ollama.ts zwei Optionen:

src/ollama.ts
/** 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,
    options: { temperature: 0.2, num_predict: 300 },
  });
  const data = (await response.json()) as { message: Message };
  return data.message;
}

temperature bestimmt, wie viel Zufall das Modell benutzt, wenn es das nächste Token wählt. Bei 0,2 nimmt es meist das wahrscheinlichste, was einen Assistenten zuverlässiger macht; nahe 1 wird es einfallsreicher und liegt öfter falsch. num_predict stoppt das Modell nach 300 Tokens, damit eine Antwort, die davonläuft, dich nicht eine Minute warten lässt.

Der Chat, jetzt mit Pixel

Ersetz src/chat.ts:

src/chat.ts
import { createInterface } from 'node:readline/promises';
import { NAME } from './config.ts';
import { askModel } from './model.ts';

const terminal = createInterface({ input: process.stdin, output: process.stdout });
// Ctrl+D closes the input: leave without an error
terminal.on('close', () => process.exit());
const name = NAME.toLowerCase();

console.log(`Talk to ${NAME}. /bye ends the chat.\n`);

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

  const answer = await askModel(text);
  console.log(`${name}> ${answer.speech}`);
}
terminal.close();
~/projects/pixel-assistant
$ npm run chatTalk to Pixel. /bye ends the chat.you> Wer bist du?pixel> Ich bin Pixel, der Assistent dieses Zuhauses. Klein, aber bemüht.you> Welches Datum ist am Freitag?pixel> Freitag ist der 20. November.you> Schreib mir ein Gedicht über Lampen mit zehn Strophen.pixel> Lampen leuchten, damit wir nicht gegen Möbel laufen. Das ist die Kurzfassung, und eine andere bekommst du von mir nicht.you> /bye

Dasselbe Modell, derselbe Rechner, ein anderer Charakter. Pixel kennt das Datum, fasst sich kurz und hat eine Meinung zu Gedichten.

Pixel kann jetzt reden, aber es kann nichts tun. Bitte es, eine Lampe einzuschalten, und es behauptet fröhlich, das sei erledigt. Im nächsten Teil gibst du ihm ein Zuhause mit Lampen und die wichtigste Fähigkeit eines Assistenten: Werkzeuge aufzurufen.

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.