@theromans/convex-dobty 0.1.12 → 0.1.14

package/src/component/knowledgeSearch.ts

@@ -1,4 +1,4 @@
-import { action } from "./_generated/server.js";
+import { internalAction, internalMutation, action } from "./_generated/server.js";
 import { internal } from "./_generated/api.js";
 import { v } from "convex/values";
 
@@ -6,17 +6,12 @@ const EMBEDDING_ENDPOINT =
   "https://openai.inference.de-txl.ionos.com/v1/embeddings";
 const EMBEDDING_MODEL = "BAAI/bge-m3";
 const EMBEDDING_DIMENSIONS = 1024;
-
-const EMBEDDING_TIMEOUT_MS = 10_000;
+const EMBEDDING_TIMEOUT_MS = 15_000;
 const DEFAULT_SEARCH_LIMIT = 5;
 
-async function getEmbedding(
-  text: string,
-  apiToken: string,
-): Promise<number[]> {
+async function getEmbedding(text: string, apiToken: string): Promise<number[]> {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), EMBEDDING_TIMEOUT_MS);
-
   try {
     const response = await fetch(EMBEDDING_ENDPOINT, {
       method: "POST",
@@ -31,14 +26,12 @@ async function getEmbedding(
       }),
       signal: controller.signal,
     });
-
     if (!response.ok) {
       const body = await response.text();
-      throw new Error(`Embedding API error ${response.status}: ${body}`);
+      throw new Error(`Embedding API ${response.status}: ${body}`);
     }
-
     const json = await response.json();
-    return json.data[0].embedding;
+    return json.data[0].embedding as number[];
   } catch (e: any) {
     if (e.name === "AbortError") {
       throw new Error(`Embedding API timed out after ${EMBEDDING_TIMEOUT_MS}ms`);
@@ -49,6 +42,128 @@ async function getEmbedding(
   }
 }
 
+/**
+ * Embed a single chunk for a single language.
+ * Called by the scheduler after a chunk is seeded or updated.
+ * Automatically schedules the other language if it is also stale.
+ */
+export const embedChunk = internalAction({
+  args: {
+    chunkId: v.id("knowledgeChunks"),
+    language: v.union(v.literal("en"), v.literal("de")),
+  },
+  handler: async (ctx, { chunkId, language }) => {
+    const apiToken = (globalThis as any).process?.env?.IONOS_API_TOKEN as string | undefined;
+    if (!apiToken) {
+      console.error("[embedChunk] IONOS_API_TOKEN not set — cannot embed");
+      return;
+    }
+
+    const chunk: any = await ctx.runQuery(internal.knowledge.getChunk, { chunkId });
+    if (!chunk) {
+      console.warn(`[embedChunk] chunk ${chunkId} not found, skipping`);
+      return;
+    }
+
+    const isStaleEn =
+      !chunk.embedding_en ||
+      !chunk.embeddedAt_en ||
+      chunk.embeddedAt_en < chunk.updatedAt;
+    const isStaleDe =
+      !chunk.embedding_de ||
+      !chunk.embeddedAt_de ||
+      chunk.embeddedAt_de < chunk.updatedAt;
+
+    const isStale = language === "en" ? isStaleEn : isStaleDe;
+    if (!isStale) {
+      // Already up to date — schedule the other language if needed
+      const otherLanguage = language === "en" ? "de" : "en";
+      const otherStale = language === "en" ? isStaleDe : isStaleEn;
+      if (otherStale) {
+        await ctx.scheduler.runAfter(0, internal.knowledgeSearch.embedChunk, {
+          chunkId,
+          language: otherLanguage,
+        });
+      }
+      return;
+    }
+
+    const title = language === "en" ? chunk.title_English : chunk.title_Deutsch;
+    const content = language === "en" ? chunk.content_English : chunk.content_Deutsch;
+
+    if (!title || !content) {
+      console.warn(`[embedChunk] chunk ${chunk.chunkKey} missing ${language} content, skipping`);
+      return;
+    }
+
+    try {
+      const embedding = await getEmbedding(`${title}\n\n${content}`, apiToken);
+
+      if (language === "en") {
+        await ctx.runMutation(internal.knowledge.updateEmbeddingEn, { chunkId, embedding });
+      } else {
+        await ctx.runMutation(internal.knowledge.updateEmbeddingDe, { chunkId, embedding });
+      }
+
+      console.log(`[embedChunk] embedded ${chunk.chunkKey} (${language})`);
+
+      // Schedule the other language if it is also stale
+      const otherLanguage = language === "en" ? "de" : "en";
+      const otherStale = language === "en" ? isStaleDe : isStaleEn;
+      if (otherStale) {
+        await ctx.scheduler.runAfter(0, internal.knowledgeSearch.embedChunk, {
+          chunkId,
+          language: otherLanguage,
+        });
+      }
+    } catch (e: any) {
+      console.error(`[embedChunk] failed for ${chunk.chunkKey} (${language}): ${e.message}`);
+    }
+  },
+});
+
+/**
+ * Schedule embedding jobs for all chunks that are stale
+ * (updatedAt > embeddedAt_en or embeddedAt_de).
+ * Called automatically after seedKnowledgeChunks, or can be triggered manually.
+ */
+export const scheduleStaleEmbeddings = internalAction({
+  args: {},
+  handler: async (ctx) => {
+    const all: any[] = await ctx.runQuery(internal.knowledge.listAllChunks, {});
+
+    let scheduled = 0;
+    for (const chunk of all) {
+      const staleEn =
+        !chunk.embedding_en ||
+        !chunk.embeddedAt_en ||
+        chunk.embeddedAt_en < chunk.updatedAt;
+      const staleDe =
+        !chunk.embedding_de ||
+        !chunk.embeddedAt_de ||
+        chunk.embeddedAt_de < chunk.updatedAt;
+
+      if (staleEn) {
+        await ctx.scheduler.runAfter(0, internal.knowledgeSearch.embedChunk, {
+          chunkId: chunk._id,
+          language: "en",
+        });
+        scheduled++;
+      } else if (staleDe) {
+        // embedChunk for EN will chain to DE when EN is already fresh
+        await ctx.scheduler.runAfter(0, internal.knowledgeSearch.embedChunk, {
+          chunkId: chunk._id,
+          language: "de",
+        });
+        scheduled++;
+      }
+    }
+
+    console.log(`[scheduleStaleEmbeddings] scheduled ${scheduled} jobs for ${all.length} chunks`);
+    return { total: all.length, scheduled };
+  },
+});
+
 export interface KnowledgeResult {
   title: string;
   content: string;
@@ -63,11 +178,9 @@ export interface KnowledgeResult {
 
 /**
  * Search knowledge chunks by embedding similarity.
- *
- * - language: the requested language for returned title/content ("en" | "de")
- * - Uses the embedding index for the requested language.
- * - Falls back to the other language's index if the primary has no vectors.
- * - Returns up to `limit` results (default 5).
+ * - language: "en" | "de" — which index to search and which fields to return
+ * - Falls back to the other language index if primary has no vectors yet
+ * - Returns up to `limit` results (default 5)
  */
 export const searchKnowledge = action({
   args: {
@@ -77,22 +190,14 @@ export const searchKnowledge = action({
     limit: v.optional(v.number()),
     apiToken: v.string(),
   },
-  handler: async (
-    ctx,
-    { topic, query, language, limit = DEFAULT_SEARCH_LIMIT, apiToken },
-  ): Promise<KnowledgeResult[]> => {
+  handler: async (ctx, { topic, query, language, limit = DEFAULT_SEARCH_LIMIT, apiToken }) => {
     const embedding = await getEmbedding(query, apiToken);
-
     return _searchByVector(ctx, { topic, embedding, language, limit });
   },
 });
 
 /**
- * Search knowledge chunks by pre-computed embedding vector (no outbound fetch needed).
- *
- * - language: the requested language for returned title/content ("en" | "de")
- * - Falls back to the other language's index if primary has no vectors.
- * - Returns up to `limit` results (default 5).
+ * Search with a pre-computed embedding vector (no outbound fetch).
  */
 export const searchByVector = action({
   args: {
@@ -101,10 +206,7 @@ export const searchByVector = action({
     language: v.union(v.literal("en"), v.literal("de")),
     limit: v.optional(v.number()),
   },
-  handler: async (
-    ctx,
-    { topic, embedding, language, limit = DEFAULT_SEARCH_LIMIT },
-  ): Promise<KnowledgeResult[]> => {
+  handler: async (ctx, { topic, embedding, language, limit = DEFAULT_SEARCH_LIMIT }) => {
     return _searchByVector(ctx, { topic, embedding, language, limit });
   },
 });
@@ -127,7 +229,6 @@ async function _searchByVector(
   const fallbackIndex = language === "en" ? "by_embedding_de" : "by_embedding_en";
   const fallbackLanguage: "en" | "de" = language === "en" ? "de" : "en";
 
-  // Try primary language index first
   let results = await ctx.vectorSearch("knowledgeChunks", primaryIndex, {
     vector: embedding,
     limit,
@@ -136,7 +237,6 @@ async function _searchByVector(
 
   let embeddingLanguage: "en" | "de" = language;
 
-  // Fall back to the other language's index if primary returned nothing
   if (results.length === 0) {
     results = await ctx.vectorSearch("knowledgeChunks", fallbackIndex, {
       vector: embedding,
@@ -150,15 +250,10 @@ async function _searchByVector(
 
   const docs: (KnowledgeResult | null)[] = await Promise.all(
     results.map(async (r: any): Promise<KnowledgeResult | null> => {
-      const doc: any = await ctx.runQuery(internal.knowledge.getChunk, {
-        chunkId: r._id,
-      });
+      const doc: any = await ctx.runQuery(internal.knowledge.getChunk, { chunkId: r._id });
       if (!doc) return null;
-
       const title = language === "en" ? doc.title_English : doc.title_Deutsch;
-      const content =
-        language === "en" ? doc.content_English : doc.content_Deutsch;
-
+      const content = language === "en" ? doc.content_English : doc.content_Deutsch;
       return {
         title,
         content,
@@ -175,89 +270,3 @@ async function _searchByVector(
 
   return docs.filter((d): d is KnowledgeResult => d !== null);
 }
-
-/**
- * Re-embed stale chunks for both languages.
- * Embeds English and Deutsch separately, storing embedding_en and embedding_de.
- */
-export const refreshEmbeddings = action({
-  args: {
-    apiToken: v.string(),
-  },
-  handler: async (
-    ctx,
-    { apiToken },
-  ): Promise<{
-    total: number;
-    staleEn: number;
-    staleDe: number;
-    embeddedEn: number;
-    embeddedDe: number;
-    errors: number;
-  }> => {
-    const allChunks: any[] = await ctx.runQuery(
-      internal.knowledge.listAllChunks,
-      {},
-    );
-
-    const staleEn = allChunks.filter(
-      (c) =>
-        !c.embedding_en || !c.embeddedAt_en || c.embeddedAt_en < c.updatedAt,
-    );
-    const staleDe = allChunks.filter(
-      (c) =>
-        !c.embedding_de || !c.embeddedAt_de || c.embeddedAt_de < c.updatedAt,
-    );
-
-    let embeddedEn = 0;
-    let embeddedDe = 0;
-    let errors = 0;
-
-    for (const chunk of staleEn) {
-      try {
-        const embedding = await getEmbedding(
-          `${chunk.title_English}\n\n${chunk.content_English}`,
-          apiToken,
-        );
-        await ctx.runMutation(internal.knowledge.updateEmbeddingEn, {
-          chunkId: chunk._id,
-          embedding,
-        });
-        embeddedEn++;
-      } catch (e: any) {
-        console.error(
-          `Failed to embed EN chunk ${chunk.chunkKey}: ${e.message}`,
-        );
-        errors++;
-      }
-    }
-
-    for (const chunk of staleDe) {
-      try {
-        const embedding = await getEmbedding(
-          `${chunk.title_Deutsch}\n\n${chunk.content_Deutsch}`,
-          apiToken,
-        );
-        await ctx.runMutation(internal.knowledge.updateEmbeddingDe, {
-          chunkId: chunk._id,
-          embedding,
-        });
-        embeddedDe++;
-      } catch (e: any) {
-        console.error(
-          `Failed to embed DE chunk ${chunk.chunkKey}: ${e.message}`,
-        );
-        errors++;
-      }
-    }
-
-    return {
-      total: allChunks.length,
-      staleEn: staleEn.length,
-      staleDe: staleDe.length,
-      embeddedEn,
-      embeddedDe,
-      errors,
-    };
-  },
-});