Zum Inhalt springen

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

Teil 6: Schnelle Regeln vor dem Modell

Beantworte die einfachen Befehle mit schlichten Regeln in unter einer Millisekunde, und bau den Router, der zuerst den schnellsten Weg probiert und alles andere an das Modell weiterreicht.

Quest-Ziele

  • Verstehen, warum nicht jede Anfrage zum Modell gehen sollte
  • Regeln schreiben, die nur beantworten, was sie vollständig verstehen
  • Ausrechnen, was ausgerechnet gehört: die Uhrzeit und Rechenaufgaben
  • Einen Router mit Stufen bauen, die Anfragen weiterreichen
  • Sehen, welche Stufe geantwortet hat und wie lange es gedauert hat

„Küche an.“ An diesem Satz gibt es nichts zu verstehen. Ein Raum, ein Zustand. Und trotzdem geht er an ein Sprachmodell, das ein paar hundert Tokens Prompt und Werkzeuge liest, darüber nachdenkt und einen Werkzeugaufruf schreibt, eine Sekunde lang oder länger. Beim echten Assistenten hinter dieser Serie hat ein Lampenbefehl über das Modell etwa 1,4 Sekunden gedauert. Derselbe Befehl über eine Regel braucht ein paar Millisekunden: Die Lampe ist an, bevor du den Satz zu Ende gesprochen hast.

Eine Sekunde klingt kurz. Aber die Befehle, die du am häufigsten benutzt, sind genau diese einfachen, zwanzigmal am Tag, und einen Assistenten, der sich langsam anfühlt, benutzt du irgendwann nicht mehr. Deshalb bekommt Pixel Stufen: Der schnellste und einfachste Weg wird zuerst probiert, und was er nicht beantworten kann, geht an die nächste Stufe weiter.

Regeln, die ihre Grenzen kennen

Die Gefahr bei Regeln ist, dass sie zu viel verstehen. Eine Regel, die nach „Küche“ und „an“ sucht, springt auch bei „Mach das Licht in der Küche an, wenn ich um sechs nach Hause komme“ an und tut voller Überzeugung das Falsche. Die Regeln, die du hier schreibst, folgen einem Grundsatz: Eine Regel beantwortet nur einen Satz, den sie vollständig versteht. Sie nimmt jedes Wort heraus, das sie kennt, und wenn etwas übrig bleibt, tritt sie zur Seite.

Zuerst die Wörter, in src/language.ts:

src/language.ts
/** Die Wörter, die die Regeln kennen. Jedes andere Wort im Satz lässt sie zur Seite treten. */
export const WORDS = {
  all: ['alle', 'alles', 'überall'],
  on: ['an', 'ein', 'anschalten', 'einschalten', 'anmachen'],
  off: ['aus', 'ausschalten', 'ausmachen', 'abschalten'],
  percent: ['prozent', '%'],
  filler: [
    'hey', 'pixel', 'bitte', 'mach', 'mache', 'schalt', 'schalte', 'stell', 'stelle', 'das',
    'die', 'der', 'den', 'dem', 'licht', 'lichter', 'lampe', 'lampen', 'in', 'im', 'auf', 'und',
    'es', 'mal',
  ],
};

/** Fragen, die die Regeln selbst beantworten. Sie sehen den Satz kleingeschrieben und ohne Satzzeichen. */
export const ASKS = {
  time: /^(wie spät ist es|wie viel uhr ist es|wieviel uhr ist es|sag mir die uhrzeit)$/,
  date: /^(welcher tag ist heute|welches datum ist heute|welches datum haben wir heute|der wievielte ist heute)$/,
  sum: /^(?:was ist|wie viel ist|wieviel ist|was macht|was ergibt) (\d+(?:,\d+)?) (plus|minus|mal|geteilt durch|durch) (\d+(?:,\d+)?)$/,
};
export const OPERATORS: Record<string, '+' | '-' | '*' | '/'> = {
  plus: '+',
  minus: '-',
  mal: '*',
  'geteilt durch': '/',
  durch: '/',
};

const clock = new Intl.DateTimeFormat(LOCALE, { hour: 'numeric', minute: '2-digit' });
const calendar = new Intl.DateTimeFormat(LOCALE, { weekday: 'long', month: 'long', day: 'numeric' });
const number = new Intl.NumberFormat(LOCALE, { maximumFractionDigits: 3 });

/** Die Sätze, die Pixel ohne das Modell sagt. */
export const say = {
  // ...
  time: (now: Date) => `Es ist ${clock.format(now)} Uhr.`,
  date: (now: Date) => `Heute ist ${calendar.format(now)}.`,
  sum: (result: number) => `Das macht ${number.format(result)}.`,
  noZero: 'Durch null teilen kann nicht einmal ich.',
};

WORDS.filler enthält die Wörter, die in einem Lampenbefehl keine Bedeutung tragen: „bitte“, „das“, „mach“, „licht“. Alle Wörter stehen klein in den Listen, weil die Regeln den Satz kleingeschrieben und ohne Satzzeichen sehen. ASKS enthält ganze Fragen als Muster. Jetzt die Regeln, in src/rules.ts:

src/rules.ts
import { type Change, setLamps } from './home.ts';
import { ASKS, COLORS, OPERATORS, ROOMS, say, WORDS } from './language.ts';
import type { Reply } from './model.ts';

/** A pattern for any of the words, as whole words: "on" is not found in "onion". */
function anyOf(words: string[]): RegExp {
  const escaped = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
  return new RegExp(`(?<![\\p{L}\\p{N}])(?:${escaped.join('|')})(?![\\p{L}\\p{N}])`, 'gu');
}

function lightRule(sentence: string): Reply | null {
  let rest = sentence;
  /** Whether the pattern is in the sentence. What it matched is taken out. */
  const take = (pattern: RegExp): boolean => {
    const before = rest;
    rest = rest.replace(pattern, ' ');
    return rest !== before;
  };

  const rooms = ROOMS.filter((room) => take(anyOf(room.words))).map((room) => room.name);
  const everywhere = take(anyOf(WORDS.all));
  const percent = new RegExp(`(\\d{1,3}) ?(?:${WORDS.percent.join('|')})`).exec(rest);
  if (percent) rest = rest.replace(percent[0], ' ');
  // the longest name first, so "warm white" is not taken for "white"
  const color = [...COLORS]
    .sort((a, b) => b.name.length - a.name.length)
    .find((candidate) => take(anyOf(candidate.words)));
  const off = take(anyOf(WORDS.off));
  const on = take(anyOf(WORDS.on));
  take(anyOf(WORDS.filler));

  // a word is left over that the rule does not know: the model should read this sentence
  if (rest.trim()) return null;
  if (rooms.length === 0 && !everywhere) return null;
  if (on && off) return null;

  const change: Change = {};
  if (off) change.on = false;
  if (on) change.on = true;
  if (percent) change.brightness = Number(percent[1]);
  if (color) change.color = color.name;
  if (Object.keys(change).length === 0) return null;

  return { speech: say.lights(setLamps(rooms, change), change) };
}

function askRule(sentence: string): Reply | null {
  if (ASKS.time.test(sentence)) return { speech: say.time(new Date()) };
  if (ASKS.date.test(sentence)) return { speech: say.date(new Date()) };
  const sum = ASKS.sum.exec(sentence);
  if (sum) {
    const [a, b] = [Number(sum[1]!.replace(',', '.')), Number(sum[3]!.replace(',', '.'))];
    const operator = OPERATORS[sum[2]!];
    if (operator === '/' && b === 0) return { speech: say.noZero };
    const result = operator === '+' ? a + b : operator === '-' ? a - b : operator === '*' ? a * b : a / b;
    return { speech: say.sum(result) };
  }
  return null;
}

/** Answers what needs no model, in well under a millisecond. Null means: not for me. */
export function rules(text: string): Reply | null {
  const sentence = text
    .toLowerCase()
    .replace(/[.,!?]+(?=\s|$)/g, ' ')
    .replace(/\s+/g, ' ')
    .trim();
  return askRule(sentence) ?? lightRule(sentence);
}

lightRule arbeitet wie jemand, der Wörter von einer Liste streicht. Nimm „Wohnzimmer warmweiß auf 40 Prozent, bitte“:

  1. Streich die Räume: „wohnzimmer“. Ein Raum gefunden.

  2. Kein Wort für „überall“. Streich „40 prozent“: eine Helligkeit.

  3. Streich eine Farbe, die längsten Namen zuerst: „warmweiß“.

  4. Kein „an“, kein „aus“. Streich die Füllwörter: „auf“, „bitte“.

  5. Nichts bleibt übrig. Die Regel hat alles verstanden und schaltet.

Jetzt nimm „Mach das Licht in der Küche an, wenn ich um sechs nach Hause komme“. Nach dem Streichen bleibt „wenn ich um sechs nach hause komme“ übrig. Die Regel gibt null zurück, und das heißt: nicht für mich. Dasselbe gilt für einen Satz ohne Raum oder für einen mit „an“ und „aus“ zugleich.

anyOf baut ein Muster, das nur ganze Wörter findet. Das seltsam aussehende (?<![\p{L}\p{N}]) heißt „kein Buchstabe und keine Ziffer davor“, damit „aus“ nicht in „hause“ gefunden wird: Sonst stünde im Satz von eben neben dem „an“ plötzlich auch ein „aus“. Der Kommentar im Code nennt das englische Gegenstück, „on“ in „onion“. Das funktioniert mit den Buchstaben jeder Sprache, auch mit ä, ö, ü und ß, was das übliche \b nicht kann.

askRule beantwortet, was gar nicht erst zu einem Sprachmodell gehen sollte: die Uhrzeit und das Datum, die der Computer einfach weiß, und Rechenaufgaben, die er einfach ausrechnet. Erinnere dich: Bei 17 mal 23 war sich das Modell nicht sicher.

Der Router

Jetzt das Stück, das die Stufen zusammenhält. Leg src/assistant.ts an:

src/assistant.ts
import { keep } from './history.ts';
import { say } from './language.ts';
import { askModel, type Reply } from './model.ts';
import { rules } from './rules.ts';

export interface Answer extends Reply {
  /** who answered */
  tier: string;
  ms: number;
}

interface Tier {
  name: string;
  /** an answer, or null to pass the request on to the next tier */
  ask(text: string): Reply | null | Promise<Reply | null>;
}

/** From the fastest and simplest to the slowest and smartest. */
const tiers: Tier[] = [
  { name: 'rules', ask: rules },
  { name: 'model', ask: askModel },
];

export async function handle(text: string): Promise<Answer> {
  const started = performance.now();
  let reply: Reply | null = null;
  let tier = 'nobody';
  for (const candidate of tiers) {
    try {
      reply = await candidate.ask(text);
    } catch (error) {
      console.error(`[${candidate.name}] ${(error as Error).message}`);
    }
    if (reply) {
      tier = candidate.name;
      break;
    }
  }
  const speech = reply?.speech ?? say.beyondMe;
  keep(text, speech);
  return { speech, tier, ms: Math.round(performance.now() - started) };
}

Eine Stufe ist ein Name und eine Funktion, die eine Antwort oder null zurückgibt. handle fragt sie der Reihe nach und nimmt die erste Antwort. Wirft eine Stufe einen Fehler, wird er protokolliert, und die nächste Stufe bekommt ihre Chance: Ein abgestürztes Modell darf den Lichtschalter nicht mitreißen. Und wenn niemand antwortet, sagt Pixel das.

Diese kleine Datei ist das Herz des Assistenten. Alles, was du ab jetzt hinzufügst, ist entweder eine neue Stufe oder macht eine Stufe besser darin, „nicht für mich“ zu sagen.

handle merkt sich außerdem den Wortwechsel im Verlauf, egal wer geantwortet hat. So versteht das Modell nach „Küche an“, beantwortet von einer Regel, immer noch „und im Flur auch“. Die Modell-Stufe merkt sich deshalb selbst nichts mehr. Ersetz src/model.ts:

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

export interface Reply {
  speech: string;
}

/** Asks the local model, which may call tools on the way to its answer. */
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}` },
  ];
  // a call, its result, another call ...: after four rounds it is enough
  for (let round = 0; round < 4; round += 1) {
    const answer = await chat(messages, { tools: toolDefinitions });
    messages.push(answer);
    if (!answer.tool_calls?.length) return { speech: spoken(answer.content) };

    const said: string[] = [];
    for (const call of answer.tool_calls) {
      const result = await runTool(call.function.name, call.function.arguments);
      if ('say' in result) said.push(result.say);
      messages.push({
        role: 'tool',
        tool_name: call.function.name,
        content: 'say' in result ? result.say : result.info,
      });
    }
    // every tool had its answer ready: no need to ask the model again
    if (said.length === answer.tool_calls.length) return { speech: said.join(' ') };
  }
  return { speech: say.beyondMe };
}

Der Chat spricht jetzt mit handle und zeigt, wer geantwortet hat. Ersetz src/chat.ts:

src/chat.ts
import { createInterface } from 'node:readline/promises';
import { onAnnounce } from './announce.ts';
import { handle } from './assistant.ts';
import { NAME } from './config.ts';
import { drawHome } from './home.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();

// a timer that is up, for example
onAnnounce((speech) => console.log(`\n${name}> ${speech}`));

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

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

  const answer = await handle(text);
  console.log(`${name}> ${answer.speech}  (${answer.tier}, ${answer.ms} ms)`);
  if (drawHome() !== home) {
    home = drawHome();
    console.log(home);
  }
}
terminal.close();
~/projects/pixel-assistant
$ npm run chatTalk to Pixel. /bye ends the chat.you> Küche anpixel> Das Licht in der Küche ist an.  (rules, 1 ms)  Wohnzimmer   ○  Küche        ● 100% weiß  Schlafzimmer ○  Bad          ○  Flur         ○you> Wohnzimmer warmweiß auf 40 Prozent, bittepixel> Das Licht im Wohnzimmer ist warmweiß auf 40 Prozent.  (rules, 0 ms)  Wohnzimmer   ● 40% warmweiß  Küche        ● 100% weiß  Schlafzimmer ○  Bad          ○  Flur         ○you> Was ist 17 mal 23?pixel> Das macht 391.  (rules, 0 ms)you> Hier ist es so hell, ich kann nicht schlafen.pixel> Das Licht im Schlafzimmer ist aus.  (model, 1630 ms)you> /bye

Drei Antworten von den Regeln, schneller, als du blinzeln kannst, und eine vom Modell, das verstanden hat, dass jemand, der nicht schlafen kann, das Schlafzimmer dunkel haben will. Das ist die Arbeitsteilung: Regeln für das, was jedes Mal gleich gesagt wird, das Modell für alles, was in freien Worten gesagt wird. Deine Zeiten für das Modell werden andere sein, die Regeln sind auf jedem Rechner so schnell.

Die erste Stufe weiß genau, was sie nicht kann. Das Modell weiß es nicht: Es beantwortet alles, mit derselben Überzeugung, ob es recht hat oder nicht. Im nächsten Teil bringst du auch der Modell-Stufe bei, „nicht für mich“ zu sagen.

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.