larkup 0.1.14 → 0.1.21

package/.next/server/chunks/packages_core_src_generator_generate-server_ts_0mt.je3._.js

@@ -0,0 +1,1145 @@
+module.exports=[171502,834648,e=>{"use strict";var t=e.i(979598),r=e.i(399828);let o="^6.0.197",s={"@ai-sdk/cohere":"^3.0.39","@ai-sdk/deepseek":"^2.0.39","@ai-sdk/gateway":"^3.0.133","@ai-sdk/google":"^3.0.83","@ai-sdk/mistral":"^3.0.40","@ai-sdk/openai":"^3.0.68","@ai-sdk/openai-compatible":"^2.0.51"};function n(e){if(e.chatProvider)return e.chatProvider;if(e.chatModelId?.startsWith("custom:"))return"custom";let t=e.chatModelId?.split("/",1)[0];return t&&["openai","google","cohere","mistral","deepseek"].includes(t)?t:e.embeddingProvider||"openai"}function a(e,t=n(e)){if(e.chatModelId)return e.chatModelId;if("custom"===t&&e.customChatModels?.[0])return`custom:${e.customChatModels[0].modelName}`;let r={openai:"openai/gpt-4o-mini",google:"google/gemini-2.5-flash",cohere:"cohere/command-r-plus",mistral:"mistral/mistral-large-latest",deepseek:"deepseek/deepseek-chat",vercel_ai_gateway:"openai/gpt-4o-mini"};return r[t]||r.openai}function i(e){let t=n(e),r=a(e,t),o=r.startsWith("custom:")?r.slice(7):r,s=function(e,t=""){switch(e){case"google":return`import { createGoogleGenerativeAI } from "@ai-sdk/google";
+const provider = createGoogleGenerativeAI({ apiKey: CHAT_API_KEY });
+const model = provider(MODEL_NAME);`;case"cohere":return`import { createCohere } from "@ai-sdk/cohere";
+const provider = createCohere({ apiKey: CHAT_API_KEY });
+const model = provider(MODEL_NAME);`;case"mistral":return`import { createMistral } from "@ai-sdk/mistral";
+const provider = createMistral({ apiKey: CHAT_API_KEY });
+const model = provider(MODEL_NAME);`;case"deepseek":return`import { createDeepSeek } from "@ai-sdk/deepseek";
+const provider = createDeepSeek({ apiKey: CHAT_API_KEY });
+const model = provider(MODEL_NAME);`;case"vercel_ai_gateway":return`import { createGateway } from "@ai-sdk/gateway";
+const provider = createGateway({ apiKey: CHAT_API_KEY });
+const model = provider(CHAT_MODEL);`;case"custom":return`import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+const provider = createOpenAICompatible({
+  name: "larkup-custom",
+  baseURL: process.env.CHAT_BASE_URL || ${JSON.stringify(t)},
+  apiKey: CHAT_API_KEY,
+});
+const model = provider.chatModel(MODEL_NAME);`;default:return`import { createOpenAI } from "@ai-sdk/openai";
+const provider = createOpenAI({ apiKey: CHAT_API_KEY });
+const model = provider(MODEL_NAME);`}}(t,(e.customChatModels??[]).find(e=>e.modelName===o)?.baseUrl),i=e.systemPrompt||"You are a helpful assistant grounded in the supplied knowledge base.";return`import { streamText } from "ai";
+import { embedQuery } from "./embed.mjs";
+import { query as storeQuery } from "./store.mjs";
+
+const CHAT_API_KEY = process.env.CHAT_API_KEY || process.env.OPENAI_API_KEY || "";
+const CHAT_MODEL = process.env.CHAT_MODEL || ${JSON.stringify(r)};
+const MODEL_NAME = CHAT_MODEL.startsWith("custom:")
+  ? CHAT_MODEL.slice("custom:".length)
+  : CHAT_MODEL.includes("/")
+    ? CHAT_MODEL.split("/").slice(1).join("/")
+    : CHAT_MODEL;
+const SYSTEM_PROMPT = process.env.CHAT_SYSTEM_PROMPT || ${JSON.stringify(i)};
+
+${s}
+
+function textFromMessage(message) {
+  if (typeof message?.content === "string") return message.content.trim();
+  if (Array.isArray(message?.content)) {
+    return message.content
+      .filter((part) => part?.type === "text" && typeof part.text === "string")
+      .map((part) => part.text)
+      .join("\\n")
+      .trim();
+  }
+  return "";
+}
+
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  if (chunks.length === 0) return {};
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+
+export async function handleChat(req, res) {
+  try {
+    const body = await readBody(req);
+    if (!Array.isArray(body.messages)) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ error: "Body must include a messages array." }));
+    }
+
+    const messages = body.messages
+      .filter((message) => ["user", "assistant", "system"].includes(message?.role))
+      .map((message) => ({ role: message.role, content: textFromMessage(message) }))
+      .filter((message) => message.content);
+    const latestUser = [...messages].reverse().find((message) => message.role === "user");
+    if (!latestUser) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ error: "At least one user message is required." }));
+    }
+
+    const vector = await embedQuery(latestUser.content);
+    const requestedTopK = Number(body.topK) || Number(process.env.TOP_K || 5);
+    const hits = await storeQuery(vector, Math.min(50, Math.max(1, requestedTopK)));
+    const context = hits
+      .map((hit, index) => \`[\${index + 1}] \${hit.title || "Untitled"}\\n\${hit.text}\`)
+      .join("\\n\\n");
+    const requestedSystem = messages
+      .filter((message) => message.role === "system")
+      .map((message) => message.content)
+      .join("\\n\\n");
+
+    const system = [
+      SYSTEM_PROMPT,
+      requestedSystem,
+      context
+        ? \`Use the retrieved context below when it is relevant. If it does not answer the question, say so.\\n\\n\${context}\`
+        : "",
+    ].filter(Boolean).join("\\n\\n");
+    const modelMessages = messages
+      .filter((message) => message.role !== "system")
+      .map((message) => ({ role: message.role, content: message.content }));
+    const result = streamText({ model, system, messages: modelMessages });
+
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization",
+    });
+    for await (const text of result.textStream) {
+      res.write(\`event: message\\ndata: \${JSON.stringify({ type: "text-delta", text })}\\n\\n\`);
+    }
+    res.write(\`event: done\\ndata: \${JSON.stringify({ type: "done", hits })}\\n\\n\`);
+    res.end();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!res.headersSent) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: message }));
+      return;
+    }
+    res.write(\`event: error\\ndata: \${JSON.stringify({ type: "error", error: message })}\\n\\n\`);
+    res.end();
+  }
+}
+`}function c(e,t){let r={custom:"@ai-sdk/openai-compatible",google:"@ai-sdk/google",cohere:"@ai-sdk/cohere",mistral:"@ai-sdk/mistral",deepseek:"@ai-sdk/deepseek",vercel_ai_gateway:"@ai-sdk/gateway",openai:"@ai-sdk/openai"}[t||"openai"]||"@ai-sdk/openai";e[r]=s[r]}e.s(["AI_SDK_PROVIDER_VERSIONS",0,s,"AI_SDK_VERSION",0,o,"addChatProviderDependency",0,c,"generateChatModule",0,i,"resolveChatModel",0,a,"resolveChatProvider",0,n],834648),e.s(["generateServer",0,function(d){var l;let p,u,m,h=(0,t.getVectorStore)(d.vectorStore);(0,r.getEmbeddingModel)(d.embeddingModelId);let g="lancedb"===d.vectorStore&&(d.storeConfig.mode??"local")==="local",f={ai:o,cheerio:"^1.0.0",...h.serverDependencies};d.embeddingModelId.startsWith("custom:")?f["@ai-sdk/openai-compatible"]=s["@ai-sdk/openai-compatible"]:"deepseek"===d.embeddingProvider?f["@ai-sdk/deepseek"]=s["@ai-sdk/deepseek"]:"google"===d.embeddingProvider?f["@ai-sdk/google"]=s["@ai-sdk/google"]:"cohere"===d.embeddingProvider?f["@ai-sdk/cohere"]=s["@ai-sdk/cohere"]:"mistral"===d.embeddingProvider?f["@ai-sdk/mistral"]=s["@ai-sdk/mistral"]:"vercel_ai_gateway"===d.embeddingProvider?f["@ai-sdk/gateway"]=s["@ai-sdk/gateway"]:(d.embeddingProvider,f["@ai-sdk/openai"]=s["@ai-sdk/openai"]);let y=n(d),E=a(d,y);c(f,y);let b=[{key:"EMBEDDING_API_KEY",required:!0,help:"API key used to embed incoming queries."},{key:"PORT",required:!1,help:"Port to listen on (default 8080)."},{key:"SERVER_API_KEY",required:!1,help:"Bearer token to secure your server endpoints. If set, requests must include 'Authorization: Bearer <key>'."},{key:"TOP_K",required:!1,help:`Default number of documents to retrieve (default ${d.topK}).`},{key:"CHAT_API_KEY",required:!0,help:"API key used by the streaming /chat endpoint."},{key:"CHAT_MODEL",required:!1,help:`Chat model override (default ${E}).`}];"custom"===y&&b.push({key:"CHAT_BASE_URL",required:!0,help:"OpenAI-compatible base URL used by the chat endpoint."}),"pinecone"===d.vectorStore?b.push({key:"PINECONE_API_KEY",required:!0,help:"Pinecone API key."},{key:"PINECONE_INDEX",required:!0,help:"Pinecone index name to query."},{key:"PINECONE_NAMESPACE",required:!1,help:"Pinecone namespace (default 'default')."},{key:"PINECONE_SPARSE_MODEL",required:!1,help:"Pinecone sparse model (for hybrid search)."},{key:"PINECONE_SPARSE_INDEX",required:!1,help:"Pinecone sparse index name (for hybrid search)."}):b.push({key:"LANCEDB_MODE",required:!1,help:"'local' (on-disk), 's3' (S3-compatible), or 'cloud' (default 'local')."},{key:"LANCEDB_PATH",required:!1,help:"On-disk path to the LanceDB tables (local mode)."},{key:"LANCEDB_TABLE",required:!1,help:"Table name holding the embedded chunks (default 'documents')."},{key:"LANCEDB_S3_URI",required:!1,help:"S3-compatible LanceDB URI (e.g. s3://bucket/prefix)."},{key:"AWS_ENDPOINT",required:!1,help:"S3-compatible endpoint (required for Cloudflare R2)."},{key:"AWS_REGION",required:!1,help:"S3 region (use auto for Cloudflare R2)."},{key:"AWS_ACCESS_KEY_ID",required:!1,help:"S3-compatible access key ID."},{key:"AWS_SECRET_ACCESS_KEY",required:!1,help:"S3-compatible secret access key."},{key:"LANCEDB_URI",required:!1,help:"LanceDB Cloud database URI (cloud mode)."},{key:"LANCEDB_API_KEY",required:!1,help:"LanceDB Cloud API key (cloud mode)."});let v={projectName:d.projectName,files:[],dependencies:f,envVars:b},A={name:d.projectName,version:"1.0.0",private:!0,type:"module",description:`Lightweight RAG server (${h.label}) generated by larkup`,scripts:{start:"node --env-file=.env server.mjs",demo:"node demo.mjs"},dependencies:f,engines:{node:">=20"}},_=v.envVars.map(e=>{let t="";if("EMBEDDING_API_KEY"===e.key&&(t=d.embeddingApiKey||""),"CHAT_API_KEY"===e.key){let e=d.chatModelId?.replace(/^custom:/,"")||"",r=d.customChatModels?.find(t=>t.modelName===e)?.apiKey;t=d.chatApiKey||r||d.embeddingApiKey||""}if("CHAT_MODEL"===e.key&&(t=E),"CHAT_BASE_URL"===e.key){let e=d.chatModelId?.replace(/^custom:/,"")||"";t=d.customChatModels?.find(t=>t.modelName===e)?.baseUrl||""}return"PINECONE_API_KEY"===e.key&&(t=d.storeConfig.apiKey||""),"PINECONE_INDEX"===e.key&&(t=d.storeConfig.indexName||""),"PINECONE_NAMESPACE"===e.key&&(t=d.storeConfig.namespace||""),"LANCEDB_MODE"===e.key&&(t=d.storeConfig.mode||"local"),"LANCEDB_URI"===e.key&&(t=d.storeConfig.uri||""),"LANCEDB_API_KEY"===e.key&&(t=d.storeConfig.apiKey||""),"LANCEDB_S3_URI"===e.key&&(t=d.storeConfig.s3Uri||""),"AWS_ENDPOINT"===e.key&&(t=d.storeConfig.s3Endpoint||""),"AWS_REGION"===e.key&&(t=d.storeConfig.s3Region||""),"AWS_ACCESS_KEY_ID"===e.key&&(t=d.storeConfig.s3AccessKeyId||""),"AWS_SECRET_ACCESS_KEY"===e.key&&(t=d.storeConfig.s3SecretAccessKey||""),`${e.key}=${t}`}).join("\n"),S=[{path:"package.json",contents:JSON.stringify(A,null,2)+"\n"},{path:"server.mjs",contents:`import { createServer } from "node:http"
+import { embedQuery } from "./embed.mjs"
+import * as store from "./store.mjs"
+import { handleChat } from "./chat.mjs"
+import fs from "node:fs"
+import path from "node:path"
+import * as cheerio from "cheerio"
+
+const PORT = process.env.PORT || 8080
+const DEFAULT_TOP_K = Number(process.env.TOP_K || ${d.topK})
+
+console.log('[${d.projectName}] SERVER_API_KEY:', process.env.SERVER_API_KEY ? 'SET ('+process.env.SERVER_API_KEY.length+' chars, starts with: '+process.env.SERVER_API_KEY.slice(0,8)+'...)' : 'NOT SET (open access)')
+
+function send(res, status, body) {
+  const json = JSON.stringify(body)
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization",
+    "Access-Control-Allow-Methods": "GET,POST,PUT,DELETE,OPTIONS",
+  })
+  res.end(json)
+}
+
+async function readBody(req) {
+  const chunks = []
+  for await (const c of req) chunks.push(c)
+  if (chunks.length === 0) return {}
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"))
+  } catch {
+    return {}
+  }
+}
+
+const server = createServer(async (req, res) => {
+  if (req.method === "OPTIONS") return send(res, 204, {})
+
+  const url = new URL(req.url, \`http://\${req.headers.host}\`)
+
+  if (req.method === "GET" && url.pathname === "/favicon2.ico") {
+    try {
+      const filepath = path.join(process.cwd(), "public", "favicon2.ico")
+      if (fs.existsSync(filepath)) {
+        res.writeHead(200, { "Content-Type": "image/x-icon" })
+        return res.end(fs.readFileSync(filepath))
+      }
+      const rootFilepath = path.join(process.cwd(), "favicon2.ico")
+      if (fs.existsSync(rootFilepath)) {
+        res.writeHead(200, { "Content-Type": "image/x-icon" })
+        return res.end(fs.readFileSync(rootFilepath))
+      }
+    } catch {}
+  }
+
+  const expectedKey = process.env.SERVER_API_KEY
+  
+  if (expectedKey) {
+    const auth = req.headers.authorization
+    const isPublic = url.pathname === "/" || url.pathname === "/health" || url.pathname === "/openapi.json" || url.pathname === "/reference"
+    if (!isPublic) {
+      if (!auth) {
+        return send(res, 401, { error: "Missing Authorization header. Expected Bearer token." })
+      }
+      const token = auth.replace(/^Bearer\\s+/i, "").trim()
+      if (token !== expectedKey.trim()) {
+        console.error('[AUTH] Token mismatch. Got:', token.slice(0,20), '| Expected starts with:', expectedKey.trim().slice(0,20))
+        return send(res, 403, { error: "Invalid API key." })
+      }
+    }
+  }
+
+  if (req.method === "GET" && url.pathname === "/health") {
+    return send(res, 200, { ok: true, service: ${JSON.stringify(d.projectName)} })
+  }
+
+  if (req.method === "GET" && url.pathname === "/") {
+    res.writeHead(302, { Location: "/reference", "Cache-Control": "no-store" })
+    return res.end()
+
+    res.writeHead(200, { "Content-Type": "text/html" })
+    return res.end(\`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>\${${JSON.stringify(d.projectName)}} — RAG Server</title>
+  <link rel="icon" href="/favicon2.ico" type="image/x-icon" />
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+  <style>
+    *{margin:0;padding:0;box-sizing:border-box}
+    body{font-family:'Inter',system-ui,sans-serif;min-height:100vh;display:flex;align-items:center;justify-content:center;background:#F2EDE8;color:#18181b;overflow:hidden;position:relative}
+    body::after{content:'';position:fixed;inset:0;pointer-events:none;z-index:0;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='400'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.75' numOctaves='3' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 0.28 0 0 0 0 0.23 0 0 0 0 0.16 0 0 0 0.55 0'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)'/%3E%3C/svg%3E");background-size:512px 512px;background-repeat:repeat;opacity:0.79;mix-blend-mode:overlay}
+    .bg-mesh{position:fixed;inset:0;z-index:0;background-image:radial-gradient(ellipse 55% 45% at 8% 4%,rgba(0,0,0,0.12),transparent 70%),radial-gradient(ellipse 45% 40% at 94% 92%,rgba(220,160,120,0.15),transparent 65%),radial-gradient(ellipse 70% 55% at 50% 50%,rgba(0,0,0,0.05),transparent 80%)}
+    .container{position:relative;z-index:1;text-align:center;max-width:800px;padding:2rem;}
+    .badge{display:inline-flex;align-items:center;gap:6px;padding:6px 16px;border-radius:100px;font-size:0.75rem;font-weight:500;color:#000;background:rgba(255,255,255,0.8);border:1px solid rgba(0,0,0,0.1);margin-bottom:2rem;backdrop-filter:blur(4px);transition:colors .2s}
+    .badge:hover{background:#fff}
+    .badge .dot{width:6px;height:6px;border-radius:50%;background:#10b981;box-shadow:0 0 6px rgba(16,185,129,.4);animation:pulse 2s ease-in-out infinite}
+    @keyframes pulse{0%,100%{opacity:1}50%{opacity:.4}}
+    h1{font-size:3.5rem;font-weight:500;letter-spacing:-0.02em;color:#000;margin-bottom:1.5rem;line-height:1.05;}
+    .subtitle{font-size:1.125rem;color:#52525b;line-height:1.6;margin-bottom:3rem;max-width:600px;margin-left:auto;margin-right:auto;}
+    .actions{display:flex;flex-wrap:wrap;gap:1rem;justify-content:center}
+    .btn{display:inline-flex;align-items:center;justify-content:center;gap:8px;padding:0.75rem 1.5rem;font-size:0.875rem;font-weight:500;text-decoration:none;transition:all .2s ease;cursor:pointer;border:none;}
+    .btn-primary{background:#000000;color:#fff;box-shadow:0 2px 12px rgba(0,0,0,.15)}
+    .btn-primary:hover{transform:translateY(-1px);box-shadow:0 4px 20px rgba(0,0,0,.25)}
+    .btn-outline{background:transparent;color:#000;border:1px solid rgba(0,0,0,.12);}
+    .btn-outline:hover{background:rgba(255,255,255,0.5);border-color:rgba(0,0,0,.2);transform:translateY(-1px);}
+    .footer{margin-top:4rem;font-size:.875rem;color:#71717a}
+    .footer a{color:#000;text-decoration:underline;text-underline-offset:2px;}
+    .footer a:hover{color:#333;}
+    .icon{width:16px;height:16px;stroke:currentColor;fill:none;stroke-width:2;stroke-linecap:round;stroke-linejoin:round}
+    @media (max-width: 640px){ h1{font-size:2.5rem;} }
+  </style>
+</head>
+<body>
+  <div class="bg-mesh"></div>
+  <div class="container">
+    <div class="badge"><span class="dot"></span> Server Online</div>
+    <h1>\${${JSON.stringify(d.projectName)}}</h1>
+    <p class="subtitle">Your RAG retrieval server is live and ready to accept queries.<br/>Powered by <strong style="color:#000000">Larkup</strong></p>
+    <div class="actions">
+      <a href="/reference" class="btn btn-primary">
+        <svg class="icon" viewBox="0 0 24 24"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/></svg>
+        API Reference
+      </a>
+      <a href="https://github.com/Larkup-AI/larkup-rag" target="_blank" rel="noopener" class="btn btn-outline">
+        <svg class="icon" viewBox="0 0 24 24"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/></svg>
+        Larkup Team
+      </a>
+      <a href="mailto:contact@larkup.de" class="btn btn-outline">
+        <svg class="icon" viewBox="0 0 24 24"><path d="M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z"/><polyline points="22,6 12,13 2,6"/></svg>
+        Contact
+      </a>
+    </div>
+    <div class="footer">Built with <a href="https://github.com/Larkup-AI/larkup-rag/buddy-rag" target="_blank" rel="noopener">larkup</a> \xb7 v1.0</div>
+  </div>
+</body>
+</html>\`)
+  }
+
+  if (req.method === "POST" && url.pathname === "/query") {
+    try {
+      const { query: q, topK } = await readBody(req)
+      if (!q || typeof q !== "string") {
+        return send(res, 400, { error: "Body must include a 'query' string." })
+      }
+      const vector = await embedQuery(q)
+      const hits = await store.query(vector, Number(topK) || DEFAULT_TOP_K)
+      return send(res, 200, { query: q, hits })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "POST" && url.pathname === "/chat") {
+    return handleChat(req, res)
+  }
+
+  if (req.method === "GET" && url.pathname === "/documents") {
+    try {
+      const page  = Math.max(1, parseInt(url.searchParams.get("page")  || "1",  10) || 1)
+      const limit = Math.min(100, Math.max(1, parseInt(url.searchParams.get("limit") || "20", 10) || 20))
+      const result = await store.list({ page, limit })
+      return send(res, 200, result)
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "GET" && url.pathname.match(/^\\/documents\\/[^/]+$/) && !url.pathname.endsWith("/documents")) {
+    try {
+      const id = url.pathname.split("/").pop()
+      const doc = await store.get(id)
+      if (!doc) return send(res, 404, { error: "Document not found" })
+      return send(res, 200, doc)
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "POST" && url.pathname === "/documents") {
+    try {
+      const doc = await readBody(req)
+      if (!doc.text) return send(res, 400, { error: "Missing text" })
+      const vector = await embedQuery(doc.text)
+      const id = doc.id || Math.random().toString(36).slice(2)
+      await store.add([{ id, vector, text: doc.text, title: doc.title || "Untitled", url: doc.url || "", documentId: doc.documentId || id }])
+      return send(res, 200, { success: true, id })
+    } catch (err) {
+      console.error("[POST /documents] Error:", err)
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "PUT" && url.pathname.startsWith("/documents/")) {
+    try {
+      const id = url.pathname.split("/").pop()
+      const doc = await readBody(req)
+      if (!doc.text) return send(res, 400, { error: "Missing text" })
+      const vector = await embedQuery(doc.text)
+      await store.update(id, { id, vector, text: doc.text, title: doc.title || "Untitled", url: doc.url, documentId: doc.documentId || id })
+      return send(res, 200, { success: true })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "DELETE" && url.pathname.startsWith("/documents/")) {
+    try {
+      const id = url.pathname.split("/").pop()
+      await store.remove(id)
+      return send(res, 200, { success: true })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "POST" && url.pathname === "/scrape") {
+    try {
+      const { url: targetUrl } = await readBody(req)
+      if (!targetUrl || typeof targetUrl !== "string") {
+        return send(res, 400, { error: "Body must include a 'url' string." })
+      }
+      const fetchRes = await fetch(targetUrl)
+      if (!fetchRes.ok) return send(res, 502, { error: \`Failed to fetch \${targetUrl}: \${fetchRes.status}\` })
+      const html = await fetchRes.text()
+      const $ = cheerio.load(html)
+      $("script, style, nav, footer, header, iframe, noscript").remove()
+      const rawText = $("body").text().replace(/\\s+/g, " ").trim()
+      if (!rawText) return send(res, 422, { error: "No text content extracted from URL." })
+
+      const title = $("title").text().trim() || new URL(targetUrl).hostname
+      const CHUNK_SIZE = 1000
+      const chunks = []
+      for (let i = 0; i < rawText.length; i += CHUNK_SIZE) {
+        chunks.push(rawText.slice(i, i + CHUNK_SIZE))
+      }
+
+      const documentId = Math.random().toString(36).slice(2)
+      for (const [idx, chunk] of chunks.entries()) {
+        const id = \`\${documentId}-\${idx}\`
+        const vector = await embedQuery(chunk)
+        await store.add([{ id, vector, text: chunk, title: \`\${title} (part \${idx + 1})\`, url: targetUrl || "", documentId }])
+      }
+
+      return send(res, 200, { success: true, documentId, chunks: chunks.length })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "GET" && url.pathname === "/corpus/summary") {
+    try {
+      const all = await store.list({ page: 1, limit: 100000 })
+      const docs = all.documents || []
+      const bySource = {}
+      const byStatus = {}
+      let totalChars = 0
+      for (const d of docs) {
+        const src = d.source || "unknown"
+        bySource[src] = (bySource[src] || 0) + 1
+        const st = d.status || "indexed"
+        byStatus[st] = (byStatus[st] || 0) + 1
+        totalChars += (d.text || "").length
+      }
+      return send(res, 200, {
+        totalDocuments: all.total,
+        bySource,
+        byStatus,
+        totalCharacters: totalChars
+      })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "POST" && url.pathname === "/corpus") {
+    try {
+      const { filter, limit: reqLimit, offset: reqOffset, includeContent } = await readBody(req)
+      const pageSize = Math.min(Math.max(reqLimit || 200, 1), 1000)
+      const page = Math.max(1, Math.floor((reqOffset || 0) / pageSize) + 1)
+      const result = await store.list({ page, limit: pageSize })
+      let docs = result.documents || []
+
+      // Apply optional filters
+      if (filter) {
+        if (filter.source) docs = docs.filter(d => d.source === filter.source)
+        if (filter.titleContains) {
+          const needle = filter.titleContains.toLowerCase()
+          docs = docs.filter(d => (d.title || "").toLowerCase().includes(needle))
+        }
+      }
+
+      const mapped = docs.map(d => {
+        const entry = { id: d.id, title: d.title, url: d.url, documentId: d.documentId, charCount: (d.text || "").length }
+        if (includeContent) entry.content = (d.text || "").slice(0, 2000)
+        return entry
+      })
+      return send(res, 200, { documents: mapped, total: result.total, page, limit: pageSize })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "POST" && url.pathname === "/corpus/export") {
+    try {
+      const { format } = await readBody(req)
+      const all = await store.list({ page: 1, limit: 100000 })
+      const docs = all.documents || []
+
+      if (format === "jsonl") {
+        const lines = docs.map(d => JSON.stringify({
+          id: d.id, title: d.title, url: d.url || "",
+          documentId: d.documentId, text: (d.text || "").slice(0, 1000)
+        }))
+        res.writeHead(200, { "Content-Type": "application/x-ndjson", "Access-Control-Allow-Origin": "*" })
+        return res.end(lines.join("\\n"))
+      }
+
+      // Default: CSV
+      const header = "id,title,url,documentId,charCount,content"
+      const csvEscape = (v) => {
+        const s = String(v || "")
+        return s.includes(",") || s.includes('"') || s.includes("\\n") ? '"' + s.replace(/"/g, '""') + '"' : s
+      }
+      const rows = docs.map(d => [
+        d.id, d.title, d.url || "", d.documentId,
+        (d.text || "").length,
+        (d.text || "").slice(0, 1000).replace(/\\n/g, " ")
+      ].map(csvEscape).join(","))
+      res.writeHead(200, { "Content-Type": "text/csv", "Access-Control-Allow-Origin": "*" })
+      return res.end([header, ...rows].join("\\n"))
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "GET" && url.pathname === "/openapi.json") {
+    return send(res, 200, {
+      openapi: "3.1.0",
+      info: { title: "Larkup Server", version: "1.0.0" },
+      security: [{ bearerAuth: [] }],
+      paths: {
+        "/query": {
+          post: {
+            summary: "Query the RAG knowledge base",
+            security: [{ bearerAuth: [] }],
+            requestBody: {
+              content: { "application/json": { schema: { type: "object", properties: { query: { type: "string" }, topK: { type: "number" } } } } }
+            },
+            responses: { "200": { description: "Successful response" } }
+          }
+        },
+        "/chat": {
+          post: {
+            summary: "Stream a retrieval-grounded chat response",
+            security: [{ bearerAuth: [] }],
+            requestBody: {
+              required: true,
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    required: ["messages"],
+                    properties: {
+                      messages: {
+                        type: "array",
+                        items: {
+                          type: "object",
+                          required: ["role", "content"],
+                          properties: {
+                            role: { type: "string", enum: ["user", "assistant", "system"] },
+                            content: { type: "string" }
+                          }
+                        }
+                      },
+                      topK: { type: "integer", minimum: 1 }
+                    }
+                  }
+                }
+              }
+            },
+            responses: {
+              "200": {
+                description: "Server-sent events containing text-delta and done events",
+                content: { "text/event-stream": {} }
+              }
+            }
+          }
+        },
+        "/documents": {
+          get: {
+            summary: "List documents (paginated)",
+            security: [{ bearerAuth: [] }],
+            parameters: [
+              { name: "page",  in: "query", required: false, schema: { type: "integer", default: 1,  minimum: 1 }, description: "Page number (1-indexed)" },
+              { name: "limit", in: "query", required: false, schema: { type: "integer", default: 20, minimum: 1, maximum: 100 }, description: "Items per page" }
+            ],
+            responses: {
+              "200": {
+                description: "Paginated list of documents",
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object",
+                      properties: {
+                        documents:  { type: "array",   items: { type: "object" } },
+                        total:      { type: "integer", description: "Total number of documents" },
+                        page:       { type: "integer", description: "Current page" },
+                        limit:      { type: "integer", description: "Items per page" },
+                        totalPages: { type: "integer", description: "Total number of pages" }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          post: {
+            summary: "Add a new document",
+            security: [{ bearerAuth: [] }],
+            requestBody: {
+              content: { "application/json": { schema: { type: "object", properties: { text: { type: "string" }, title: { type: "string" }, url: { type: "string" }, documentId: { type: "string" } } } } }
+            },
+            responses: { "200": { description: "Successful response" } }
+          }
+        },
+        "/documents/{id}": {
+          get: {
+            summary: "Get a single document by ID",
+            security: [{ bearerAuth: [] }],
+            parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+            responses: {
+              "200": { description: "Document object" },
+              "404": { description: "Document not found" }
+            }
+          },
+          put: {
+            summary: "Update a document",
+            security: [{ bearerAuth: [] }],
+            parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+            requestBody: {
+              content: { "application/json": { schema: { type: "object", properties: { text: { type: "string" }, title: { type: "string" }, url: { type: "string" }, documentId: { type: "string" } } } } }
+            },
+            responses: { "200": { description: "Successful response" } }
+          },
+          delete: {
+            summary: "Delete a document",
+            security: [{ bearerAuth: [] }],
+            parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+            responses: { "200": { description: "Successful response" } }
+          }
+        },
+        "/scrape": {
+          post: {
+            summary: "Scrape a URL and ingest into the corpus",
+            security: [{ bearerAuth: [] }],
+            requestBody: {
+              content: { "application/json": { schema: { type: "object", required: ["url"], properties: { url: { type: "string", description: "URL to scrape" } } } } }
+            },
+            responses: {
+              "200": { description: "Scrape successful", content: { "application/json": { schema: { type: "object", properties: { success: { type: "boolean" }, documentId: { type: "string" }, chunks: { type: "integer" } } } } } },
+              "502": { description: "Failed to fetch the target URL" }
+            }
+          }
+        },
+        "/health": {
+          get: {
+            summary: "Health check",
+            responses: { "200": { description: "OK" } }
+          }
+        },
+        "/corpus/summary": {
+          get: {
+            summary: "Get corpus summary statistics",
+            security: [{ bearerAuth: [] }],
+            responses: {
+              "200": {
+                description: "Corpus summary with counts by source and status",
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object",
+                      properties: {
+                        totalDocuments: { type: "integer" },
+                        bySource: { type: "object" },
+                        byStatus: { type: "object" },
+                        totalCharacters: { type: "integer" }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "/corpus": {
+          post: {
+            summary: "Get corpus documents with optional filtering",
+            security: [{ bearerAuth: [] }],
+            requestBody: {
+              content: { "application/json": { schema: { type: "object", properties: {
+                filter: { type: "object", properties: { source: { type: "string" }, titleContains: { type: "string" } } },
+                limit: { type: "integer", default: 200 },
+                offset: { type: "integer", default: 0 },
+                includeContent: { type: "boolean", default: false }
+              } } } }
+            },
+            responses: { "200": { description: "Paginated list of corpus documents" } }
+          }
+        },
+        "/corpus/export": {
+          post: {
+            summary: "Export full corpus as CSV or JSONL",
+            security: [{ bearerAuth: [] }],
+            requestBody: {
+              content: { "application/json": { schema: { type: "object", properties: { format: { type: "string", enum: ["csv", "jsonl"], default: "csv" } } } } }
+            },
+            responses: { "200": { description: "Corpus data in requested format" } }
+          }
+        }
+      },
+      components: {
+        securitySchemes: {
+          bearerAuth: {
+            type: "http",
+            scheme: "bearer"
+          }
+        }
+      }
+    })
+  }
+
+  if (req.method === "GET" && url.pathname === "/reference") {
+    const defaultToken = process.env.SERVER_API_KEY || ""
+    res.writeHead(200, { "Content-Type": "text/html" })
+    return res.end(\`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>API Reference</title>
+          <meta charset="utf-8" />
+          <meta name="viewport" content="width=device-width, initial-scale=1" />
+          <link rel="icon" href="/favicon2.ico" type="image/x-icon" />
+          <style>
+            :root {
+              --scalar-color-1: #000000;
+              --scalar-color-2: #333333;
+              --scalar-color-3: #666666;
+              --scalar-color-accent: #000000;
+              --scalar-background-1: #ffffff;
+              --scalar-background-2: #fafafa;
+              --scalar-background-3: #f5f5f5;
+              --scalar-background-accent: #f0f0f0;
+            }
+            .dark-mode {
+              --scalar-color-1: #ffffff;
+              --scalar-color-2: #cccccc;
+              --scalar-color-3: #999999;
+              --scalar-color-accent: #ffffff;
+              --scalar-background-1: #000000;
+              --scalar-background-2: #111111;
+              --scalar-background-3: #222222;
+              --scalar-background-accent: #333333;
+            }
+          </style>
+        </head>
+        <body>
+          <script id="api-reference" data-url="/openapi.json"></script>
+          <script>
+            const configuration = {
+              "theme": "default",
+              "hideClientButton": false,
+              "showSidebar": true,
+              "showDeveloperTools": "localhost",
+              "showToolbar": "localhost",
+              "operationTitleSource": "summary",
+              "persistAuth": true,
+              "telemetry": true,
+              "externalUrls": {
+                "dashboardUrl": "https://dashboard.scalar.com",
+                "registryUrl": "https://registry.scalar.com",
+                "proxyUrl": "https://proxy.scalar.com",
+                "apiBaseUrl": "https://api.scalar.com"
+              },
+              "default": false,
+              "layout": "modern",
+              "isEditable": false,
+              "isLoading": false,
+              "hideModels": false,
+              "documentDownloadType": "both",
+              "hideTestRequestButton": false,
+              "hideSearch": false,
+              "showOperationId": false,
+              "hideDarkModeToggle": false,
+              "withDefaultFonts": true,
+              "defaultOpenFirstTag": true,
+              "defaultOpenAllTags": false,
+              "expandAllModelSections": false,
+              "expandAllResponses": false,
+              "orderSchemaPropertiesBy": "alpha",
+              "orderRequiredPropertiesFirst": true,
+              "_integration": "html",
+              "modelsSectionLabel": "Models",
+              "slug": "api-1",
+              "title": "API #1",
+              "authentication": {
+                "preferredSecurityScheme": "bearerAuth",
+                "http": {
+                  "basic": { "username": "", "password": "" },
+                  "bearer": { "token": "\${defaultToken}" }
+                }
+              }
+            };
+            document.getElementById('api-reference').dataset.configuration = JSON.stringify(configuration);
+          </script>
+          <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+        </body>
+      </html>
+    \`)
+  }
+
+  return send(res, 404, { error: "Not found" })
+})
+
+server.listen(PORT, () => {
+  console.log(\`[${d.projectName}] RAG server listening on :\${PORT}\`)
+})
+`},{path:"chat.mjs",contents:i(d)},{path:"embed.mjs",contents:function(e){let t=`import { embed } from "ai"
+`,r="";if(e.embeddingModelId.startsWith("custom:")){let o=e.embeddingModelId.slice(7),s=(e.customEmbeddings??[]).find(e=>e.modelName===o);t+=`import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
+`,r=`const provider = createOpenAICompatible({
+  name: "custom_provider",
+  baseURL: process.env.EMBEDDING_BASE_URL || ${JSON.stringify(s?.baseUrl||"")},
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = provider.embeddingModel(process.env.EMBEDDING_MODEL || ${JSON.stringify(s?.modelName||"")})`}else"deepseek"===e.embeddingProvider?(t+=`import { createDeepSeek } from "@ai-sdk/deepseek"
+`,r=`const provider = createDeepSeek({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = provider.embeddingModel(process.env.EMBEDDING_MODEL || ${JSON.stringify(e.embeddingModelId)})`):"google"===e.embeddingProvider?(t+=`import { createGoogleGenerativeAI } from "@ai-sdk/google"
+`,r=`const provider = createGoogleGenerativeAI({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = provider.textEmbeddingModel(process.env.EMBEDDING_MODEL || ${JSON.stringify(e.embeddingModelId)})`):"cohere"===e.embeddingProvider?(t+=`import { createCohere } from "@ai-sdk/cohere"
+`,r=`const provider = createCohere({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = provider.embedding(process.env.EMBEDDING_MODEL || ${JSON.stringify(e.embeddingModelId)})`):"mistral"===e.embeddingProvider?(t+=`import { createMistral } from "@ai-sdk/mistral"
+`,r=`const provider = createMistral({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = provider.embedding(process.env.EMBEDDING_MODEL || ${JSON.stringify(e.embeddingModelId)})`):"vercel_ai_gateway"===e.embeddingProvider?(t+=`import { createGateway } from "@ai-sdk/gateway"
+`,r=`const gateway = createGateway({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = gateway.embedding(process.env.EMBEDDING_MODEL || ${JSON.stringify(e.embeddingModelId)})`):(t+=`import { createOpenAI } from "@ai-sdk/openai"
+`,r=`const provider = createOpenAI({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const modelName = process.env.EMBEDDING_MODEL || ${JSON.stringify(e.embeddingModelId)};
+const MODEL = provider.embedding(modelName.includes("/") ? modelName.split("/")[1] : modelName)`);return`${t}
+${r}
+
+export async function embedQuery(text) {
+  const { embedding } = await embed({ model: MODEL, value: text })
+  return embedding
+}
+`}(d)},{path:"store.mjs",contents:"pinecone"===d.vectorStore?`import { Pinecone } from "@pinecone-database/pinecone"
+
+const API_KEY = process.env.PINECONE_API_KEY || ""
+const INDEX = process.env.PINECONE_INDEX || ""
+const NAMESPACE = process.env.PINECONE_NAMESPACE || "default"
+
+if (!API_KEY) throw new Error("PINECONE_API_KEY is required.")
+if (!INDEX) throw new Error("PINECONE_INDEX is required.")
+
+const pc = new Pinecone({ apiKey: API_KEY })
+const ns = pc.index(INDEX).namespace(NAMESPACE)
+
+export async function query(vector, topK) {
+  const res = await ns.query({ vector, topK, includeMetadata: true })
+  return (res.matches ?? []).map((m) => {
+    const meta = m.metadata ?? {}
+    return {
+      id: m.id,
+      score: m.score ?? 0,
+      text: meta.text ?? "",
+      title: meta.title ?? "Untitled",
+      url: meta.url || undefined,
+      documentId: meta.documentId ?? "",
+      metadata: meta,
+    }
+  })
+}
+
+export async function list({ page = 1, limit = 20 } = {}) {
+  // Collect all IDs via Pinecone's cursor-based pagination
+  const allIds = []
+  let paginationToken = undefined
+  do {
+    const res = await ns.listPaginated({ limit: 100, paginationToken })
+    if (res.vectors) allIds.push(...res.vectors.map(v => v.id))
+    paginationToken = res.pagination?.next
+  } while (paginationToken)
+
+  const total = allIds.length
+  const start = (page - 1) * limit
+  const pageIds = allIds.slice(start, start + limit)
+
+  if (pageIds.length === 0) {
+    return { documents: [], total, page, limit, totalPages: Math.ceil(total / limit) }
+  }
+
+  const fetched = await ns.fetch(pageIds)
+  const documents = Object.values(fetched.records).map(r => {
+    const meta = r.metadata ?? {}
+    return {
+      id: r.id,
+      text: meta.text ?? "",
+      title: meta.title ?? "Untitled",
+      url: meta.url || undefined,
+      documentId: meta.documentId ?? "",
+    }
+  })
+  return { documents, total, page, limit, totalPages: Math.ceil(total / limit) }
+}
+
+export async function get(id) {
+  const fetched = await ns.fetch([id])
+  const r = fetched.records[id]
+  if (!r) return null;
+  const meta = r.metadata ?? {}
+  return {
+    id: r.id,
+    text: meta.text ?? "",
+    title: meta.title ?? "Untitled",
+    url: meta.url || undefined,
+    documentId: meta.documentId ?? "",
+  }
+}
+
+export async function add(docs) {
+  const vectors = docs.map(d => ({
+    id: d.id,
+    values: d.vector,
+    metadata: {
+      ...(d.metadata ?? {}),
+      text: d.text,
+      title: d.title,
+      url: d.url || "",
+      documentId: d.documentId,
+    }
+  }))
+  await ns.upsert(vectors)
+  return { success: true }
+}
+
+export async function remove(id) {
+  await ns.deleteOne(id)
+  return { success: true }
+}
+
+export async function update(id, doc) {
+  await ns.update({
+    id,
+    values: doc.vector,
+    setMetadata: {
+      ...(doc.metadata ?? {}),
+      text: doc.text,
+      title: doc.title,
+      url: doc.url || "",
+      documentId: doc.documentId,
+    }
+  })
+  return { success: true }
+}
+`:`import * as lancedb from "@lancedb/lancedb"
+import path from "node:path"
+
+const MODE = process.env.LANCEDB_MODE || "local"
+const IS_SERVERLESS = !!process.env.VERCEL || !!process.env.AWS_LAMBDA_FUNCTION_NAME
+const DEFAULT_DB_PATH = IS_SERVERLESS ? "/tmp/lancedb" : "./.larkup/lancedb"
+const DB_PATH = process.env.LANCEDB_PATH || DEFAULT_DB_PATH
+const URI = process.env.LANCEDB_URI || ""
+const API_KEY = process.env.LANCEDB_API_KEY || ""
+const S3_URI = process.env.LANCEDB_S3_URI || ""
+const TABLE = process.env.LANCEDB_TABLE || "documents"
+
+if (IS_SERVERLESS && MODE === "local") {
+  console.warn("[LanceDB] Running on serverless — using /tmp/lancedb. Data will NOT persist between invocations. Use S3-compatible storage or LanceDB Cloud for production.")
+}
+
+let _conn = null
+let _table = null
+
+async function getConn() {
+  if (_conn) return _conn
+  if (MODE === "cloud") {
+    if (!URI || !API_KEY) {
+      throw new Error("LanceDB Cloud needs LANCEDB_URI and LANCEDB_API_KEY.")
+    }
+    _conn = await lancedb.connect(URI, { apiKey: API_KEY })
+  } else if (MODE === "s3") {
+    if (!S3_URI) {
+      throw new Error("S3-compatible LanceDB needs LANCEDB_S3_URI.")
+    }
+    _conn = await lancedb.connect(S3_URI)
+  } else {
+    const abs = path.isAbsolute(DB_PATH) ? DB_PATH : path.join(process.cwd(), DB_PATH)
+    _conn = await lancedb.connect(abs)
+  }
+  return _conn
+}
+
+async function getTable() {
+  if (_table) return _table
+  const conn = await getConn()
+  const names = await conn.tableNames()
+  if (names.includes(TABLE)) {
+    _table = await conn.openTable(TABLE)
+    return _table
+  }
+  return null
+}
+
+export async function query(vector, topK) {
+  const t = await getTable()
+  if (!t) return []
+  const rows = await t.search(vector).limit(topK).toArray()
+  return rows.map((row) => ({
+    id: row.id,
+    score: typeof row._distance === "number" ? 1 / (1 + row._distance) : 0,
+    text: row.text,
+    title: row.title,
+    url: row.url || undefined,
+    documentId: row.documentId,
+    metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata,
+  }))
+}
+
+export async function list({ page = 1, limit = 20 } = {}) {
+  const t = await getTable()
+  if (!t) return { documents: [], total: 0, page, limit, totalPages: 0 }
+  const allRows = await t.query().select(["id", "text", "title", "url", "documentId"]).toArray()
+  const total = allRows.length
+  const start = (page - 1) * limit
+  const pageRows = allRows.slice(start, start + limit)
+  return {
+    documents: pageRows.map((row) => ({
+      id: row.id,
+      text: row.text,
+      title: row.title,
+      url: row.url || undefined,
+      documentId: row.documentId,
+    })),
+    total,
+    page,
+    limit,
+    totalPages: Math.ceil(total / limit),
+  }
+}
+
+export async function get(id) {
+  const t = await getTable()
+  if (!t) return null
+  const rows = await t.query().filter(\`id = '\${id}'\`).limit(1).toArray()
+  if (!rows.length) return null;
+  const row = rows[0];
+  return { id: row.id, text: row.text, title: row.title, url: row.url || undefined, documentId: row.documentId }
+}
+
+export async function add(docs) {
+  if (docs.length === 0) return { success: true }
+  let t = await getTable()
+  if (t) {
+    await t.add(docs)
+  } else {
+    const conn = await getConn()
+    const names = await conn.tableNames()
+    if (names.includes(TABLE)) {
+      t = await conn.openTable(TABLE)
+      _table = t
+      await t.add(docs)
+    } else {
+      t = await conn.createTable(TABLE, docs)
+      _table = t
+    }
+  }
+  return { success: true }
+}
+
+export async function remove(id) {
+  const t = await getTable()
+  if (!t) return { success: true }
+  await t.delete(\`id = '\${id}'\`)
+  return { success: true }
+}
+
+export async function update(id, doc) {
+  let t = await getTable()
+  if (!t) {
+    const conn = await getConn()
+    t = await conn.createTable(TABLE, [doc])
+    _table = t
+    return { success: true }
+  }
+  await t.delete(\`id = '\${id}'\`)
+  await t.add([doc])
+  return { success: true }
+}`},{path:"demo.mjs",contents:`const BASE = process.env.RAG_SERVER_URL || "http://localhost:8080"
+
+const question = process.argv.slice(2).join(" ") || "What is this corpus about?"
+
+const res = await fetch(\`\${BASE}/query\`, {
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({ query: question }),
+})
+
+const data = await res.json()
+if (!res.ok) {
+  console.error("Error:", data.error)
+  process.exit(1)
+}
+
+console.log(\`\\nQuery: \${data.query}\\n\`)
+for (const [i, hit] of data.hits.entries()) {
+  console.log(\`#\${i + 1} [\${hit.score.toFixed(3)}] \${hit.title}\`)
+  if (hit.url) console.log(\`   \${hit.url}\`)
+  console.log(\`   \${hit.text.slice(0, 160).replace(/\\n/g, " ")}...\\n\`)
+}
+`},{path:"Dockerfile",contents:`FROM node:22-slim
+
+WORKDIR /app
+
+COPY package.json ./
+RUN npm install --omit=dev
+
+COPY . .
+
+ENV PORT=8080
+EXPOSE 8080
+
+CMD ["node", "server.mjs"]
+`},{path:".dockerignore",contents:`node_modules
+npm-debug.log
+.env
+.git
+.DS_Store
+`},{path:"docker-compose.yml",contents:(l=d.projectName,p=g?`    volumes:
+      - ./.larkup:/app/.larkup
+`:"",`services:
+  ${l}:
+    build: .
+    container_name: ${l}
+    restart: unless-stopped
+    ports:
+      - "8080:8080"
+    env_file:
+      - .env
+${p}`)},{path:"vercel.json",contents:`{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "builds": [{ "src": "server.mjs", "use": "@vercel/node" }],
+  "routes": [
+    { "handle": "filesystem" },
+    { "src": "/(.*)", "dest": "server.mjs" }
+  ]
+}
+`},{path:".env.example",contents:v.envVars.map(e=>`# ${e.help}${e.required?"":" (optional)"}
+${e.key}=`).join("\n")},{path:".env",contents:_},{path:".gitignore",contents:"node_modules\n.env\n.DS_Store\n"},{path:"README.md",contents:(u=(0,t.getVectorStore)(d.vectorStore),m=Object.entries(v.dependencies).map(([e,t])=>`- \`${e}@${t}\``).join("\n"),`# ${d.projectName}
+
+A lightweight RAG retrieval server generated by **larkup**.
+
+- **Vector store:** ${u.label}
+- **Embedding model:** ${d.embeddingModelId}
+- **Index type:** ${d.indexType}
+- **Default top-k:** ${d.topK}
+
+## Dependencies
+${m}
+
+## Run locally
+\`\`\`bash
+npm install
+cp .env.example .env
+node server.mjs
+\`\`\`
+
+Then query it:
+\`\`\`bash
+node demo.mjs "your question here"
+# or
+curl -X POST http://localhost:8080/query \\
+  -H "Content-Type: application/json" \\
+  -H "Authorization: Bearer <your-key>" \\
+  -d '{"query":"your question","topK":${d.topK}}'
+\`\`\`
+
+## Deploy
+
+### Docker / VPS
+\`\`\`bash
+docker compose up -d --build
+\`\`\`
+
+### Vercel
+\`\`\`bash
+vercel deploy
+\`\`\`
+
+## API
+- \`GET  /health\`           → \`{ ok: true }\`
+- \`GET  /reference\`        → Scalar API docs UI
+- \`POST /query\`            → \`{ query, hits: [{ id, score, title, url, text, documentId }] }\`
+- \`POST /chat\`             → SSE stream of retrieval-grounded assistant text
+- \`GET  /documents\`        → list all documents (paginated)
+- \`GET  /documents/:id\`    → get a single document
+- \`POST /documents\`        → add a document
+- \`PUT  /documents/:id\`    → update a document
+- \`DELETE /documents/:id\`  → delete a document
+- \`POST /scrape\`           → scrape a URL and ingest into the corpus
+- \`GET  /corpus/summary\`   → get corpus statistics (counts by source/status)
+- \`POST /corpus\`           → get corpus documents with optional filtering
+- \`POST /corpus/export\`    → export full corpus as CSV or JSONL
+`)}].map(e=>{var t;return{...e,language:(t=e.path).endsWith(".json")?"json":t.endsWith(".mjs")||t.endsWith(".js")?"javascript":t.endsWith(".md")?"markdown":t.endsWith("Dockerfile")?"dockerfile":t.endsWith(".yml")||t.endsWith(".yaml")?"yaml":"text"}});try{let t=e.r(902157),r=e.r(750227),o=r.resolve(process.cwd(),"public/favicon2.ico");if(t.existsSync(o))S.push({path:"public/favicon2.ico",contents:t.readFileSync(o).toString("base64"),language:"ico",encoding:"base64"});else{let e=r.resolve(process.cwd(),"apps/web/public/favicon2.ico");t.existsSync(e)&&S.push({path:"public/favicon2.ico",contents:t.readFileSync(e).toString("base64"),language:"ico",encoding:"base64"})}}catch(e){}return v.files=S,v}],171502)}];
+
+//# sourceMappingURL=packages_core_src_generator_generate-server_ts_0mt.je3._.js.map