@convex-dev/rag 0.1.7

package/src/client/setup.test.ts

@@ -0,0 +1,28 @@
+/// <reference types="vite/client" />
+import { test } from "vitest";
+import { convexTest } from "convex-test";
+export const modules = import.meta.glob("./**/*.*s");
+
+import {
+  defineSchema,
+  type GenericSchema,
+  type SchemaDefinition,
+} from "convex/server";
+import { type RAGComponent } from "./index.js";
+import { componentsGeneric } from "convex/server";
+import componentSchema from "../component/schema.js";
+export { componentSchema };
+export const componentModules = import.meta.glob("../component/**/*.ts");
+
+export function initConvexTest<
+  Schema extends SchemaDefinition<GenericSchema, boolean>,
+>(schema?: Schema) {
+  const t = convexTest(schema ?? defineSchema({}), modules);
+  t.registerComponent("rag", componentSchema, componentModules);
+  return t;
+}
+export const components = componentsGeneric() as unknown as {
+  rag: RAGComponent;
+};
+
+test("setup", () => {});

package/src/client/types.ts

@@ -0,0 +1,69 @@
+import type {
+  Expand,
+  FunctionReference,
+  GenericActionCtx,
+  GenericDataModel,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  StorageActionWriter,
+  StorageReader,
+} from "convex/server";
+import { type GenericId } from "convex/values";
+import type { Mounts } from "../component/_generated/api.js";
+
+// UseApi<typeof api> is an alternative that has jump-to-definition but is
+// less stable and reliant on types within the component files, which can cause
+// issues where passing `components.foo` doesn't match the argument
+export type RAGComponent = UseApi<Mounts>;
+
+// Type utils follow
+
+export type RunQueryCtx = {
+  runQuery: GenericQueryCtx<GenericDataModel>["runQuery"];
+};
+export type RunMutationCtx = {
+  runQuery: GenericMutationCtx<GenericDataModel>["runQuery"];
+  runMutation: GenericMutationCtx<GenericDataModel>["runMutation"];
+};
+export type RunActionCtx = {
+  runQuery: GenericActionCtx<GenericDataModel>["runQuery"];
+  runMutation: GenericActionCtx<GenericDataModel>["runMutation"];
+  runAction: GenericActionCtx<GenericDataModel>["runAction"];
+};
+export type ActionCtx = RunActionCtx & {
+  storage: StorageActionWriter;
+};
+export type QueryCtx = RunQueryCtx & {
+  storage: StorageReader;
+};
+
+export type OpaqueIds<T> =
+  T extends GenericId<infer _T>
+    ? string
+    : T extends (infer U)[]
+      ? OpaqueIds<U>[]
+      : T extends ArrayBuffer
+        ? ArrayBuffer
+        : T extends object
+          ? {
+              [K in keyof T]: OpaqueIds<T[K]>;
+            }
+          : T;
+
+export type UseApi<API> = Expand<{
+  [mod in keyof API]: API[mod] extends FunctionReference<
+    infer FType,
+    "public",
+    infer FArgs,
+    infer FReturnType,
+    infer FComponentPath
+  >
+    ? FunctionReference<
+        FType,
+        "internal",
+        OpaqueIds<FArgs>,
+        OpaqueIds<FReturnType>,
+        FComponentPath
+      >
+    : UseApi<API[mod]>;
+}>;

package/src/component/_generated/api.d.ts

@@ -0,0 +1,439 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type * as chunks from "../chunks.js";
+import type * as embeddings_importance from "../embeddings/importance.js";
+import type * as embeddings_index from "../embeddings/index.js";
+import type * as embeddings_tables from "../embeddings/tables.js";
+import type * as entries from "../entries.js";
+import type * as filters from "../filters.js";
+import type * as namespaces from "../namespaces.js";
+import type * as search from "../search.js";
+
+import type {
+  ApiFromModules,
+  FilterApi,
+  FunctionReference,
+} from "convex/server";
+
+/**
+ * A utility for referencing Convex functions in your app's API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+declare const fullApi: ApiFromModules<{
+  chunks: typeof chunks;
+  "embeddings/importance": typeof embeddings_importance;
+  "embeddings/index": typeof embeddings_index;
+  "embeddings/tables": typeof embeddings_tables;
+  entries: typeof entries;
+  filters: typeof filters;
+  namespaces: typeof namespaces;
+  search: typeof search;
+}>;
+export type Mounts = {
+  chunks: {
+    insert: FunctionReference<
+      "mutation",
+      "public",
+      {
+        chunks: Array<{
+          content: { metadata?: Record<string, any>; text: string };
+          embedding: Array<number>;
+          searchableText?: string;
+        }>;
+        entryId: string;
+        startOrder: number;
+      },
+      { status: "pending" | "ready" | "replaced" }
+    >;
+    list: FunctionReference<
+      "query",
+      "public",
+      {
+        entryId: string;
+        paginationOpts: {
+          cursor: string | null;
+          endCursor?: string | null;
+          id?: number;
+          maximumBytesRead?: number;
+          maximumRowsRead?: number;
+          numItems: number;
+        };
+      },
+      {
+        continueCursor: string;
+        isDone: boolean;
+        page: Array<{
+          metadata?: Record<string, any>;
+          order: number;
+          state: "pending" | "ready" | "replaced";
+          text: string;
+        }>;
+        pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+        splitCursor?: string | null;
+      }
+    >;
+    replaceChunksPage: FunctionReference<
+      "mutation",
+      "public",
+      { entryId: string; startOrder: number },
+      { nextStartOrder: number; status: "pending" | "ready" | "replaced" }
+    >;
+  };
+  entries: {
+    add: FunctionReference<
+      "mutation",
+      "public",
+      {
+        allChunks?: Array<{
+          content: { metadata?: Record<string, any>; text: string };
+          embedding: Array<number>;
+          searchableText?: string;
+        }>;
+        entry: {
+          contentHash?: string;
+          filterValues: Array<{ name: string; value: any }>;
+          importance: number;
+          key?: string;
+          metadata?: Record<string, any>;
+          namespaceId: string;
+          title?: string;
+        };
+        onComplete?: string;
+      },
+      {
+        created: boolean;
+        entryId: string;
+        replacedVersion: {
+          contentHash?: string;
+          entryId: string;
+          filterValues: Array<{ name: string; value: any }>;
+          importance: number;
+          key?: string;
+          metadata?: Record<string, any>;
+          status: "pending" | "ready" | "replaced";
+          title?: string;
+        } | null;
+        status: "pending" | "ready" | "replaced";
+      }
+    >;
+    addAsync: FunctionReference<
+      "mutation",
+      "public",
+      {
+        chunker: string;
+        entry: {
+          contentHash?: string;
+          filterValues: Array<{ name: string; value: any }>;
+          importance: number;
+          key?: string;
+          metadata?: Record<string, any>;
+          namespaceId: string;
+          title?: string;
+        };
+        onComplete?: string;
+      },
+      { created: boolean; entryId: string; status: "pending" | "ready" }
+    >;
+    deleteAsync: FunctionReference<
+      "mutation",
+      "public",
+      { entryId: string; startOrder: number },
+      null
+    >;
+    findByContentHash: FunctionReference<
+      "query",
+      "public",
+      {
+        contentHash: string;
+        dimension: number;
+        filterNames: Array<string>;
+        key: string;
+        modelId: string;
+        namespace: string;
+      },
+      {
+        contentHash?: string;
+        entryId: string;
+        filterValues: Array<{ name: string; value: any }>;
+        importance: number;
+        key?: string;
+        metadata?: Record<string, any>;
+        status: "pending" | "ready" | "replaced";
+        title?: string;
+      } | null
+    >;
+    get: FunctionReference<
+      "query",
+      "public",
+      { entryId: string },
+      {
+        contentHash?: string;
+        entryId: string;
+        filterValues: Array<{ name: string; value: any }>;
+        importance: number;
+        key?: string;
+        metadata?: Record<string, any>;
+        status: "pending" | "ready" | "replaced";
+        title?: string;
+      } | null
+    >;
+    list: FunctionReference<
+      "query",
+      "public",
+      {
+        namespaceId: string;
+        order?: "desc" | "asc";
+        paginationOpts: {
+          cursor: string | null;
+          endCursor?: string | null;
+          id?: number;
+          maximumBytesRead?: number;
+          maximumRowsRead?: number;
+          numItems: number;
+        };
+        status: "pending" | "ready" | "replaced";
+      },
+      {
+        continueCursor: string;
+        isDone: boolean;
+        page: Array<{
+          contentHash?: string;
+          entryId: string;
+          filterValues: Array<{ name: string; value: any }>;
+          importance: number;
+          key?: string;
+          metadata?: Record<string, any>;
+          status: "pending" | "ready" | "replaced";
+          title?: string;
+        }>;
+        pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+        splitCursor?: string | null;
+      }
+    >;
+    promoteToReady: FunctionReference<
+      "mutation",
+      "public",
+      { entryId: string },
+      {
+        replacedVersion: {
+          contentHash?: string;
+          entryId: string;
+          filterValues: Array<{ name: string; value: any }>;
+          importance: number;
+          key?: string;
+          metadata?: Record<string, any>;
+          status: "pending" | "ready" | "replaced";
+          title?: string;
+        } | null;
+      }
+    >;
+  };
+  namespaces: {
+    get: FunctionReference<
+      "query",
+      "public",
+      {
+        dimension: number;
+        filterNames: Array<string>;
+        modelId: string;
+        namespace: string;
+      },
+      null | {
+        createdAt: number;
+        dimension: number;
+        filterNames: Array<string>;
+        modelId: string;
+        namespace: string;
+        namespaceId: string;
+        status: "pending" | "ready" | "replaced";
+        version: number;
+      }
+    >;
+    getOrCreate: FunctionReference<
+      "mutation",
+      "public",
+      {
+        dimension: number;
+        filterNames: Array<string>;
+        modelId: string;
+        namespace: string;
+        onComplete?: string;
+        status: "pending" | "ready";
+      },
+      { namespaceId: string; status: "pending" | "ready" }
+    >;
+    list: FunctionReference<
+      "query",
+      "public",
+      {
+        paginationOpts: {
+          cursor: string | null;
+          endCursor?: string | null;
+          id?: number;
+          maximumBytesRead?: number;
+          maximumRowsRead?: number;
+          numItems: number;
+        };
+        status: "pending" | "ready" | "replaced";
+      },
+      {
+        continueCursor: string;
+        isDone: boolean;
+        page: Array<{
+          createdAt: number;
+          dimension: number;
+          filterNames: Array<string>;
+          modelId: string;
+          namespace: string;
+          namespaceId: string;
+          status: "pending" | "ready" | "replaced";
+          version: number;
+        }>;
+        pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+        splitCursor?: string | null;
+      }
+    >;
+    lookup: FunctionReference<
+      "query",
+      "public",
+      {
+        dimension: number;
+        filterNames: Array<string>;
+        modelId: string;
+        namespace: string;
+      },
+      null | string
+    >;
+    promoteToReady: FunctionReference<
+      "mutation",
+      "public",
+      { namespaceId: string },
+      {
+        replacedVersion: null | {
+          createdAt: number;
+          dimension: number;
+          filterNames: Array<string>;
+          modelId: string;
+          namespace: string;
+          namespaceId: string;
+          status: "pending" | "ready" | "replaced";
+          version: number;
+        };
+      }
+    >;
+  };
+  search: {
+    search: FunctionReference<
+      "action",
+      "public",
+      {
+        chunkContext?: { after: number; before: number };
+        embedding: Array<number>;
+        filters: Array<{ name: string; value: any }>;
+        limit: number;
+        modelId: string;
+        namespace: string;
+        vectorScoreThreshold?: number;
+      },
+      {
+        entries: Array<{
+          contentHash?: string;
+          entryId: string;
+          filterValues: Array<{ name: string; value: any }>;
+          importance: number;
+          key?: string;
+          metadata?: Record<string, any>;
+          status: "pending" | "ready" | "replaced";
+          title?: string;
+        }>;
+        results: Array<{
+          content: Array<{ metadata?: Record<string, any>; text: string }>;
+          entryId: string;
+          order: number;
+          score: number;
+          startOrder: number;
+        }>;
+      }
+    >;
+  };
+};
+// For now fullApiWithMounts is only fullApi which provides
+// jump-to-definition in component client code.
+// Use Mounts for the same type without the inference.
+declare const fullApiWithMounts: typeof fullApi;
+
+export declare const api: FilterApi<
+  typeof fullApiWithMounts,
+  FunctionReference<any, "public">
+>;
+export declare const internal: FilterApi<
+  typeof fullApiWithMounts,
+  FunctionReference<any, "internal">
+>;
+
+export declare const components: {
+  workpool: {
+    lib: {
+      cancel: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          id: string;
+          logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
+        },
+        any
+      >;
+      cancelAll: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          before?: number;
+          logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
+        },
+        any
+      >;
+      enqueue: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          config: {
+            logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
+            maxParallelism: number;
+          };
+          fnArgs: any;
+          fnHandle: string;
+          fnName: string;
+          fnType: "action" | "mutation" | "query";
+          onComplete?: { context?: any; fnHandle: string };
+          retryBehavior?: {
+            base: number;
+            initialBackoffMs: number;
+            maxAttempts: number;
+          };
+          runAt: number;
+        },
+        string
+      >;
+      status: FunctionReference<
+        "query",
+        "internal",
+        { id: string },
+        | { previousAttempts: number; state: "pending" }
+        | { previousAttempts: number; state: "running" }
+        | { state: "finished" }
+      >;
+    };
+  };
+};

package/src/component/_generated/api.js

@@ -0,0 +1,23 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import { anyApi, componentsGeneric } from "convex/server";
+
+/**
+ * A utility for referencing Convex functions in your app's API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+export const internal = anyApi;
+export const components = componentsGeneric();

package/src/component/_generated/dataModel.d.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  DataModelFromSchemaDefinition,
+  DocumentByName,
+  TableNamesInDataModel,
+  SystemTableNames,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
+
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> =
+  GenericId<TableName>;
+
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;