unrag 0.2.4 → 0.2.6

package/registry/core/context-engine.ts

@@ -3,6 +3,17 @@ import { ingest, planIngest } from "./ingest";
 import { retrieve } from "./retrieve";
 import { defineConfig, resolveConfig } from "./config";
 import { createAiEmbeddingProvider } from "../embedding/ai";
+import { createOpenAiEmbeddingProvider } from "../embedding/openai";
+import { createGoogleEmbeddingProvider } from "../embedding/google";
+import { createOpenRouterEmbeddingProvider } from "../embedding/openrouter";
+import { createAzureEmbeddingProvider } from "../embedding/azure";
+import { createVertexEmbeddingProvider } from "../embedding/vertex";
+import { createBedrockEmbeddingProvider } from "../embedding/bedrock";
+import { createCohereEmbeddingProvider } from "../embedding/cohere";
+import { createMistralEmbeddingProvider } from "../embedding/mistral";
+import { createTogetherEmbeddingProvider } from "../embedding/together";
+import { createOllamaEmbeddingProvider } from "../embedding/ollama";
+import { createVoyageEmbeddingProvider } from "../embedding/voyage";
 import type {
   AssetExtractor,
   ContextEngineConfig,
@@ -70,6 +81,61 @@ export const defineUnragConfig = <T extends DefineUnragConfigInput>(config: T) =
       return embeddingProvider;
     }
 
+    if (config.embedding.provider === "openai") {
+      embeddingProvider = createOpenAiEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
+    if (config.embedding.provider === "google") {
+      embeddingProvider = createGoogleEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
+    if (config.embedding.provider === "openrouter") {
+      embeddingProvider = createOpenRouterEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
+    if (config.embedding.provider === "azure") {
+      embeddingProvider = createAzureEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
+    if (config.embedding.provider === "vertex") {
+      embeddingProvider = createVertexEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
+    if (config.embedding.provider === "bedrock") {
+      embeddingProvider = createBedrockEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
+    if (config.embedding.provider === "cohere") {
+      embeddingProvider = createCohereEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
+    if (config.embedding.provider === "mistral") {
+      embeddingProvider = createMistralEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
+    if (config.embedding.provider === "together") {
+      embeddingProvider = createTogetherEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
+    if (config.embedding.provider === "ollama") {
+      embeddingProvider = createOllamaEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
+    if (config.embedding.provider === "voyage") {
+      embeddingProvider = createVoyageEmbeddingProvider(config.embedding.config);
+      return embeddingProvider;
+    }
+
     embeddingProvider = config.embedding.create();
     return embeddingProvider;
   };
@@ -104,5 +170,3 @@ export const defineUnragConfig = <T extends DefineUnragConfigInput>(config: T) =
       new ContextEngine(createEngineConfig(runtime)),
   };
 };
-
-

package/registry/core/types.ts

@@ -670,6 +670,50 @@ export type UnragEmbeddingConfig =
       provider: "ai";
       config?: import("../embedding/ai").AiEmbeddingConfig;
     }
+  | {
+      provider: "openai";
+      config?: import("../embedding/openai").OpenAiEmbeddingConfig;
+    }
+  | {
+      provider: "google";
+      config?: import("../embedding/google").GoogleEmbeddingConfig;
+    }
+  | {
+      provider: "openrouter";
+      config?: import("../embedding/openrouter").OpenRouterEmbeddingConfig;
+    }
+  | {
+      provider: "azure";
+      config?: import("../embedding/azure").AzureEmbeddingConfig;
+    }
+  | {
+      provider: "vertex";
+      config?: import("../embedding/vertex").VertexEmbeddingConfig;
+    }
+  | {
+      provider: "bedrock";
+      config?: import("../embedding/bedrock").BedrockEmbeddingConfig;
+    }
+  | {
+      provider: "cohere";
+      config?: import("../embedding/cohere").CohereEmbeddingConfig;
+    }
+  | {
+      provider: "mistral";
+      config?: import("../embedding/mistral").MistralEmbeddingConfig;
+    }
+  | {
+      provider: "together";
+      config?: import("../embedding/together").TogetherEmbeddingConfig;
+    }
+  | {
+      provider: "ollama";
+      config?: import("../embedding/ollama").OllamaEmbeddingConfig;
+    }
+  | {
+      provider: "voyage";
+      config?: import("../embedding/voyage").VoyageEmbeddingConfig;
+    }
   | {
       provider: "custom";
       /**
@@ -736,5 +780,3 @@ export type ResolvedContextEngineConfig = {
   storage: ContentStorageConfig;
   assetProcessing: AssetProcessingConfig;
 };
-
-

package/registry/docs/unrag.md

@@ -8,9 +8,14 @@ Unrag installs a small RAG module into your codebase with:
 
 Add these to your environment:
 - `DATABASE_URL` (Postgres connection string)
-- `AI_GATEWAY_API_KEY` (required by the `ai` SDK when using Vercel AI Gateway)
+- (Embedding) set the environment variables required by your selected provider.
+
+If you used the default provider (Vercel AI Gateway):
+- `AI_GATEWAY_API_KEY`
 - Optional: `AI_GATEWAY_MODEL` (defaults to `openai/text-embedding-3-small`)
 
+If you picked a different provider (OpenAI / Google / Voyage / etc.), see the installed provider docs under your Unrag docs site (`/docs/providers/*`).
+
 ## Database requirements
 
 Enable pgvector:

package/registry/embedding/_shared.ts

@@ -0,0 +1,20 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+export function requireOptional<T = any>(args: {
+  id: string;
+  installHint: string;
+  providerName: string;
+}): T {
+  try {
+    return require(args.id) as T;
+  } catch {
+    throw new Error(
+      `Unrag embedding provider "${args.providerName}" requires "${args.id}" to be installed.\n` +
+        `Install it with: ${args.installHint}`
+    );
+  }
+}
+
+

package/registry/embedding/ai.ts

@@ -1,5 +1,5 @@
 import { embed, embedMany } from "ai";
-import type { EmbeddingProvider, ImageEmbeddingInput } from "../core/types";
+import type { EmbeddingProvider } from "../core/types";
 
 type BaseConfig = {
   /**
@@ -9,52 +9,18 @@ type BaseConfig = {
   timeoutMs?: number;
 };
 
-export type AiEmbeddingConfig =
-  | (BaseConfig & {
-      /**
-       * Defaults to "text" for backwards compatibility.
-       * - "text": only supports embedding strings
-       * - "multimodal": additionally enables `embedImage()` for image assets (when the model supports it)
-       */
-      type?: "text";
-    })
-  | (BaseConfig & {
-      type: "multimodal";
-      /**
-       * Controls how images are translated into AI SDK `embed()` values.
-       * Different providers use different shapes; this is the escape hatch.
-       */
-      image?: {
-        value?: (input: ImageEmbeddingInput) => unknown;
-      };
-    });
+/**
+ * Text-only embedding config for the AI SDK provider.
+ */
+export type AiEmbeddingConfig = BaseConfig;
 
 const DEFAULT_TEXT_MODEL = "openai/text-embedding-3-small";
-const DEFAULT_MULTIMODAL_MODEL = "cohere/embed-v4.0";
-
-const bytesToDataUrl = (bytes: Uint8Array, mediaType: string) => {
-  const base64 = Buffer.from(bytes).toString("base64");
-  return `data:${mediaType};base64,${base64}`;
-};
-
-const defaultImageValue = (input: ImageEmbeddingInput) => {
-  const v =
-    typeof input.data === "string"
-      ? input.data
-      : bytesToDataUrl(input.data, input.mediaType ?? "image/jpeg");
-  // This matches common AI Gateway multimodal embedding inputs where
-  // the embedding value is an object containing one or more images.
-  return { image: [v] };
-};
 
 export const createAiEmbeddingProvider = (
   config: AiEmbeddingConfig = {}
 ): EmbeddingProvider => {
-  const type = (config as any).type ?? "text";
   const model =
-    config.model ??
-    process.env.AI_GATEWAY_MODEL ??
-    (type === "multimodal" ? DEFAULT_MULTIMODAL_MODEL : DEFAULT_TEXT_MODEL);
+    config.model ?? process.env.AI_GATEWAY_MODEL ?? DEFAULT_TEXT_MODEL;
   const timeoutMs = config.timeoutMs;
 
   return {
@@ -93,31 +59,6 @@ export const createAiEmbeddingProvider = (
       }
       return embeddings;
     },
-    ...(type === "multimodal"
-      ? {
-          embedImage: async (input: ImageEmbeddingInput) => {
-            const abortSignal = timeoutMs
-              ? AbortSignal.timeout(timeoutMs)
-              : undefined;
-
-            const imageValue =
-              (config as any)?.image?.value?.(input) ?? defaultImageValue(input);
-
-            const result = await embed({
-              model,
-              value: imageValue,
-              ...(abortSignal ? { abortSignal } : {}),
-            });
-
-            if (!result.embedding) {
-              throw new Error("Embedding missing from AI SDK response");
-            }
-
-            return result.embedding;
-          },
-        }
-      : {}),
   };
 };
 
-

package/registry/embedding/azure.ts

@@ -0,0 +1,79 @@
+import { embed, embedMany } from "ai";
+import type { EmbeddingProvider } from "../core/types";
+import { requireOptional } from "./_shared";
+
+export type AzureEmbeddingConfig = {
+  model?: string;
+  timeoutMs?: number;
+  dimensions?: number;
+  user?: string;
+};
+
+const DEFAULT_TEXT_MODEL = "text-embedding-3-small";
+
+const buildProviderOptions = (config: AzureEmbeddingConfig) => {
+  if (config.dimensions === undefined && config.user === undefined) {
+    return undefined;
+  }
+  return {
+    openai: {
+      ...(config.dimensions !== undefined ? { dimensions: config.dimensions } : {}),
+      ...(config.user ? { user: config.user } : {}),
+    },
+  };
+};
+
+export const createAzureEmbeddingProvider = (
+  config: AzureEmbeddingConfig = {}
+): EmbeddingProvider => {
+  const { azure } = requireOptional<any>({
+    id: "@ai-sdk/azure",
+    installHint: "bun add @ai-sdk/azure",
+    providerName: "azure",
+  });
+  const model =
+    config.model ?? process.env.AZURE_EMBEDDING_MODEL ?? DEFAULT_TEXT_MODEL;
+  const timeoutMs = config.timeoutMs;
+  const providerOptions = buildProviderOptions(config);
+  const embeddingModel = azure.embedding(model);
+
+  return {
+    name: `azure:${model}`,
+    dimensions: config.dimensions,
+    embed: async ({ text }) => {
+      const abortSignal = timeoutMs
+        ? AbortSignal.timeout(timeoutMs)
+        : undefined;
+
+      const result = await embed({
+        model: embeddingModel,
+        value: text,
+        ...(providerOptions ? { providerOptions } : {}),
+        ...(abortSignal ? { abortSignal } : {}),
+      });
+
+      if (!result.embedding) {
+        throw new Error("Embedding missing from Azure OpenAI response");
+      }
+
+      return result.embedding;
+    },
+    embedMany: async (inputs) => {
+      const values = inputs.map((i) => i.text);
+      const abortSignal = timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined;
+
+      const result = await embedMany({
+        model: embeddingModel,
+        values,
+        ...(providerOptions ? { providerOptions } : {}),
+        ...(abortSignal ? { abortSignal } : {}),
+      });
+
+      const { embeddings } = result;
+      if (!Array.isArray(embeddings)) {
+        throw new Error("Embeddings missing from Azure OpenAI embedMany response");
+      }
+      return embeddings;
+    },
+  };
+};

package/registry/embedding/bedrock.ts

@@ -0,0 +1,79 @@
+import { embed, embedMany } from "ai";
+import type { EmbeddingProvider } from "../core/types";
+import { requireOptional } from "./_shared";
+
+export type BedrockEmbeddingConfig = {
+  model?: string;
+  timeoutMs?: number;
+  dimensions?: number;
+  normalize?: boolean;
+};
+
+const DEFAULT_TEXT_MODEL = "amazon.titan-embed-text-v2:0";
+
+const buildProviderOptions = (config: BedrockEmbeddingConfig) => {
+  if (config.dimensions === undefined && config.normalize === undefined) {
+    return undefined;
+  }
+  return {
+    bedrock: {
+      ...(config.dimensions !== undefined ? { dimensions: config.dimensions } : {}),
+      ...(config.normalize !== undefined ? { normalize: config.normalize } : {}),
+    },
+  };
+};
+
+export const createBedrockEmbeddingProvider = (
+  config: BedrockEmbeddingConfig = {}
+): EmbeddingProvider => {
+  const { bedrock } = requireOptional<any>({
+    id: "@ai-sdk/amazon-bedrock",
+    installHint: "bun add @ai-sdk/amazon-bedrock",
+    providerName: "bedrock",
+  });
+  const model =
+    config.model ?? process.env.BEDROCK_EMBEDDING_MODEL ?? DEFAULT_TEXT_MODEL;
+  const timeoutMs = config.timeoutMs;
+  const providerOptions = buildProviderOptions(config);
+  const embeddingModel = bedrock.embedding(model);
+
+  return {
+    name: `bedrock:${model}`,
+    dimensions: config.dimensions,
+    embed: async ({ text }) => {
+      const abortSignal = timeoutMs
+        ? AbortSignal.timeout(timeoutMs)
+        : undefined;
+
+      const result = await embed({
+        model: embeddingModel,
+        value: text,
+        ...(providerOptions ? { providerOptions } : {}),
+        ...(abortSignal ? { abortSignal } : {}),
+      });
+
+      if (!result.embedding) {
+        throw new Error("Embedding missing from Bedrock response");
+      }
+
+      return result.embedding;
+    },
+    embedMany: async (inputs) => {
+      const values = inputs.map((i) => i.text);
+      const abortSignal = timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined;
+
+      const result = await embedMany({
+        model: embeddingModel,
+        values,
+        ...(providerOptions ? { providerOptions } : {}),
+        ...(abortSignal ? { abortSignal } : {}),
+      });
+
+      const { embeddings } = result;
+      if (!Array.isArray(embeddings)) {
+        throw new Error("Embeddings missing from Bedrock embedMany response");
+      }
+      return embeddings;
+    },
+  };
+};

package/registry/embedding/cohere.ts

@@ -0,0 +1,79 @@
+import { embed, embedMany } from "ai";
+import type { EmbeddingProvider } from "../core/types";
+import { requireOptional } from "./_shared";
+
+export type CohereEmbeddingConfig = {
+  model?: string;
+  timeoutMs?: number;
+  inputType?: "search_document" | "search_query" | "classification" | "clustering";
+  truncate?: "NONE" | "START" | "END";
+};
+
+const DEFAULT_TEXT_MODEL = "embed-english-v3.0";
+
+const buildProviderOptions = (config: CohereEmbeddingConfig) => {
+  if (!config.inputType && !config.truncate) {
+    return undefined;
+  }
+  return {
+    cohere: {
+      ...(config.inputType ? { inputType: config.inputType } : {}),
+      ...(config.truncate ? { truncate: config.truncate } : {}),
+    },
+  };
+};
+
+export const createCohereEmbeddingProvider = (
+  config: CohereEmbeddingConfig = {}
+): EmbeddingProvider => {
+  const { cohere } = requireOptional<any>({
+    id: "@ai-sdk/cohere",
+    installHint: "bun add @ai-sdk/cohere",
+    providerName: "cohere",
+  });
+  const model =
+    config.model ?? process.env.COHERE_EMBEDDING_MODEL ?? DEFAULT_TEXT_MODEL;
+  const timeoutMs = config.timeoutMs;
+  const providerOptions = buildProviderOptions(config);
+  const embeddingModel = cohere.embedding(model);
+
+  return {
+    name: `cohere:${model}`,
+    dimensions: undefined,
+    embed: async ({ text }) => {
+      const abortSignal = timeoutMs
+        ? AbortSignal.timeout(timeoutMs)
+        : undefined;
+
+      const result = await embed({
+        model: embeddingModel,
+        value: text,
+        ...(providerOptions ? { providerOptions } : {}),
+        ...(abortSignal ? { abortSignal } : {}),
+      });
+
+      if (!result.embedding) {
+        throw new Error("Embedding missing from Cohere response");
+      }
+
+      return result.embedding;
+    },
+    embedMany: async (inputs) => {
+      const values = inputs.map((i) => i.text);
+      const abortSignal = timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined;
+
+      const result = await embedMany({
+        model: embeddingModel,
+        values,
+        ...(providerOptions ? { providerOptions } : {}),
+        ...(abortSignal ? { abortSignal } : {}),
+      });
+
+      const { embeddings } = result;
+      if (!Array.isArray(embeddings)) {
+        throw new Error("Embeddings missing from Cohere embedMany response");
+      }
+      return embeddings;
+    },
+  };
+};

package/registry/embedding/google.ts

@@ -0,0 +1,93 @@
+import { embed, embedMany } from "ai";
+import type { EmbeddingProvider } from "../core/types";
+import { requireOptional } from "./_shared";
+
+export type GoogleEmbeddingTaskType =
+  | "SEMANTIC_SIMILARITY"
+  | "CLASSIFICATION"
+  | "CLUSTERING"
+  | "RETRIEVAL_DOCUMENT"
+  | "RETRIEVAL_QUERY"
+  | "QUESTION_ANSWERING"
+  | "FACT_VERIFICATION"
+  | "CODE_RETRIEVAL_QUERY";
+
+export type GoogleEmbeddingConfig = {
+  model?: string;
+  timeoutMs?: number;
+  outputDimensionality?: number;
+  taskType?: GoogleEmbeddingTaskType;
+};
+
+const DEFAULT_TEXT_MODEL = "gemini-embedding-001";
+
+const buildProviderOptions = (config: GoogleEmbeddingConfig) => {
+  if (config.outputDimensionality === undefined && config.taskType === undefined) {
+    return undefined;
+  }
+  return {
+    google: {
+      ...(config.outputDimensionality !== undefined
+        ? { outputDimensionality: config.outputDimensionality }
+        : {}),
+      ...(config.taskType ? { taskType: config.taskType } : {}),
+    },
+  };
+};
+
+export const createGoogleEmbeddingProvider = (
+  config: GoogleEmbeddingConfig = {}
+): EmbeddingProvider => {
+  const { google } = requireOptional<any>({
+    id: "@ai-sdk/google",
+    installHint: "bun add @ai-sdk/google",
+    providerName: "google",
+  });
+  const model =
+    config.model ??
+    process.env.GOOGLE_GENERATIVE_AI_EMBEDDING_MODEL ??
+    DEFAULT_TEXT_MODEL;
+  const timeoutMs = config.timeoutMs;
+  const providerOptions = buildProviderOptions(config);
+  const embeddingModel = google.embedding(model);
+
+  return {
+    name: `google:${model}`,
+    dimensions: config.outputDimensionality,
+    embed: async ({ text }) => {
+      const abortSignal = timeoutMs
+        ? AbortSignal.timeout(timeoutMs)
+        : undefined;
+
+      const result = await embed({
+        model: embeddingModel,
+        value: text,
+        ...(providerOptions ? { providerOptions } : {}),
+        ...(abortSignal ? { abortSignal } : {}),
+      });
+
+      if (!result.embedding) {
+        throw new Error("Embedding missing from Google response");
+      }
+
+      return result.embedding;
+    },
+    embedMany: async (inputs) => {
+      const values = inputs.map((i) => i.text);
+      const abortSignal = timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined;
+
+      const result = await embedMany({
+        model: embeddingModel,
+        values,
+        ...(providerOptions ? { providerOptions } : {}),
+        ...(abortSignal ? { abortSignal } : {}),
+      });
+
+      const { embeddings } = result;
+      if (!Array.isArray(embeddings)) {
+        throw new Error("Embeddings missing from Google embedMany response");
+      }
+      return embeddings;
+    },
+  };
+};

package/registry/embedding/mistral.ts

@@ -0,0 +1,62 @@
+import { embed, embedMany } from "ai";
+import type { EmbeddingProvider } from "../core/types";
+import { requireOptional } from "./_shared";
+
+export type MistralEmbeddingConfig = {
+  model?: string;
+  timeoutMs?: number;
+};
+
+const DEFAULT_TEXT_MODEL = "mistral-embed";
+
+export const createMistralEmbeddingProvider = (
+  config: MistralEmbeddingConfig = {}
+): EmbeddingProvider => {
+  const { mistral } = requireOptional<any>({
+    id: "@ai-sdk/mistral",
+    installHint: "bun add @ai-sdk/mistral",
+    providerName: "mistral",
+  });
+  const model =
+    config.model ?? process.env.MISTRAL_EMBEDDING_MODEL ?? DEFAULT_TEXT_MODEL;
+  const timeoutMs = config.timeoutMs;
+  const embeddingModel = mistral.embedding(model);
+
+  return {
+    name: `mistral:${model}`,
+    dimensions: undefined,
+    embed: async ({ text }) => {
+      const abortSignal = timeoutMs
+        ? AbortSignal.timeout(timeoutMs)
+        : undefined;
+
+      const result = await embed({
+        model: embeddingModel,
+        value: text,
+        ...(abortSignal ? { abortSignal } : {}),
+      });
+
+      if (!result.embedding) {
+        throw new Error("Embedding missing from Mistral response");
+      }
+
+      return result.embedding;
+    },
+    embedMany: async (inputs) => {
+      const values = inputs.map((i) => i.text);
+      const abortSignal = timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined;
+
+      const result = await embedMany({
+        model: embeddingModel,
+        values,
+        ...(abortSignal ? { abortSignal } : {}),
+      });
+
+      const { embeddings } = result;
+      if (!Array.isArray(embeddings)) {
+        throw new Error("Embeddings missing from Mistral embedMany response");
+      }
+      return embeddings;
+    },
+  };
+};