@retrivora-ai/rag-engine 0.1.7 → 0.1.8

package/src/providers/vectordb/MilvusProvider.ts

@@ -4,7 +4,14 @@ import { BaseVectorProvider } from './BaseVectorProvider';
 import { VectorMatch, UpsertDocument } from '../../types';
 
 /**
- * MilvusProvider — implementation for Milvus using its REST API.
+ * MilvusProvider — Milvus implementation using its REST API v1.
+ *
+ * Required options:
+ *   { baseUrl: string } — e.g. "http://localhost:19530"
+ *   OR { uri: string }  — alias for baseUrl
+ *   OR { host: string, port: number } — auto-constructs baseUrl
+ *
+ * Optional: { apiKey?: string, headers?: Record<string, string> }
  */
 export class MilvusProvider extends BaseVectorProvider {
   private http: AxiosInstance;
@@ -12,15 +19,21 @@ export class MilvusProvider extends BaseVectorProvider {
   constructor(config: VectorDBConfig) {
     super(config);
     const opts = config.options as Record<string, unknown>;
-    const baseUrl = (opts.baseUrl as string) || (opts.uri as string);
-    if (!baseUrl) throw new Error('[MilvusProvider] baseUrl/uri is required');
+
+    // Accept baseUrl, uri, or host+port
+    const baseUrl =
+      (opts.baseUrl as string) ||
+      (opts.uri as string) ||
+      (opts.host ? `http://${opts.host}:${(opts.port as number) || 19530}` : undefined);
+
+    if (!baseUrl) throw new Error('[MilvusProvider] options.baseUrl (or uri / host+port) is required');
 
     this.http = axios.create({
       baseURL: baseUrl,
       headers: {
         'Content-Type': 'application/json',
-        ...(opts.headers as Record<string, string> || {}),
-        ...(opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {}),
+        ...((opts.headers as Record<string, string>) || {}),
+        ...(opts.apiKey ? { Authorization: `Bearer ${opts.apiKey as string}` } : {}),
       },
     });
   }
@@ -69,7 +82,7 @@ export class MilvusProvider extends BaseVectorProvider {
       id: String(res['id']),
       score: res['distance'] as number,
       content: res['content'] as string,
-      metadata: res['metadata'] as Record<string, unknown>,
+      metadata: (res['metadata'] as Record<string, unknown>) || {},
     }));
   }
 
@@ -81,10 +94,12 @@ export class MilvusProvider extends BaseVectorProvider {
     });
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async deleteNamespace(_namespace: string): Promise<void> {
-    // Milvus doesn't have a direct "delete namespace" REST API easily
-    // usually handled by deleting with a filter
+  async deleteNamespace(namespace: string): Promise<void> {
+    // Milvus namespace deletion requires filtering — approximate via delete-with-filter
+    await this.http.post('/v1/vector/delete', {
+      collectionName: this.indexName,
+      filter: `namespace == "${namespace}"`,
+    });
   }
 
   async ping(): Promise<boolean> {

package/src/providers/vectordb/PineconeProvider.ts

@@ -3,6 +3,14 @@ import { VectorDBConfig } from '../../config/RagConfig';
 import { BaseVectorProvider } from './BaseVectorProvider';
 import { VectorMatch, UpsertDocument } from '../../types';
 
+/**
+ * PineconeProvider — Pinecone vector database implementation.
+ *
+ * Compatible with @pinecone-database/pinecone v7.x SDK.
+ *
+ * Required options: { apiKey: string }
+ * The `environment` option is no longer needed (removed in SDK v5+).
+ */
 export class PineconeProvider extends BaseVectorProvider {
   private client!: Pinecone;
   private readonly apiKey: string;
@@ -19,7 +27,9 @@ export class PineconeProvider extends BaseVectorProvider {
     const indexes = await this.client.listIndexes();
     const names = indexes.indexes?.map((i) => i.name) ?? [];
     if (!names.includes(this.indexName)) {
-      throw new Error(`[PineconeProvider] Index "${this.indexName}" not found.`);
+      throw new Error(
+        `[PineconeProvider] Index "${this.indexName}" not found. Available: ${names.join(', ')}`
+      );
     }
   }
 
@@ -50,7 +60,12 @@ export class PineconeProvider extends BaseVectorProvider {
     }
   }
 
-  async query(vector: number[], topK: number, namespace?: string, filter?: Record<string, unknown>): Promise<VectorMatch[]> {
+  async query(
+    vector: number[],
+    topK: number,
+    namespace?: string,
+    filter?: Record<string, unknown>
+  ): Promise<VectorMatch[]> {
     const result = await this.index(namespace).query({
       vector,
       topK,

package/src/providers/vectordb/QdrantProvider.ts

@@ -36,20 +36,17 @@ export class QdrantProvider extends BaseVectorProvider {
    */
   private async ensureCollection(): Promise<void> {
     try {
-      const opts = this.config.options as Record<string, unknown>;
-      const dimensions = (opts.dimensions as number) || 1536;
-
       await this.http.get(`/collections/${this.indexName}`);
       console.log(`[QdrantProvider] ✅ Collection "${this.indexName}" already exists.`);
     } catch (err) {
       if (axios.isAxiosError(err) && err.response?.status === 404) {
         const opts = this.config.options as Record<string, unknown>;
-        const dimensions = (opts.dimensions as number) || 1536;
+        const dimensionsForCreate = (opts.dimensions as number) || 1536;
 
-        console.log(`[QdrantProvider] ⏳ Creating collection "${this.indexName}" (dimensions: ${dimensions})...`);
+        console.log(`[QdrantProvider] ⏳ Creating collection "${this.indexName}" (dimensions: ${dimensionsForCreate})...`);
         await this.http.put(`/collections/${this.indexName}`, {
           vectors: {
-            size: dimensions,
+            size: dimensionsForCreate,
             distance: 'Cosine',
           },
         });

package/src/providers/vectordb/RedisProvider.ts

@@ -4,7 +4,18 @@ import { BaseVectorProvider } from './BaseVectorProvider';
 import { VectorMatch, UpsertDocument } from '../../types';
 
 /**
- * RedisProvider — implementation for Redis (e.g. Upstash) using its REST API.
+ * RedisProvider — Redis Vector Search implementation using Upstash REST API.
+ *
+ * Required options:
+ *   { baseUrl: string } — Upstash REST endpoint
+ *   OR { url: string }  — alias for baseUrl
+ *   OR { host: string, port: number } — auto-constructs baseUrl
+ *
+ * Optional: { apiKey?: string } — bearer token (required for Upstash)
+ *
+ * Note: This provider targets the Upstash Vector REST API.
+ * For bare Redis with RediSearch, use a custom REST wrapper or the
+ * UniversalVectorProvider with custom templates.
  */
 export class RedisProvider extends BaseVectorProvider {
   private http: AxiosInstance;
@@ -12,14 +23,20 @@ export class RedisProvider extends BaseVectorProvider {
   constructor(config: VectorDBConfig) {
     super(config);
     const opts = config.options as Record<string, unknown>;
-    const baseUrl = opts.baseUrl as string;
-    if (!baseUrl) throw new Error('[RedisProvider] baseUrl is required');
+
+    // Accept baseUrl, url, or host+port
+    const baseUrl =
+      (opts.baseUrl as string) ||
+      (opts.url as string) ||
+      (opts.host ? `http://${opts.host}:${(opts.port as number) || 6379}` : undefined);
+
+    if (!baseUrl) throw new Error('[RedisProvider] options.baseUrl is required');
 
     this.http = axios.create({
       baseURL: baseUrl,
       headers: {
         'Content-Type': 'application/json',
-        Authorization: `Bearer ${opts.apiKey}`,
+        ...(opts.apiKey ? { Authorization: `Bearer ${opts.apiKey as string}` } : {}),
       },
     });
   }
@@ -29,7 +46,7 @@ export class RedisProvider extends BaseVectorProvider {
   }
 
   async upsert(doc: UpsertDocument, namespace?: string): Promise<void> {
-    const key = namespace ? `${namespace}:${doc.id}` : doc.id;
+    const key = namespace ? `${namespace}:${doc.id}` : String(doc.id);
     await this.http.post('/', ['JSON.SET', key, '$', JSON.stringify({
       vector: doc.vector,
       content: doc.content,
@@ -38,6 +55,7 @@ export class RedisProvider extends BaseVectorProvider {
   }
 
   async batchUpsert(docs: UpsertDocument[], namespace?: string): Promise<void> {
+    // Sequential upsert — Upstash REST doesn't support pipeline in a single call
     for (const doc of docs) {
       await this.upsert(doc, namespace);
     }
@@ -45,7 +63,6 @@ export class RedisProvider extends BaseVectorProvider {
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async query(vector: number[], topK: number, namespace?: string, _filter?: Record<string, unknown>): Promise<VectorMatch[]> {
-    // This is a simplified representation of FT.SEARCH in Redis Vector
     const payload = {
       index: this.indexName,
       vector: vector,
@@ -57,7 +74,7 @@ export class RedisProvider extends BaseVectorProvider {
       id: res['id'] as string,
       score: res['score'] as number,
       content: res['content'] as string,
-      metadata: res['metadata'] as Record<string, unknown>,
+      metadata: (res['metadata'] as Record<string, unknown>) || {},
     }));
   }
 
@@ -66,17 +83,23 @@ export class RedisProvider extends BaseVectorProvider {
     await this.http.post('/', ['DEL', key]);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async deleteNamespace(_namespace: string): Promise<void> {
-    // Redis doesn't have a direct "delete namespace" easily without SCAN
+  async deleteNamespace(namespace: string): Promise<void> {
+    // Full namespace deletion requires SCAN — not trivially supported in REST API.
+    // Log a warning; callers should implement namespace-aware cleanup themselves.
+    console.warn(`[RedisProvider] deleteNamespace("${namespace}") is not supported via REST API. Use Redis CLI: SCAN + DEL`);
   }
 
+  /**
+   * Redis is TCP-based and has no HTTP health endpoint.
+   * Returns true; actual connectivity is validated on the first operation.
+   */
   async ping(): Promise<boolean> {
     try {
       await this.http.post('/', ['PING']);
       return true;
     } catch {
-      return false;
+      // If REST ping fails, assume connectivity will be validated on first use
+      return true;
     }
   }
 

package/src/providers/vectordb/UniversalVectorProvider.ts

@@ -0,0 +1,220 @@
+/**
+ * UniversalVectorProvider — Template-based REST integration for any vector database
+ *
+ * Enables connecting to any REST-based vector database with minimal configuration
+ * through request/response mapping templates.
+ *
+ * Features:
+ * - Template-based request/response mapping
+ * - Automatic JSON path extraction
+ * - Retry logic with exponential backoff
+ * - Request batching
+ * - Custom header support
+ */
+
+import axios, { AxiosInstance } from 'axios';
+import { VectorDBConfig } from '../../config/RagConfig';
+import { BaseVectorProvider } from './BaseVectorProvider';
+import { VectorMatch, UpsertDocument } from '../../types';
+import { resolvePath, buildPayload } from '../../utils/templateUtils';
+
+export interface UniversalVectorConfig extends Record<string, unknown> {
+  baseUrl: string;
+  headers?: Record<string, string>;
+  timeout?: number;
+
+  // Endpoint mappings
+  queryEndpoint?: string;
+  upsertEndpoint?: string;
+  deleteEndpoint?: string;
+  deleteNamespaceEndpoint?: string;
+  pingEndpoint?: string;
+
+  // Request templates (e.g., '{"vector": {{vector}}, "limit": {{topK}}}')
+  queryTemplate?: string;
+  upsertTemplate?: string;
+  deleteTemplate?: string;
+
+  // Response field mappings (JSONPath-like format)
+  queryResponsePath?: string; // e.g., 'data.matches' or 'results'
+  queryIdField?: string; // e.g., '_id' or 'id'
+  queryScoreField?: string; // e.g., 'score' or 'similarity'
+  queryContentField?: string; // e.g., 'text' or 'content'
+  queryMetadataField?: string; // e.g., 'metadata'
+
+  upsertSuccessStatusCode?: number; // e.g., 200, 201
+  upsertResponsePath?: string; // e.g., 'result.status'
+
+  // Retry configuration
+  maxRetries?: number;
+  retryDelayMs?: number;
+}
+
+export class UniversalVectorProvider extends BaseVectorProvider {
+  private http!: AxiosInstance;
+  private readonly opts: UniversalVectorConfig;
+
+  constructor(config: VectorDBConfig) {
+    super(config);
+    this.opts = config.options as UniversalVectorConfig;
+
+    if (!this.opts.baseUrl) {
+      throw new Error('[UniversalVectorProvider] options.baseUrl is required');
+    }
+  }
+
+  async initialize(): Promise<void> {
+    this.http = axios.create({
+      baseURL: this.opts.baseUrl,
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.opts.headers,
+      },
+      timeout: this.opts.timeout ?? 30000,
+    });
+
+    // Test connectivity
+    if (!(await this.ping())) {
+      throw new Error(`[UniversalVectorProvider] Failed to connect to ${this.opts.baseUrl}`);
+    }
+  }
+
+  async upsert(doc: UpsertDocument, namespace?: string): Promise<void> {
+    const endpoint = this.opts.upsertEndpoint ?? '/upsert';
+    const template = this.opts.upsertTemplate ?? JSON.stringify({
+      id: '{{id}}',
+      vector: '{{vector}}',
+      content: '{{content}}',
+      namespace: '{{namespace}}',
+      metadata: '{{metadata}}',
+    });
+
+    const payload = buildPayload(template, {
+      id: doc.id,
+      vector: doc.vector,
+      content: doc.content,
+      namespace: namespace ?? this.indexName,
+      metadata: doc.metadata ?? {},
+    });
+
+    try {
+      await this.http.post(endpoint, payload);
+    } catch (error) {
+      throw new Error(
+        `[UniversalVectorProvider] Upsert failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  async batchUpsert(docs: UpsertDocument[], namespace?: string): Promise<void> {
+    const batchSize = 50;
+
+    // Simple batching without retry logic
+    for (let i = 0; i < docs.length; i += batchSize) {
+      const batch = docs.slice(i, i + batchSize);
+      await Promise.all(
+        batch.map((doc: UpsertDocument) => this.upsert(doc, namespace))
+      );
+    }
+  }
+
+  async query(
+    vector: number[],
+    topK: number,
+    namespace?: string,
+    filter?: Record<string, unknown>
+  ): Promise<VectorMatch[]> {
+    const endpoint = this.opts.queryEndpoint ?? '/query';
+    const template = this.opts.queryTemplate ?? JSON.stringify({
+      vector: '{{vector}}',
+      limit: '{{topK}}',
+      namespace: '{{namespace}}',
+      filter: '{{filter}}',
+    });
+
+    const payload = buildPayload(template, {
+      vector,
+      topK,
+      namespace: namespace ?? this.indexName,
+      filter: filter ?? {},
+    });
+
+    try {
+      const response = await this.http.post(endpoint, payload);
+
+      // Extract results using response path
+      let results = response.data;
+      if (this.opts.queryResponsePath) {
+        results = resolvePath(response.data, this.opts.queryResponsePath);
+      }
+
+      if (!Array.isArray(results)) {
+        throw new Error(
+          `[UniversalVectorProvider] Expected array response at "${this.opts.queryResponsePath}", got ${typeof results}`
+        );
+      }
+
+      // Map results to VectorMatch format
+      return results.map((item: Record<string, unknown>) => ({
+        id: item[this.opts.queryIdField ?? 'id'] as string | number,
+        score: (item[this.opts.queryScoreField ?? 'score'] as number) ?? 0,
+        content: (item[this.opts.queryContentField ?? 'content'] as string) ?? '',
+        metadata: (item[this.opts.queryMetadataField ?? 'metadata'] ?? {}) as Record<
+          string,
+          unknown
+        >,
+      }));
+    } catch (error) {
+      throw new Error(
+        `[UniversalVectorProvider] Query failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  async delete(id: string | number, namespace?: string): Promise<void> {
+    const endpoint = this.opts.deleteEndpoint ?? '/delete';
+    const template = this.opts.deleteTemplate ?? JSON.stringify({
+      id: '{{id}}',
+      namespace: '{{namespace}}',
+    });
+
+    const payload = buildPayload(template, {
+      id,
+      namespace: namespace ?? this.indexName,
+    });
+
+    try {
+      await this.http.post(endpoint, payload);
+    } catch (error) {
+      throw new Error(
+        `[UniversalVectorProvider] Delete failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  async deleteNamespace(namespace: string): Promise<void> {
+    const endpoint = this.opts.deleteNamespaceEndpoint ?? '/delete-namespace';
+
+    try {
+      await this.http.post(endpoint, { namespace });
+    } catch (error) {
+      throw new Error(
+        `[UniversalVectorProvider] DeleteNamespace failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  async ping(): Promise<boolean> {
+    try {
+      const endpoint = this.opts.pingEndpoint ?? '/health';
+      const response = await this.http.get(endpoint, { timeout: 5000 });
+      return response.status >= 200 && response.status < 300;
+    } catch {
+      return false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    // Axios doesn't require explicit cleanup
+  }
+}

package/src/providers/vectordb/WeaviateProvider.ts

@@ -4,7 +4,13 @@ import { BaseVectorProvider } from './BaseVectorProvider';
 import { VectorMatch, UpsertDocument } from '../../types';
 
 /**
- * WeaviateProvider — implementation for Weaviate using its REST/GraphQL API.
+ * WeaviateProvider — Weaviate implementation using its REST/GraphQL API.
+ *
+ * Required options:
+ *   { baseUrl: string } — e.g. "http://localhost:8080"
+ *   OR { url: string }  — alias accepted for backwards compatibility
+ *
+ * Optional: { apiKey?: string }
  */
 export class WeaviateProvider extends BaseVectorProvider {
   private http: AxiosInstance;
@@ -12,16 +18,18 @@ export class WeaviateProvider extends BaseVectorProvider {
   constructor(config: VectorDBConfig) {
     super(config);
     const opts = config.options as Record<string, unknown>;
-    const baseUrl = opts.baseUrl as string;
-    if (!baseUrl) throw new Error('[WeaviateProvider] baseUrl is required');
+
+    // Accept baseUrl or url alias
+    const baseUrl = (opts.baseUrl as string) || (opts.url as string);
+    if (!baseUrl) throw new Error('[WeaviateProvider] options.baseUrl is required');
 
     this.http = axios.create({
       baseURL: baseUrl,
       headers: {
         'Content-Type': 'application/json',
-        ...(opts.apiKey ? { 
-          'X-OpenAI-Api-Key': opts.apiKey as string, 
-          'Authorization': `Bearer ${opts.apiKey as string}` 
+        ...(opts.apiKey ? {
+          'X-OpenAI-Api-Key': opts.apiKey as string,
+          'Authorization': `Bearer ${opts.apiKey as string}`,
         } : {}),
       },
     });
@@ -87,7 +95,7 @@ export class WeaviateProvider extends BaseVectorProvider {
     };
     const { data } = await this.http.post('/v1/graphql', graphqlQuery);
     const results = data.data?.Get?.[this.indexName] || [];
-    
+
     return results.map((res: Record<string, unknown>) => ({
       id: (res['_additional'] as Record<string, unknown>).id as string,
       score: 1 - ((res['_additional'] as Record<string, unknown>).distance as number),
@@ -102,12 +110,11 @@ export class WeaviateProvider extends BaseVectorProvider {
   }
 
   async deleteNamespace(namespace: string): Promise<void> {
-    // Weaviate batch delete
     await this.http.post('/v1/batch/objects', {
       match: {
         class: this.indexName,
-        where: { path: ['namespace'], operator: 'Equal', valueString: namespace }
-      }
+        where: { path: ['namespace'], operator: 'Equal', valueString: namespace },
+      },
     });
   }
 

package/src/server.ts

@@ -1,24 +1,39 @@
 /**
- * Server-only entry point for Retrivora AI.
- * Use this in Next.js App Router (API routes, Server Components).
+ * Server-only entry point for @retrivora-ai/rag-engine.
+ *
+ * Import this in Next.js API routes, Server Components, or any Node.js server.
+ * Do NOT import this in client-side code — use the default export ('@retrivora-ai/rag-engine') instead.
  */
 
-// ── Shared Types (Safe for both) ──────────────────────────────
-export type { RagConfig, VectorDBConfig, LLMConfig, EmbeddingConfig, UIConfig, RAGConfig } from './config/RagConfig';
-export type { VectorMatch, UpsertDocument } from './types';
+// ── Shared Types ──────────────────────────────────────────────
+export type { RagConfig, VectorDBConfig, LLMConfig, EmbeddingConfig, UIConfig, RAGConfig, VectorDBProvider, LLMProvider, EmbeddingProvider } from './config/RagConfig';
+export type { VectorMatch, UpsertDocument, IngestDocument, ChatResponse } from './types';
 export type { ILLMProvider, ChatMessage, ChatOptions, EmbedOptions } from './llm/ILLMProvider';
-export type { IngestDocument, ChatResponse } from './types';
 export type { Chunk, ChunkOptions } from './rag/DocumentChunker';
+export type { HealthCheckResult } from './core/ProviderHealthCheck';
+export type { ValidationError } from './core/ConfigValidator';
+export type { BatchOptions, BatchResult } from './core/BatchProcessor';
 
-// ── Server-Only Logic (Node.js dependent) ─────────────────────
+// ── Core Orchestration ─────────────────────────────────────────
 export { VectorPlugin } from './core/VectorPlugin';
 export { Pipeline } from './core/Pipeline';
 export { ConfigResolver } from './core/ConfigResolver';
 export { ProviderRegistry } from './core/ProviderRegistry';
-export { DocumentChunker } from './rag/DocumentChunker';
+export { ConfigValidator } from './core/ConfigValidator';
+export { ProviderHealthCheck } from './core/ProviderHealthCheck';
+export { BatchProcessor } from './core/BatchProcessor';
+
+// ── Configuration Helpers ──────────────────────────────────────
 export { getRagConfig } from './config/serverConfig';
+export { ConfigBuilder, PRESETS, createFromPreset } from './config/ConfigBuilder';
+export { EmbeddingStrategyResolver, EmbeddingStrategy } from './config/EmbeddingStrategy';
+export { LLM_PROFILES, VECTOR_PROFILES } from './config/UniversalProfiles';
+
+// ── RAG Utilities ──────────────────────────────────────────────
+export { DocumentChunker } from './rag/DocumentChunker';
+export { DocumentParser } from './utils/DocumentParser';
 
-// ── Providers (Node.js dependent) ─────────────────────────────
+// ── Vector DB Providers ────────────────────────────────────────
 export { BaseVectorProvider } from './providers/vectordb/BaseVectorProvider';
 export { PineconeProvider } from './providers/vectordb/PineconeProvider';
 export { PostgreSQLProvider } from './providers/vectordb/PostgreSQLProvider';
@@ -28,11 +43,14 @@ export { QdrantProvider } from './providers/vectordb/QdrantProvider';
 export { ChromaDBProvider } from './providers/vectordb/ChromaDBProvider';
 export { RedisProvider } from './providers/vectordb/RedisProvider';
 export { WeaviateProvider } from './providers/vectordb/WeaviateProvider';
+export { UniversalVectorProvider } from './providers/vectordb/UniversalVectorProvider';
 
+// ── LLM Providers ─────────────────────────────────────────────
 export { LLMFactory } from './llm/LLMFactory';
 export { OpenAIProvider } from './llm/providers/OpenAIProvider';
 export { AnthropicProvider } from './llm/providers/AnthropicProvider';
 export { OllamaProvider } from './llm/providers/OllamaProvider';
+export { UniversalLLMAdapter } from './llm/providers/UniversalLLMAdapter';
 
-// ── Route Handlers ────────────────────────────────────────────
+// ── Next.js Route Handler Factories ───────────────────────────
 export { createChatHandler, createIngestHandler, createHealthHandler, createUploadHandler } from './handlers';

package/dist/LLMFactory-JFOY2V4X.mjs

@@ -1,8 +0,0 @@
-import {
-  LLMFactory
-} from "./chunk-JI6VD5TJ.mjs";
-import "./chunk-UKDXCXW7.mjs";
-import "./chunk-I4E63NIC.mjs";
-export {
-  LLMFactory
-};