Einen KI-Assistenten mit lokalen Modellen bauen · Teil 7 von 13 der Serie
Teil 7: Die Antworten des Modells prüfen
Ein kleines Modell behauptet Dinge, die es nicht getan hat, antwortet, wo es nicht sollte, und antwortet manchmal gar nicht. Fang alle drei Fälle im Code ab: Prüf jede Antwort, bevor sie jemand hört.
Einen KI-Assistenten mit lokalen Modellen bauenTeil 7 von 13
Auf dieser Seite
Quest-Ziele
- Die typischen Fehler eines kleinen Modells kennen
- Eine Antwort abfangen, die eine Aktion behauptet, die kein Werkzeug ausgeführt hat
- Eine Antwort erkennen, die aufgibt, und die Anfrage weiterreichen
- Jedem Durchgang ein Zeitlimit geben
- Den Assistenten am Laufen halten, wenn das Modell nicht läuft
Bisher glaubt Pixel alles, was das Modell sagt. Das ist ein Fehler, und jeder Assistent, der auf einem Sprachmodell aufbaut, muss mit ihm umgehen. Ein Modell weiß nicht, was es weiß. Es erzeugt die wahrscheinlichsten nächsten Wörter, und „Erledigt, das Licht ist an!“ ist etwas, das ein Assistent sehr wahrscheinlich sagt, egal ob etwas passiert ist oder nicht.
Als der echte Assistent hinter dieser Serie sein lokales Modell bekam, beantwortete er 66 Prozent seiner Testsätze richtig. Nach den Prüfungen aus diesem Teil, der Notiz mit dem Kalender aus Teil 3 und ein paar Regeln wie denen aus Teil 6 waren es 98 Prozent, mit demselben Modell. Nichts davon hat das Modell klüger gemacht. Es ist gewöhnlicher Code, der die Arbeit des Modells prüft, so wie du die Arbeit eines neuen Kollegen prüfen würdest, der eifrig ist und sich seiner Sache ein bisschen zu sicher.
Drei Arten, danebenzuliegen
Das leere Versprechen. „Erledigt!“ oder „Ich habe dir einen Timer gestellt“, ohne Werkzeugaufruf. Nichts ist passiert, und wer gefragt hat, merkt es erst, wenn der Tee kalt ist.
Die höfliche Kapitulation. „Tut mir leid, ich habe keinen Zugriff auf aktuelle Sportergebnisse.“ Stimmt, hilft aber niemandem und ist kein Grund, den Durchgang zu beenden: Vielleicht kann eine andere Stufe helfen.
Das Schweigen. Das Modell braucht ewig, oder Ollama läuft gar nicht.
Für alle drei ist die Antwort dieselbe wie im letzten Teil: Die Stufe gibt null zurück, „nicht für mich“, und der Router geht weiter.
Die ersten beiden erkennen
Woran erkennst du, dass eine Antwort eine Aktion behauptet? Du suchst nach den Wörtern, die solche Antworten verwenden. Das klingt gröber, als es sein dürfte, und es funktioniert trotzdem. Ergänze in src/language.ts:
/** Eine Antwort, die behauptet, etwas sei erledigt. Ohne Werkzeugaufruf ist nichts passiert. */
export const CLAIM =
/(?<!\p{L})(erledigt|(habe|hab|wurde|wurden|ist|sind) (\p{L}+ ){0,5}(gemacht|gespeichert|notiert|gemerkt|eingeschaltet|ausgeschaltet|angeschaltet|gedimmt|gestellt|eingestellt|gestartet|gelöscht|gestoppt)|merke ich mir|(ist|sind) jetzt (an|aus))(?!\p{L})/iu;
/** Eine Antwort, die aufgibt. Die nächste Stufe weiß vielleicht mehr. */
export const REFUSAL =
/(?<!\p{L})(weiß ich (\p{L}+ )?nicht|ich weiß (es |das )?(\p{L}+ )?nicht|kann ich (\p{L}+ ){0,3}nicht(?! klagen)|ich kann (\p{L}+ ){0,3}nicht(?! klagen)|(ich habe|habe ich) (\p{L}+ )?keine?n? (zugriff|information|informationen|daten|ahnung)|keine ahnung|bin (ich )?(mir )?(da )?nicht sicher|als ki)(?!\p{L})/iu;
export const NUDGE =
'Du hast kein Werkzeug aufgerufen, also ist nichts passiert. Ruf jetzt das passende Werkzeug auf.';CLAIM findet Antworten, die sagen, dass etwas erledigt wurde. REFUSAL findet Antworten, die aufgeben. NUDGE ist das, was Pixel zum Modell sagt, wenn es ein leeres Versprechen erwischt.
Zeitlimits und ein fehlendes Modell
Der Client braucht zwei Ergänzungen: einen Weg, eine Anfrage aufzugeben, und einen Weg zu fragen, ob Ollama überhaupt da ist. Ersetz src/ollama.ts:
import { MODEL, OLLAMA_URL } from './config.ts';
export interface ToolCall {
function: { name: string; arguments: Record<string, unknown> };
}
export interface Message {
role: 'system' | 'user' | 'assistant' | 'tool';
content: string;
/** on an assistant message: the tools the model wants to call */
tool_calls?: ToolCall[];
/** on a tool message: the tool whose result this is */
tool_name?: string;
}
export interface ChatOptions {
/** the tools the model may call, as Ollama expects them */
tools?: object[];
/** lets the caller give up, for example after a time limit */
signal?: AbortSignal;
}
async function post(path: string, body: object, signal?: AbortSignal): Promise<Response> {
const response = await fetch(`${OLLAMA_URL}${path}`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify(body),
signal,
});
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[], options: ChatOptions = {}): Promise<Message> {
const response = await post(
'/api/chat',
{
model: MODEL,
messages,
tools: options.tools,
stream: false,
think: false,
options: { temperature: 0.2, num_predict: 300 },
},
options.signal,
);
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;
}
}
}
/** Whether Ollama is running and answers. */
export async function available(): Promise<boolean> {
try {
const response = await fetch(`${OLLAMA_URL}/api/version`, { signal: AbortSignal.timeout(1000) });
return response.ok;
} catch {
return false;
}
}Ein signal ist die Art, wie JavaScript etwas abbricht, das gerade läuft. fetch nimmt eines an, und wenn das Signal auslöst, endet die Anfrage mit einem Fehler. available fragt Ollama nach seiner Version und wartet höchstens eine Sekunde; jede Antwort heißt, dass es läuft.
Die Modell-Stufe, mit Prüfungen
Ersetz src/model.ts:
import { recent } from './history.ts';
import { CLAIM, NUDGE, PERSONA, REFUSAL } from './language.ts';
import { available, chat, type Message } from './ollama.ts';
import { contextBlock, spoken } from './prompt.ts';
import { runTool, toolDefinitions } from './tools.ts';
export interface Reply {
speech: string;
}
/** How long a whole turn may take before Pixel gives up on the model. */
const BUDGET_MS = 30_000;
/**
* Asks the local model, which may call tools. Returns null when the model is not the one
* to answer: it is not running, it took too long, or it gave up.
*/
export async function askModel(text: string): Promise<Reply | null> {
if (!(await available())) return null;
const signal = AbortSignal.timeout(BUDGET_MS);
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}` },
];
let toolsUsed = 0;
let nudged = false;
for (let round = 0; round < 4; round += 1) {
const answer = await chat(messages, { tools: toolDefinitions, signal });
messages.push(answer);
if (answer.tool_calls?.length) {
const said: string[] = [];
for (const call of answer.tool_calls) {
const result = await runTool(call.function.name, call.function.arguments);
toolsUsed += 1;
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(' ') };
continue;
}
const speech = spoken(answer.content);
if (!speech) return null;
// "Done!" without a tool call: nothing was done. Ask once more, firmly.
if (toolsUsed === 0 && CLAIM.test(speech)) {
if (nudged) return null;
nudged = true;
messages.push({ role: 'user', content: NUDGE });
continue;
}
if (REFUSAL.test(speech)) return null;
return { speech };
}
return null;
}Die Funktion kann jetzt null zurückgeben, und das tut sie immer dann, wenn das Modell nicht das richtige für die Antwort ist. Von oben nach unten:
Ollama läuft nicht: nicht für mich. Kein Fehler, kein Warten.
AbortSignal.timeout(BUDGET_MS)startet eine Uhr für den ganzen Durchgang, alle Runden zusammen. Läuft sie ab, endet die Anfrage, die gerade unterwegs ist, mit einem Fehler, und den fängt der Router aus dem letzten Teil ab. Dreißig Sekunden sind großzügig, weil die allererste Anfrage das Modell auch noch in den Arbeitsspeicher laden muss. Senk die Zahl, sobald du weißt, wie schnell dein Rechner ist.Eine leere Antwort: nicht für mich.
Das leere Versprechen: Die Antwort behauptet eine Aktion, aber in diesem Durchgang ist kein Werkzeug gelaufen. Pixel sagt das dem Modell in klaren Worten und fragt noch einmal. Meistens ruft das Modell dann das Werkzeug auf, das es vergessen hat. Behauptet es wieder etwas, gibt die Stufe auf.
Die Kapitulation: Die Antwort passt auf
REFUSAL. Nicht für mich.
Achte darauf, was die Prüfung auf das leere Versprechen nicht tut: Sie schlägt nicht an, wenn ein Werkzeug gelaufen ist. „Erledigt, der Timer ist gestellt“ nach einem echten Werkzeugaufruf ist schlicht wahr.
Probier es aus
Frag nach etwas, das das Modell nicht wissen kann:
$ npm run chatTalk to Pixel. /bye ends the chat.you> Wer hat gestern Abend das Fußballspiel gewonnen?pixel> Das übersteigt leider meine Fähigkeiten. (nobody, 1210 ms)you> /bye
Das Modell hat so etwas gesagt wie „Ich habe keinen Zugriff auf aktuelle Sportergebnisse“, die Prüfung hat die Kapitulation erkannt, und weil es noch keine weitere Stufe gibt, hat der Router selbst geantwortet. Das sieht nach einem Rückschritt aus, ist aber die ehrliche Antwort, und im letzten Teil dieser Serie übernimmt genau hier eine dritte Stufe.
Jetzt halt das Modell an und schau, was von Pixel übrig bleibt:
# Ollama beenden: die App schließen, oder unter Linux:$ sudo systemctl stop ollama$ npm run chatTalk to Pixel. /bye ends the chat.you> Küche anpixel> Das Licht in der Küche ist an. (rules, 1 ms)you> Mach es hier gemütlich.pixel> Das übersteigt leider meine Fähigkeiten. (nobody, 4 ms)
Die Lampen funktionieren weiter, in einer Millisekunde. Das ist das zweite Geschenk der Stufen, nach dem Tempo: Wenn der kluge Teil ausfällt, hält der einfache Teil das Haus am Laufen.
Pixel ist jetzt schnell, sorgfältig und ehrlich, was seine Grenzen angeht. Aber es vergisst alles, sobald du den Chat schließt. Im nächsten Teil bekommt es ein Gedächtnis, das nach Bedeutung findet.
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.