Project: A Local Chat Assistant (with Burmese System Prompt)

// app/api/chat/route.ts -- backend proxy to a local model server.
// The browser never talks to the local server directly: this route owns
// the system prompt and the local base URL.
import { NextRequest } from "next/server";

const LOCAL_MODEL_URL = "http://localhost:11434/api/chat";
const MODEL_NAME = "llama3.1:8b";

const SYSTEM_PROMPT = `You are a patient tutor. Answer in Burmese first,
in clear everyday language, and give the English technical term in
parentheses the first time it appears. Keep answers short unless the
user asks for more detail. If you don't know something, say so plainly
instead of guessing.`;

type ChatMessage = { role: "user" | "assistant"; content: string };

export async function POST(req: NextRequest) {
  const { messages } = (await req.json()) as { messages: ChatMessage[] };

  const upstream = await fetch(LOCAL_MODEL_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      model: MODEL_NAME,
      // System prompt + full prior history + newest message, every turn --
      // the model itself remembers nothing between requests.
      messages: [{ role: "system", content: SYSTEM_PROMPT }, ...messages],
      stream: true,
    }),
  });

  if (!upstream.ok || !upstream.body) {
    return new Response(
      JSON.stringify({ error: "Local model server is unreachable." }),
      { status: 502, headers: { "Content-Type": "application/json" } },
    );
  }

  // Re-stream the upstream NDJSON response straight through to the browser
  // instead of buffering the whole reply before responding.
  return new Response(upstream.body, {
    headers: { "Content-Type": "application/x-ndjson" },
  });
}

// --- frontend: consume the stream and grow the visible reply ---
//
// Called with the running conversation array and a callback that receives
// the assistant's partial text after every new token.
export async function sendMessage(
  history: ChatMessage[],
  onPartialReply: (text: string) => void,
): Promise<string> {
  const res = await fetch("/api/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ messages: history }),
  });

  if (!res.ok || !res.body) {
    const message = "[Error: could not reach the local model. Is it running?]";
    onPartialReply(message);
    return message;
  }

  const reader = res.body.getReader();
  const decoder = new TextDecoder();
  let buffer = "";
  let assistantText = "";

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop() ?? ""; // keep the last, possibly-incomplete line

    for (const line of lines) {
      if (!line.trim()) continue;
      const chunk = JSON.parse(line) as {
        message?: { content: string };
        done: boolean;
      };
      if (chunk.message?.content) {
        assistantText += chunk.message.content;
        onPartialReply(assistantText); // repaint with the growing reply
      }
    }
  }

  return assistantText;
}