Zum Inhalt springen

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

Teil 9: Eine Chat-Seite im Browser

Hol den Assistenten aus dem Terminal: ein kleiner Webserver nur mit Node.js, eine Seite mit dem Gespräch und den Lampen des Zuhauses und ein Kanal, über den der Server der Seite sagt, was sich geändert hat.

Quest-Ziele

  • Einen Webserver mit nichts als Node.js schreiben
  • Einen Satz von einer Seite an den Assistenten schicken
  • Änderungen mit Server-Sent Events vom Server an die Seite schicken
  • Die Lampen so zeichnen, dass sie in ihrer Farbe leuchten
  • Die Seite nur vom eigenen Rechner aus erreichbar halten

Das Terminal war ein guter Ort, um Pixel zu bauen, aber dort wohnt ein Assistent nicht. Eine Seite im Browser kann das Zuhause zeigen, sie funktioniert auf jedem Betriebssystem gleich, und in den nächsten Teilen wird sie Pixels Mikrofon und Lautsprecher. Der Assistent selbst ändert sich überhaupt nicht: Die Seite spricht mit derselben Funktion handle, die auch der Terminal-Chat benutzt.

Der Server

Gib der Seite einen Port in src/config.ts:

src/config.ts
export const PORT = Number(process.env.PORT ?? 3210);

Der Server hat drei Aufgaben: die Dateien der Seite ausliefern, einen Satz entgegennehmen und beantworten, und der Seite Bescheid geben, wenn sich etwas ändert. Node.js kann das alles ohne ein zusätzliches Paket. Leg src/server.ts an:

src/server.ts
import { readFile } from 'node:fs/promises';
import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
import { extname, join } from 'node:path';
import { onAnnounce } from './announce.ts';
import { handle } from './assistant.ts';
import { NAME, PORT } from './config.ts';
import { getLamps, onHomeChange } from './home.ts';
import { COLORS } from './language.ts';

const PUBLIC = join(import.meta.dirname, '..', 'public');
const TYPES: Record<string, string> = {
  '.html': 'text/html; charset=utf-8',
  '.css': 'text/css',
  '.js': 'text/javascript',
};

/** The browsers that have the page open. Each one is a response that never ends. */
const watchers = new Set<ServerResponse>();

function push(event: string, data: unknown): void {
  for (const watcher of watchers) watcher.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
}

/** The lamps, each with the color the page paints it in. */
const home = () =>
  getLamps().map((lamp) => ({ ...lamp, css: COLORS.find((color) => color.name === lamp.color)?.css }));

onHomeChange(() => push('home', home()));
onAnnounce((speech) => push('say', { speech }));

async function body(request: IncomingMessage): Promise<Buffer> {
  const chunks: Buffer[] = [];
  for await (const chunk of request) chunks.push(chunk);
  return Buffer.concat(chunks);
}

function json(response: ServerResponse, data: unknown): void {
  response.writeHead(200, { 'content-type': 'application/json' });
  response.end(JSON.stringify(data));
}

const server = createServer(async (request, response) => {
  const { pathname } = new URL(request.url ?? '/', 'http://localhost');
  try {
    if (request.method === 'POST' && pathname === '/api/say') {
      const { text } = JSON.parse((await body(request)).toString()) as { text: string };
      return json(response, await handle(String(text)));
    }
    if (pathname === '/api/events') {
      response.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache' });
      response.write(`event: home\ndata: ${JSON.stringify(home())}\n\n`);
      watchers.add(response);
      request.on('close', () => watchers.delete(response));
      return;
    }
    // everything else is a file from public/
    const file = join(PUBLIC, pathname === '/' ? 'index.html' : pathname);
    if (!file.startsWith(PUBLIC)) throw new Error('outside public/');
    const content = await readFile(file);
    response.writeHead(200, { 'content-type': TYPES[extname(file)] ?? 'application/octet-stream' });
    response.end(content);
  } catch (error) {
    const missing = (error as NodeJS.ErrnoException).code === 'ENOENT';
    if (!missing) console.error(error);
    if (!response.headersSent) response.writeHead(missing ? 404 : 500);
    response.end();
  }
});

// 127.0.0.1: only this computer can reach the page
server.listen(PORT, '127.0.0.1', () => console.log(`${NAME} is at http://localhost:${PORT}`));

Jede Anfrage an den Server landet in der Funktion, die createServer bekommt. Sie schaut auf die Adresse und entscheidet, was zu tun ist:

  • POST /api/say liest den Satz aus der Anfrage, gibt ihn an handle und schickt die Antwort als JSON zurück. Das ist die ganze Verbindung zwischen der Seite und dem Assistenten.

  • GET /api/events ist der Kanal in die andere Richtung. Dazu gleich mehr.

  • Alles andere ist eine Datei aus dem Ordner public. Die Prüfung mit startsWith sorgt dafür, dass eine Adresse wie /../src/config.ts keine Dateien außerhalb davon erreicht.

Der Server spricht zuerst

Normalerweise fragt eine Webseite, und der Server antwortet. Aber ein Timer, der klingelt, oder eine Lampe, die eine Regel gerade geschaltet hat, sind Dinge, die der Server zuerst weiß. Dafür gibt es Server-Sent Events: Die Seite öffnet eine Anfrage an /api/events, und der Server beantwortet sie nie zu Ende. Er hält die Antwort offen und schreibt ein paar Zeilen hinein, sobald es etwas Neues gibt:

text
event: home
data: [{"room":"Küche","on":true,"brightness":100,"color":"weiß","css":"#fff4e0"}, ...]

watchers enthält diese offenen Antworten, eine pro Browser-Tab, und push schreibt in alle. Die beiden Zeilen unter home verbinden das mit dem, was du früher gebaut hast: onHomeChange aus Teil 4, das seitdem auf einen Zuhörer wartet, und onAnnounce aus Teil 5. Eine Lampe, die sich ändert, erscheint also sofort auf jeder offenen Seite, egal wie sie geschaltet wurde.

Die Seite

Leg neben src einen Ordner public an und darin die index.html:

public/index.html
<!doctype html>
<html lang="de">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Pixel</title>
    <link rel="icon" href="data:," />
    <link rel="stylesheet" href="style.css" />
  </head>
  <body>
    <main>
      <h1>Pixel</h1>
      <section id="home" aria-label="Das Zuhause"></section>
      <section id="log" aria-live="polite"></section>
      <form id="form">
        <input id="text" placeholder="Sag etwas zu Pixel" autocomplete="off" autofocus />
        <button>Senden</button>
      </form>
    </main>
    <script type="module" src="app.js"></script>
  </body>
</html>

Ein wenig Styling, in public/style.css:

public/style.css
:root {
  color-scheme: dark;
  font-family: system-ui, sans-serif;
  background: #17111f;
  color: #f3ecff;
}
main {
  max-width: 40rem;
  margin: 0 auto;
  padding: 1rem;
}
#home {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(7rem, 1fr));
  gap: 0.5rem;
}
.room {
  padding: 0.75rem 0.25rem;
  font-size: 0.9rem;
  border: 2px solid #4a3a66;
  border-radius: 0.5rem;
  text-align: center;
}
.bulb {
  width: 2.5rem;
  height: 2.5rem;
  margin: 0 auto 0.5rem;
  border-radius: 50%;
  border: 2px solid #4a3a66;
  /* --glow is the color of the lamp, --level its brightness from 0 to 1 */
  background: color-mix(in srgb, var(--glow) calc(var(--level) * 100%), #241a33);
  box-shadow: 0 0 calc(var(--level) * 1.5rem) var(--glow);
  transition: all 0.3s;
}
.room small {
  display: block;
  min-height: 1.2em;
  color: #a898c4;
}
#log {
  height: 40vh;
  margin: 1rem 0;
  overflow-y: auto;
}
#log p {
  margin: 0.4rem 0;
  padding: 0.5rem 0.75rem;
  border-radius: 0.5rem;
  background: #241a33;
}
#log p.you {
  margin-left: 20%;
  background: #4a2f7a;
}
#log small {
  margin-left: 0.5rem;
  color: #a898c4;
}
form {
  display: flex;
  gap: 0.5rem;
}
input#text {
  flex: 1;
}
input#text,
button {
  padding: 0.6rem 0.8rem;
  border: 2px solid #4a3a66;
  border-radius: 0.5rem;
  background: #241a33;
  color: inherit;
  font: inherit;
}
button.active {
  background: #ea580c;
}
.switches {
  display: flex;
  gap: 1.5rem;
  color: #a898c4;
}

Spannend ist .bulb. Jede Lampe bekommt vom Skript zwei Werte, --glow für ihre Farbe und --level für ihre Helligkeit von 0 bis 1. Das Stylesheet mischt die Farbe je nach Helligkeit in den dunklen Hintergrund und legt einen Schatten in derselben Farbe darum, was wie ein Leuchten aussieht.

Und das Skript, public/app.js. Es läuft im Browser, ist also einfaches JavaScript:

public/app.js
const home = document.querySelector('#home');
const log = document.querySelector('#log');
const form = document.querySelector('#form');
const input = document.querySelector('#text');

/** Adds a line to the conversation. `who` is "you" or "pixel". */
function show(who, text, note = '') {
  const line = document.createElement('p');
  line.className = who;
  line.textContent = text;
  if (note) {
    const small = document.createElement('small');
    small.textContent = note;
    line.append(small);
  }
  log.append(line);
  line.scrollIntoView();
}

/** Shows Pixel's answer. */
async function answered(answer) {
  show('pixel', answer.speech, answer.tier ? `${answer.tier}, ${answer.ms} ms` : '');
}

/** Sends a sentence to Pixel. */
async function send(text) {
  show('you', text);
  const response = await fetch('/api/say', {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ text }),
  });
  await answered(await response.json());
}

form.addEventListener('submit', (event) => {
  event.preventDefault();
  const text = input.value.trim();
  input.value = '';
  if (text) send(text);
});

/** Draws the rooms with their lamps. */
function drawHome(lamps) {
  home.replaceChildren(
    ...lamps.map((lamp) => {
      const room = document.createElement('div');
      room.className = 'room';
      const bulb = document.createElement('div');
      bulb.className = 'bulb';
      bulb.style.setProperty('--glow', lamp.css);
      bulb.style.setProperty('--level', lamp.on ? lamp.brightness / 100 : 0);
      const state = document.createElement('small');
      state.textContent = lamp.on ? `${lamp.brightness}% ${lamp.color}` : '';
      room.append(bulb, lamp.room, state);
      return room;
    }),
  );
}

// what the server sends without being asked: the lamps, and what Pixel says by itself
const events = new EventSource('/api/events');
events.addEventListener('home', (event) => drawHome(JSON.parse(event.data)));
events.addEventListener('say', (event) => answered(JSON.parse(event.data)));
  • show fügt dem Gespräch eine Zeile hinzu. Es setzt den Text mit textContent, nie mit innerHTML, damit die Seite nichts, was ein Modell schreibt, je als Code ausführen kann.

  • send schickt einen Satz an /api/say und zeigt die Antwort, mit der Stufe und der Zeit in kleiner Schrift.

  • EventSource ist die Browser-Seite der Server-Sent Events. Es öffnet den Kanal, verbindet sich von selbst neu, wenn der Server neu startet, und ruft für jedes Ereignis eine Funktion auf: Das Zuhause wird neu gezeichnet, und eine Ansage wird wie eine Antwort angezeigt.

Starten

Ergänze ein Skript in der package.json:

package.json
"scripts": {
    "chat": "node src/chat.ts",
    "serve": "node src/server.ts",
    "typecheck": "tsc"
  }
~/projects/pixel-assistant
$ npm run servePixel is at http://localhost:3210

Öffne localhost:3210 und sprich mit Pixel:

Die Seite: oben die Räume mit ihren Lampen, darunter das Gespräch. Diese drei Befehle haben die Regeln beantwortet.

Öffne die Seite in einem zweiten Tab und schalte im ersten eine Lampe: Beide Tabs zeigen es. Stell einen Timer, und die Ansage erscheint in beiden. Der Terminal-Chat funktioniert auch weiterhin, aber er ist ein eigenes Programm mit einem eigenen Zuhause.

Pixel hat jetzt ein Gesicht. Im nächsten Teil bekommt es Ohren: Du hältst einen Knopf gedrückt, sagst, was du willst, und eine Spracherkennung auf deinem Rechner macht Text daraus.

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.