@retrivora-ai/rag-engine 0.1.7 → 0.1.9

package/src/config/serverConfig.ts

@@ -3,11 +3,28 @@
  *
  * This keeps secrets server-side and never exposes them to the browser.
  * Consumer projects set these env vars in their .env.local file.
+ *
+ * Supported VECTOR_DB_PROVIDER values and their required env vars:
+ *   pinecone      → PINECONE_API_KEY, PINECONE_INDEX
+ *   pgvector /
+ *   postgresql    → PGVECTOR_CONNECTION_STRING, VECTOR_DB_INDEX
+ *   mongodb       → MONGODB_URI, MONGODB_DB, MONGODB_COLLECTION
+ *   qdrant        → QDRANT_URL, QDRANT_API_KEY
+ *   milvus        → MILVUS_URL (e.g. http://localhost:19530)
+ *   chromadb      → CHROMADB_URL (e.g. http://localhost:8000)
+ *   weaviate      → WEAVIATE_URL, WEAVIATE_API_KEY
+ *   redis         → REDIS_URL, REDIS_API_KEY
+ *   rest /
+ *   universal_rest→ VECTOR_BASE_URL, VECTOR_DB_REST_API_KEY
  */
 
 import { RagConfig } from './RagConfig';
 
-const VECTOR_DB_PROVIDERS = ['pinecone', 'pgvector', 'postgresql', 'mongodb', 'milvus', 'qdrant', 'chromadb', 'redis', 'weaviate', 'rest', 'universal_rest', 'custom'] as const;
+const VECTOR_DB_PROVIDERS = [
+  'pinecone', 'pgvector', 'postgresql', 'mongodb', 'milvus',
+  'qdrant', 'chromadb', 'redis', 'weaviate', 'rest', 'universal_rest', 'custom',
+] as const;
+
 const LLM_PROVIDERS = ['openai', 'anthropic', 'ollama', 'rest', 'universal_rest', 'custom'] as const;
 const EMBEDDING_PROVIDERS = ['openai', 'ollama', 'rest', 'universal_rest', 'custom'] as const;
 
@@ -19,12 +36,10 @@ function readString(env: Record<string, string | undefined>, name: string): stri
 function readNumber(env: Record<string, string | undefined>, name: string, fallback: number): number {
   const value = env[name];
   if (!value) return fallback;
-
   const parsed = Number(value);
   if (!Number.isFinite(parsed)) {
     throw new Error(`[getRagConfig] ${name} must be a valid number`);
   }
-
   return parsed;
 }
 
@@ -38,12 +53,15 @@ function readEnum<T extends readonly string[]>(
   if ((allowed as readonly string[]).includes(value)) {
     return value as T[number];
   }
-
   throw new Error(`[getRagConfig] ${name} must be one of: ${allowed.join(', ')}`);
 }
 
 export function getRagConfig(env: Record<string, string | undefined> = process.env): RagConfig {
-  const projectId = readString(env, 'RAG_PROJECT_ID') ?? readString(env, 'NEXT_PUBLIC_PROJECT_ID') ?? '__default__';
+  const projectId =
+    readString(env, 'RAG_PROJECT_ID') ??
+    readString(env, 'NEXT_PUBLIC_PROJECT_ID') ??
+    '__default__';
+
   const vectorProvider = readEnum(env, 'VECTOR_DB_PROVIDER', 'pinecone', VECTOR_DB_PROVIDERS);
   const llmProvider = readEnum(env, 'LLM_PROVIDER', 'openai', LLM_PROVIDERS);
   const embeddingProvider = readEnum(env, 'EMBEDDING_PROVIDER', 'openai', EMBEDDING_PROVIDERS);
@@ -51,32 +69,44 @@ export function getRagConfig(env: Record<string, string | undefined> = process.e
 
   // Build provider-specific vectorDb options
   const vectorDbOptions: Record<string, unknown> = {};
+
   if (vectorProvider === 'pinecone') {
     vectorDbOptions.apiKey = readString(env, 'PINECONE_API_KEY') ?? '';
-    vectorDbOptions.environment = readString(env, 'PINECONE_ENVIRONMENT') ?? '';
-  } else if (vectorProvider === 'pgvector') {
+  } else if (vectorProvider === 'pgvector' || vectorProvider === 'postgresql') {
     vectorDbOptions.connectionString = readString(env, 'PGVECTOR_CONNECTION_STRING') ?? '';
     vectorDbOptions.dimensions = embeddingDimensions;
+  } else if (vectorProvider === 'mongodb') {
+    vectorDbOptions.uri = readString(env, 'MONGODB_URI') ?? '';
+    vectorDbOptions.database = readString(env, 'MONGODB_DB') ?? '';
+    vectorDbOptions.collection = readString(env, 'MONGODB_COLLECTION') ?? '';
+    vectorDbOptions.indexName = readString(env, 'MONGODB_INDEX_NAME') ?? 'vector_index';
+  } else if (vectorProvider === 'qdrant') {
+    vectorDbOptions.baseUrl = readString(env, 'QDRANT_URL') ?? 'http://localhost:6333';
+    vectorDbOptions.apiKey = readString(env, 'QDRANT_API_KEY');
+    vectorDbOptions.dimensions = embeddingDimensions;
+  } else if (vectorProvider === 'milvus') {
+    vectorDbOptions.baseUrl = readString(env, 'MILVUS_URL') ?? 'http://localhost:19530';
+    vectorDbOptions.apiKey = readString(env, 'MILVUS_API_KEY');
+  } else if (vectorProvider === 'chromadb') {
+    vectorDbOptions.baseUrl = readString(env, 'CHROMADB_URL') ?? 'http://localhost:8000';
+  } else if (vectorProvider === 'weaviate') {
+    vectorDbOptions.baseUrl = readString(env, 'WEAVIATE_URL') ?? 'http://localhost:8080';
+    vectorDbOptions.apiKey = readString(env, 'WEAVIATE_API_KEY');
+  } else if (vectorProvider === 'redis') {
+    vectorDbOptions.baseUrl = readString(env, 'REDIS_URL') ?? '';
+    vectorDbOptions.apiKey = readString(env, 'REDIS_API_KEY');
   } else if (vectorProvider === 'rest') {
     vectorDbOptions.baseUrl = readString(env, 'VECTOR_DB_REST_URL') ?? '';
     vectorDbOptions.headers = readString(env, 'VECTOR_DB_REST_API_KEY')
       ? { 'api-key': readString(env, 'VECTOR_DB_REST_API_KEY') }
       : {};
   } else if (vectorProvider === 'universal_rest') {
-    vectorDbOptions.baseUrl = readString(env, 'VECTOR_BASE_URL') ?? readString(env, 'VECTOR_DB_REST_URL') ?? '';
+    vectorDbOptions.baseUrl =
+      readString(env, 'VECTOR_BASE_URL') ?? readString(env, 'VECTOR_DB_REST_URL') ?? '';
     vectorDbOptions.profile = readString(env, 'VECTOR_UNIVERSAL_PROFILE');
     vectorDbOptions.headers = readString(env, 'VECTOR_DB_REST_API_KEY')
       ? { Authorization: `Bearer ${readString(env, 'VECTOR_DB_REST_API_KEY')}` }
       : {};
-  } else if (vectorProvider === 'mongodb') {
-    vectorDbOptions.uri = readString(env, 'MONGODB_URI') ?? '';
-    vectorDbOptions.database = readString(env, 'MONGODB_DB') ?? '';
-    vectorDbOptions.collection = readString(env, 'MONGODB_COLLECTION') ?? '';
-    vectorDbOptions.indexName = readString(env, 'MONGODB_INDEX_NAME') ?? 'vector_index';
-  } else if (vectorProvider === 'qdrant') {
-    vectorDbOptions.baseUrl = readString(env, 'QDRANT_URL') ?? 'http://localhost:6333';
-    vectorDbOptions.apiKey = readString(env, 'QDRANT_API_KEY');
-    vectorDbOptions.dimensions = embeddingDimensions;
   }
 
   const llmApiKeyByProvider: Record<string, string | undefined> = {
@@ -84,11 +114,14 @@ export function getRagConfig(env: Record<string, string | undefined> = process.e
     anthropic: readString(env, 'ANTHROPIC_API_KEY'),
     ollama: undefined,
     universal_rest: readString(env, 'LLM_API_KEY'),
+    rest: readString(env, 'LLM_API_KEY'),
+    custom: readString(env, 'LLM_API_KEY'),
   };
 
   const embeddingApiKeyByProvider: Record<string, string | undefined> = {
     openai: readString(env, 'OPENAI_API_KEY'),
     ollama: undefined,
+    universal_rest: readString(env, 'EMBEDDING_API_KEY') ?? readString(env, 'OPENAI_API_KEY'),
     custom: readString(env, 'EMBEDDING_API_KEY') ?? readString(env, 'OPENAI_API_KEY'),
   };
 
@@ -132,7 +165,7 @@ export function getRagConfig(env: Record<string, string | undefined> = process.e
       welcomeMessage:
         readString(env, 'NEXT_PUBLIC_WELCOME_MESSAGE') ??
         readString(env, 'UI_WELCOME_MESSAGE') ??
-        'Hello! I\'m your AI assistant. Ask me anything about your documents.',
+        "Hello! I'm your AI assistant. Ask me anything about your documents.",
       visualStyle: (readString(env, 'NEXT_PUBLIC_UI_VISUAL_STYLE') ?? readString(env, 'UI_VISUAL_STYLE') ?? 'glass') as 'glass' | 'solid',
       borderRadius: (readString(env, 'NEXT_PUBLIC_UI_BORDER_RADIUS') ?? readString(env, 'UI_BORDER_RADIUS') ?? 'xl') as 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full',
     },

package/src/core/ConfigValidator.ts

@@ -3,6 +3,10 @@
  *
  * Validates RagConfig against provider requirements and best practices.
  * Returns detailed errors for misconfiguration.
+ *
+ * Key invariant: option keys validated here MUST match the keys each
+ * Provider constructor reads. See each provider's constructor for the
+ * canonical option names.
  */
 
 import { RagConfig, VectorDBConfig, LLMConfig, EmbeddingConfig } from '../config/RagConfig';
@@ -22,7 +26,6 @@ export class ConfigValidator {
   static validate(config: RagConfig): ValidationError[] {
     const errors: ValidationError[] = [];
 
-    // Validate root level
     if (!config.projectId) {
       errors.push({
         field: 'projectId',
@@ -31,31 +34,24 @@ export class ConfigValidator {
       });
     }
 
-    // Validate Vector DB configuration
     errors.push(...this.validateVectorDbConfig(config.vectorDb));
-
-    // Validate LLM configuration
     errors.push(...this.validateLLMConfig(config.llm));
 
-    // Validate Embedding configuration (if provided)
     if (config.embedding) {
       errors.push(...this.validateEmbeddingConfig(config.embedding));
     } else if (config.llm.provider === 'anthropic') {
-      // Anthropic should have a separate embedding provider
       errors.push({
         field: 'embedding',
         message: 'Embedding config is required when using Anthropic LLM',
-        suggestion: 'Provide embedding config with provider (e.g., "openai")',
+        suggestion: 'Provide embedding config with provider (e.g., "openai" or "ollama")',
         severity: 'error',
       });
     }
 
-    // Validate UI config if provided
     if (config.ui) {
       errors.push(...this.validateUIConfig(config.ui as Record<string, unknown>));
     }
 
-    // Validate RAG tuning if provided
     if (config.rag) {
       errors.push(...this.validateRAGConfig(config.rag as Record<string, unknown>));
     }
@@ -83,7 +79,6 @@ export class ConfigValidator {
       });
     }
 
-    // Provider-specific validation
     switch (config.provider) {
       case 'pinecone':
         errors.push(...this.validatePineconeConfig(config));
@@ -119,6 +114,10 @@ export class ConfigValidator {
     return errors;
   }
 
+  /**
+   * Pinecone — only needs apiKey (environment was removed in SDK v7+).
+   * Options key: { apiKey: string }
+   */
   private static validatePineconeConfig(config: VectorDBConfig): ValidationError[] {
     const errors: ValidationError[] = [];
     const opts = config.options as Record<string, unknown>;
@@ -132,18 +131,13 @@ export class ConfigValidator {
       });
     }
 
-    if (!opts.environment) {
-      errors.push({
-        field: 'vectorDb.options.environment',
-        message: 'Pinecone environment is required',
-        suggestion: 'Set PINECONE_ENVIRONMENT environment variable (e.g., "gcp-starter")',
-        severity: 'error',
-      });
-    }
-
     return errors;
   }
 
+  /**
+   * PostgreSQL / pgvector — needs a connection string.
+   * Options key: { connectionString: string }
+   */
   private static validatePostgresConfig(config: VectorDBConfig): ValidationError[] {
     const errors: ValidationError[] = [];
     const opts = config.options as Record<string, unknown>;
@@ -160,6 +154,10 @@ export class ConfigValidator {
     return errors;
   }
 
+  /**
+   * MongoDB — needs uri, database, and collection.
+   * Options keys: { uri: string, database: string, collection: string }
+   */
   private static validateMongoDBConfig(config: VectorDBConfig): ValidationError[] {
     const errors: ValidationError[] = [];
     const opts = config.options as Record<string, unknown>;
@@ -194,24 +192,23 @@ export class ConfigValidator {
     return errors;
   }
 
+  /**
+   * Milvus — accepts baseUrl OR uri (preferred) OR host+port.
+   * MilvusProvider reads opts.baseUrl ?? opts.uri.
+   * Options keys: { baseUrl?: string, uri?: string, host?: string, port?: number }
+   */
   private static validateMilvusConfig(config: VectorDBConfig): ValidationError[] {
     const errors: ValidationError[] = [];
     const opts = config.options as Record<string, unknown>;
 
-    if (!opts.host) {
-      errors.push({
-        field: 'vectorDb.options.host',
-        message: 'Milvus host is required',
-        suggestion: 'Set MILVUS_HOST environment variable',
-        severity: 'error',
-      });
-    }
+    const hasBaseUrl = Boolean(opts.baseUrl || opts.uri);
+    const hasHostPort = Boolean(opts.host && opts.port);
 
-    if (!opts.port) {
+    if (!hasBaseUrl && !hasHostPort) {
       errors.push({
-        field: 'vectorDb.options.port',
-        message: 'Milvus port is required',
-        suggestion: 'Set MILVUS_PORT environment variable (default: 19530)',
+        field: 'vectorDb.options.baseUrl',
+        message: 'Milvus connection is required: provide baseUrl (e.g., "http://localhost:19530") or host + port',
+        suggestion: 'Set MILVUS_URL environment variable',
         severity: 'error',
       });
     }
@@ -219,6 +216,10 @@ export class ConfigValidator {
     return errors;
   }
 
+  /**
+   * Qdrant — needs baseUrl (or url alias).
+   * Options keys: { baseUrl: string, apiKey?: string }
+   */
   private static validateQdrantConfig(config: VectorDBConfig): ValidationError[] {
     const errors: ValidationError[] = [];
     const opts = config.options as Record<string, unknown>;
@@ -235,15 +236,20 @@ export class ConfigValidator {
     return errors;
   }
 
+  /**
+   * ChromaDB — accepts baseUrl OR host.
+   * ChromaDBProvider reads opts.baseUrl.
+   * Options keys: { baseUrl?: string, host?: string, port?: number }
+   */
   private static validateChromaDBConfig(config: VectorDBConfig): ValidationError[] {
     const errors: ValidationError[] = [];
     const opts = config.options as Record<string, unknown>;
 
-    if (!opts.host && !opts.path) {
+    if (!opts.baseUrl && !opts.host) {
       errors.push({
-        field: 'vectorDb.options.host',
-        message: 'ChromaDB host or path is required',
-        suggestion: 'Set CHROMADB_HOST or CHROMADB_PATH environment variable',
+        field: 'vectorDb.options.baseUrl',
+        message: 'ChromaDB connection is required: provide baseUrl (e.g., "http://localhost:8000") or host',
+        suggestion: 'Set CHROMADB_URL environment variable',
         severity: 'error',
       });
     }
@@ -251,15 +257,23 @@ export class ConfigValidator {
     return errors;
   }
 
+  /**
+   * Redis — accepts baseUrl OR url OR host+port.
+   * RedisProvider reads opts.baseUrl.
+   * Options keys: { baseUrl?: string, url?: string, host?: string, port?: number, apiKey?: string }
+   */
   private static validateRedisConfig(config: VectorDBConfig): ValidationError[] {
     const errors: ValidationError[] = [];
     const opts = config.options as Record<string, unknown>;
 
-    if (!opts.url && (!opts.host || !opts.port)) {
+    const hasUrl = Boolean(opts.baseUrl || opts.url);
+    const hasHostPort = Boolean(opts.host && opts.port);
+
+    if (!hasUrl && !hasHostPort) {
       errors.push({
-        field: 'vectorDb.options.url',
-        message: 'Redis connection URL or host:port is required',
-        suggestion: 'Set REDIS_URL or REDIS_HOST/REDIS_PORT environment variables',
+        field: 'vectorDb.options.baseUrl',
+        message: 'Redis connection is required: provide baseUrl/url or host + port',
+        suggestion: 'Set REDIS_URL environment variable',
         severity: 'error',
       });
     }
@@ -267,13 +281,18 @@ export class ConfigValidator {
     return errors;
   }
 
+  /**
+   * Weaviate — accepts baseUrl OR url.
+   * WeaviateProvider reads opts.baseUrl.
+   * Options keys: { baseUrl?: string, url?: string, apiKey?: string }
+   */
   private static validateWeaviateConfig(config: VectorDBConfig): ValidationError[] {
     const errors: ValidationError[] = [];
     const opts = config.options as Record<string, unknown>;
 
-    if (!opts.url) {
+    if (!opts.baseUrl && !opts.url) {
       errors.push({
-        field: 'vectorDb.options.url',
+        field: 'vectorDb.options.baseUrl',
         message: 'Weaviate instance URL is required',
         suggestion: 'Set WEAVIATE_URL environment variable',
         severity: 'error',
@@ -283,6 +302,10 @@ export class ConfigValidator {
     return errors;
   }
 
+  /**
+   * Universal REST / custom REST adapter.
+   * Options key: { baseUrl: string }
+   */
   private static validateRestConfig(config: VectorDBConfig): ValidationError[] {
     const errors: ValidationError[] = [];
     const opts = config.options as Record<string, unknown>;
@@ -320,7 +343,6 @@ export class ConfigValidator {
       });
     }
 
-    // Provider-specific validation
     switch (config.provider) {
       case 'openai':
         if (!config.apiKey) {
@@ -365,7 +387,6 @@ export class ConfigValidator {
         break;
     }
 
-    // Validate temperature
     if (config.temperature !== undefined) {
       if (config.temperature < 0 || config.temperature > 2) {
         errors.push({
@@ -376,7 +397,6 @@ export class ConfigValidator {
       }
     }
 
-    // Validate maxTokens
     if (config.maxTokens !== undefined && config.maxTokens <= 0) {
       errors.push({
         field: 'llm.maxTokens',
@@ -404,12 +424,11 @@ export class ConfigValidator {
       errors.push({
         field: 'embedding.model',
         message: 'Embedding model name is required',
-        suggestion: 'e.g., "text-embedding-3-small" for OpenAI',
+        suggestion: 'e.g., "text-embedding-3-small" for OpenAI, "nomic-embed-text" for Ollama',
         severity: 'error',
       });
     }
 
-    // Provider-specific validation
     if (config.provider === 'openai' && !config.apiKey) {
       errors.push({
         field: 'embedding.apiKey',
@@ -422,13 +441,12 @@ export class ConfigValidator {
     if (config.provider === 'ollama' && !config.baseUrl) {
       errors.push({
         field: 'embedding.baseUrl',
-        message: 'Ollama base URL is required',
+        message: 'Ollama base URL is required for embedding',
         suggestion: 'Set EMBEDDING_BASE_URL environment variable',
         severity: 'error',
       });
     }
 
-    // Validate dimensions
     if (config.dimensions !== undefined && config.dimensions <= 0) {
       errors.push({
         field: 'embedding.dimensions',
@@ -526,11 +544,10 @@ export class ConfigValidator {
   }
 
   private static isValidCSSColor(color: string): boolean {
-    // Basic regex for hex, rgb, rgba, hsl, hsla
     const hexRegex = /^#([0-9a-f]{3}){1,2}$/i;
     const rgbRegex = /^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+(?:\.\d+)?))?\)$/i;
     const hslRegex = /^hsla?\((\d+),\s*(\d+)%,\s*(\d+)%(?:,\s*(\d+(?:\.\d+)?))?\)$/i;
-    const namedColors = ['red', 'blue', 'green', 'black', 'white', 'transparent']; // basic set
+    const namedColors = ['red', 'blue', 'green', 'black', 'white', 'transparent'];
 
     return (
       hexRegex.test(color) ||

package/src/core/Pipeline.ts

@@ -4,8 +4,7 @@ import { DocumentChunker } from '../rag/DocumentChunker';
 import { RagConfig } from '../config/RagConfig';
 import { ProviderRegistry } from './ProviderRegistry';
 import { BatchProcessor, BatchOptions } from './BatchProcessor';
-
-// Moved to src/types/index.ts
+import { EmbeddingStrategyResolver } from '../config/EmbeddingStrategy';
 import { IngestDocument, ChatResponse } from '../types';
 
 /**
@@ -14,9 +13,9 @@ import { IngestDocument, ChatResponse } from '../types';
  * Features:
  * - Lazy initialization of providers
  * - Batch processing with retry logic
- * - Configurable embedding strategies
+ * - Smart embedding strategy (integrated / separate / external)
  * - Error recovery for transient failures
- * - Support for multi-tenancy via namespacing
+ * - Multi-tenancy support via namespacing
  */
 export class Pipeline {
   private vectorDB!: BaseVectorProvider;
@@ -37,26 +36,32 @@ export class Pipeline {
   async initialize(): Promise<void> {
     if (this.initialised) return;
 
+    // Resolve vector DB provider
     this.vectorDB = await ProviderRegistry.createVectorProvider(this.config.vectorDb);
-    this.llmProvider = ProviderRegistry.createLLMProvider(this.config.llm, this.config.embedding);
-
-    if (this.config.llm.provider === 'anthropic') {
-      // Anthropic doesn't support embeddings, so use separate provider
-      const { LLMFactory } = await import('../llm/LLMFactory');
-      this.embeddingProvider = LLMFactory.createEmbeddingProvider(this.config.embedding);
-    } else {
-      this.embeddingProvider = this.llmProvider;
-    }
+
+    // Resolve LLM + embedding providers using EmbeddingStrategyResolver.
+    // This handles all cases: integrated (same provider for chat+embed),
+    // separate (e.g. Anthropic + OpenAI embedding), and external.
+    const { llmProvider, embeddingProvider } = await EmbeddingStrategyResolver.resolve(
+      this.config.llm,
+      this.config.embedding
+    );
+
+    this.llmProvider = llmProvider;
+    this.embeddingProvider = embeddingProvider;
 
     await this.vectorDB.initialize();
     this.initialised = true;
   }
 
   /**
-   * Ingest documents with automatic chunking, embedding, and batch processing.
+   * Ingest documents with automatic chunking, embedding, and batch upsert.
    * Handles retries for transient failures.
    */
-  async ingest(documents: IngestDocument[], namespace?: string): Promise<Array<{ docId: string | number; chunksIngested: number }>> {
+  async ingest(
+    documents: IngestDocument[],
+    namespace?: string
+  ): Promise<Array<{ docId: string | number; chunksIngested: number }>> {
     await this.initialize();
     const ns = namespace ?? this.config.projectId;
     const results = [];
@@ -68,9 +73,9 @@ export class Pipeline {
           metadata: doc.metadata,
         });
 
-        // Batch embed chunks with retry logic
-        const batchOptions: BatchOptions = {
-          batchSize: 50, // Embedding batch size
+        // Batch embed with retry
+        const embedBatchOptions: BatchOptions = {
+          batchSize: 50,
           maxRetries: 3,
           initialDelayMs: 100,
         };
@@ -78,11 +83,11 @@ export class Pipeline {
         const vectors = await BatchProcessor.mapWithRetry(
           chunks.map(c => c.content),
           (text) => this.embeddingProvider.embed(text),
-          batchOptions
+          embedBatchOptions
         );
 
         if (vectors.length !== chunks.length) {
-          throw new Error(`Embedding failed: got ${vectors.length} vectors for ${chunks.length} chunks`);
+          throw new Error(`Embedding mismatch: got ${vectors.length} vectors for ${chunks.length} chunks`);
         }
 
         const upsertDocs = chunks.map((chunk, i) => ({
@@ -92,7 +97,7 @@ export class Pipeline {
           metadata: chunk.metadata,
         }));
 
-        // Batch upsert with retry logic
+        // Batch upsert with retry
         const upsertBatchOptions: BatchOptions = {
           batchSize: 100,
           maxRetries: 3,
@@ -115,10 +120,7 @@ export class Pipeline {
         });
       } catch (error) {
         console.error(`[Pipeline] Failed to ingest document ${doc.docId}:`, error);
-        results.push({
-          docId: doc.docId,
-          chunksIngested: 0,
-        });
+        results.push({ docId: doc.docId, chunksIngested: 0 });
       }
     }
 
@@ -134,7 +136,7 @@ export class Pipeline {
     try {
       const queryVector = await this.embeddingProvider.embed(question);
       const rawMatches = await this.vectorDB.query(queryVector, topK, ns);
-      
+
       const sources = rawMatches.filter((m) => m.score >= scoreThreshold);
       const context = sources.length
         ? sources.map((m, i) => `[Source ${i + 1}]\n${m.content}`).join('\n\n---\n\n')