@retrivora-ai/rag-engine 0.1.2 → 0.1.4

package/dist/server.mjs

@@ -1,145 +1,70 @@
 import {
-  AnthropicProvider,
-  DocumentChunker,
-  LLMFactory,
-  MongoDbAdapter,
-  OllamaProvider,
-  OpenAIProvider,
-  PgVectorAdapter,
-  PineconeAdapter,
-  RAGPipeline,
-  VectorDBFactory,
+  QdrantProvider
+} from "./chunk-6FODXNUF.mjs";
+import {
+  ChromaDBProvider
+} from "./chunk-HUGLYKD6.mjs";
+import {
+  RedisProvider
+} from "./chunk-VPNRDXIA.mjs";
+import {
+  WeaviateProvider
+} from "./chunk-V75V7BT2.mjs";
+import {
   createChatHandler,
   createHealthHandler,
   createIngestHandler,
   createUploadHandler
-} from "./chunk-W57OWMJK.mjs";
-import "./chunk-ZPXLQR5Q.mjs";
-
-// src/config/serverConfig.ts
-var VECTOR_DB_PROVIDERS = ["pinecone", "pgvector", "mongodb", "rest", "universal_rest", "custom"];
-var LLM_PROVIDERS = ["openai", "anthropic", "ollama", "rest", "universal_rest", "custom"];
-var EMBEDDING_PROVIDERS = ["openai", "ollama", "rest", "universal_rest", "custom"];
-function readString(env, name) {
-  var _a;
-  const value = (_a = env[name]) == null ? void 0 : _a.trim();
-  return value ? value : void 0;
-}
-function readNumber(env, name, fallback) {
-  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;
-}
-function readEnum(env, name, fallback, allowed) {
-  var _a;
-  const value = (_a = readString(env, name)) != null ? _a : fallback;
-  if (allowed.includes(value)) {
-    return value;
-  }
-  throw new Error(`[getRagConfig] ${name} must be one of: ${allowed.join(", ")}`);
-}
-function getRagConfig(env = process.env) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J;
-  const projectId = (_b = (_a = readString(env, "RAG_PROJECT_ID")) != null ? _a : readString(env, "NEXT_PUBLIC_PROJECT_ID")) != null ? _b : "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);
-  const embeddingDimensions = readNumber(env, "EMBEDDING_DIMENSIONS", 1536);
-  const vectorDbOptions = {};
-  if (vectorProvider === "pinecone") {
-    vectorDbOptions.apiKey = (_c = readString(env, "PINECONE_API_KEY")) != null ? _c : "";
-    vectorDbOptions.environment = (_d = readString(env, "PINECONE_ENVIRONMENT")) != null ? _d : "";
-  } else if (vectorProvider === "pgvector") {
-    vectorDbOptions.connectionString = (_e = readString(env, "PGVECTOR_CONNECTION_STRING")) != null ? _e : "";
-    vectorDbOptions.dimensions = embeddingDimensions;
-  } else if (vectorProvider === "rest") {
-    vectorDbOptions.baseUrl = (_f = readString(env, "VECTOR_DB_REST_URL")) != null ? _f : "";
-    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 = (_h = (_g = readString(env, "VECTOR_BASE_URL")) != null ? _g : readString(env, "VECTOR_DB_REST_URL")) != null ? _h : "";
-    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 = (_i = readString(env, "MONGODB_URI")) != null ? _i : "";
-    vectorDbOptions.database = (_j = readString(env, "MONGODB_DB")) != null ? _j : "";
-    vectorDbOptions.collection = (_k = readString(env, "MONGODB_COLLECTION")) != null ? _k : "";
-    vectorDbOptions.indexName = (_l = readString(env, "MONGODB_INDEX_NAME")) != null ? _l : "vector_index";
-  }
-  const llmApiKeyByProvider = {
-    openai: readString(env, "OPENAI_API_KEY"),
-    anthropic: readString(env, "ANTHROPIC_API_KEY"),
-    ollama: void 0,
-    universal_rest: readString(env, "LLM_API_KEY")
-  };
-  const embeddingApiKeyByProvider = {
-    openai: readString(env, "OPENAI_API_KEY"),
-    ollama: void 0,
-    custom: (_m = readString(env, "EMBEDDING_API_KEY")) != null ? _m : readString(env, "OPENAI_API_KEY")
-  };
-  return {
-    projectId,
-    vectorDb: {
-      provider: vectorProvider,
-      indexName: (_n = readString(env, "VECTOR_DB_INDEX")) != null ? _n : "rag-index",
-      options: vectorDbOptions
-    },
-    llm: {
-      provider: llmProvider,
-      model: (_o = readString(env, "LLM_MODEL")) != null ? _o : "gpt-4o",
-      apiKey: (_p = llmApiKeyByProvider[llmProvider]) != null ? _p : "",
-      baseUrl: readString(env, "LLM_BASE_URL"),
-      systemPrompt: readString(env, "LLM_SYSTEM_PROMPT"),
-      maxTokens: readNumber(env, "LLM_MAX_TOKENS", 1024),
-      temperature: readNumber(env, "LLM_TEMPERATURE", 0.7),
-      options: {
-        profile: readString(env, "LLM_UNIVERSAL_PROFILE")
-      }
-    },
-    embedding: {
-      provider: embeddingProvider,
-      model: (_q = readString(env, "EMBEDDING_MODEL")) != null ? _q : "text-embedding-3-small",
-      apiKey: embeddingApiKeyByProvider[embeddingProvider],
-      baseUrl: readString(env, "EMBEDDING_BASE_URL"),
-      dimensions: embeddingDimensions,
-      options: {
-        profile: readString(env, "EMBEDDING_UNIVERSAL_PROFILE")
-      }
-    },
-    ui: {
-      title: (_s = (_r = readString(env, "NEXT_PUBLIC_UI_TITLE")) != null ? _r : readString(env, "UI_TITLE")) != null ? _s : "AI Assistant",
-      subtitle: (_u = (_t = readString(env, "NEXT_PUBLIC_UI_SUBTITLE")) != null ? _t : readString(env, "UI_SUBTITLE")) != null ? _u : "Powered by RAG",
-      primaryColor: (_w = (_v = readString(env, "NEXT_PUBLIC_PRIMARY_COLOR")) != null ? _v : readString(env, "UI_PRIMARY_COLOR")) != null ? _w : "#10b981",
-      accentColor: (_y = (_x = readString(env, "NEXT_PUBLIC_ACCENT_COLOR")) != null ? _x : readString(env, "UI_ACCENT_COLOR")) != null ? _y : "#3b82f6",
-      logoUrl: (_z = readString(env, "NEXT_PUBLIC_LOGO_URL")) != null ? _z : readString(env, "UI_LOGO_URL"),
-      placeholder: (_B = (_A = readString(env, "NEXT_PUBLIC_PLACEHOLDER")) != null ? _A : readString(env, "UI_PLACEHOLDER")) != null ? _B : "Ask me anything\u2026",
-      showSources: ((_D = (_C = readString(env, "NEXT_PUBLIC_SHOW_SOURCES")) != null ? _C : readString(env, "UI_SHOW_SOURCES")) != null ? _D : "true") !== "false",
-      welcomeMessage: (_F = (_E = readString(env, "NEXT_PUBLIC_WELCOME_MESSAGE")) != null ? _E : readString(env, "UI_WELCOME_MESSAGE")) != null ? _F : "Hello! I'm your AI assistant. Ask me anything about your documents.",
-      visualStyle: (_H = (_G = readString(env, "NEXT_PUBLIC_UI_VISUAL_STYLE")) != null ? _G : readString(env, "UI_VISUAL_STYLE")) != null ? _H : "glass",
-      borderRadius: (_J = (_I = readString(env, "NEXT_PUBLIC_UI_BORDER_RADIUS")) != null ? _I : readString(env, "UI_BORDER_RADIUS")) != null ? _J : "xl"
-    },
-    rag: {
-      topK: readNumber(env, "RAG_TOP_K", 5),
-      scoreThreshold: readNumber(env, "RAG_SCORE_THRESHOLD", 0),
-      chunkSize: readNumber(env, "RAG_CHUNK_SIZE", 1e3),
-      chunkOverlap: readNumber(env, "RAG_CHUNK_OVERLAP", 200)
-    }
-  };
-}
+} from "./chunk-FGGSVVSY.mjs";
+import {
+  ConfigResolver,
+  DocumentChunker,
+  Pipeline,
+  ProviderRegistry,
+  VectorPlugin,
+  getRagConfig
+} from "./chunk-AIAB2IEE.mjs";
+import {
+  AnthropicProvider,
+  LLMFactory,
+  OllamaProvider,
+  OpenAIProvider
+} from "./chunk-GD3QJFNN.mjs";
+import {
+  PineconeProvider
+} from "./chunk-AALIF3AL.mjs";
+import {
+  PostgreSQLProvider
+} from "./chunk-S5DRHETN.mjs";
+import {
+  MongoDBProvider
+} from "./chunk-QEYVWVT5.mjs";
+import {
+  MilvusProvider
+} from "./chunk-7NXI6ZWX.mjs";
+import {
+  BaseVectorProvider
+} from "./chunk-VOIWNO5O.mjs";
+import "./chunk-I4E63NIC.mjs";
 export {
   AnthropicProvider,
+  BaseVectorProvider,
+  ChromaDBProvider,
+  ConfigResolver,
   DocumentChunker,
   LLMFactory,
-  MongoDbAdapter,
+  MilvusProvider,
+  MongoDBProvider,
   OllamaProvider,
   OpenAIProvider,
-  PgVectorAdapter,
-  PineconeAdapter,
-  RAGPipeline,
-  VectorDBFactory,
+  PineconeProvider,
+  Pipeline,
+  PostgreSQLProvider,
+  ProviderRegistry,
+  QdrantProvider,
+  RedisProvider,
+  VectorPlugin,
+  WeaviateProvider,
   createChatHandler,
   createHealthHandler,
   createIngestHandler,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retrivora-ai/rag-engine",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Retrivora AI is a plug-and-play AI engine for RAG chat experiences — generic vector DB + LLM provider, embeddable or standalone.",
   "author": "Abhinav Alkuchi",
   "license": "MIT",

package/src/app/page.tsx

@@ -478,7 +478,7 @@ export const POST = createChatHandler(getRagConfig());`}
                       <span className="mb-1">VECTOR_DB_PROVIDER=universal_rest</span>
                       <span className="mb-4">LLM_PROVIDER=openai</span>
                       <span className="text-slate-500 text-xs mb-2"># Client UI (Public)</span>
-                      <span>NEXT_PUBLIC_UI_TITLE="AI Assistant"</span>
+                      <span>NEXT_PUBLIC_UI_TITLE=&quot;AI Assistant&quot;</span>
                     </div>
                   </div>
                 </div>

package/src/components/MessageBubble.tsx

@@ -5,7 +5,7 @@ import { Bot, User, ChevronDown, ChevronRight } from 'lucide-react';
 import ReactMarkdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
 import { ChatMessage } from '@/llm/ILLMProvider';
-import { VectorMatch } from '@/vectordb/IVectorDB';
+import { VectorMatch } from '@/types';
 import { SourceCard } from './SourceCard';
 
 interface MessageBubbleProps {

package/src/components/SourceCard.tsx

@@ -2,7 +2,7 @@
 
 import React from 'react';
 import { ChevronDown, ChevronUp } from 'lucide-react';
-import { VectorMatch } from '@/vectordb/IVectorDB';
+import { VectorMatch } from '@/types';
 
 interface SourceCardProps {
   source: VectorMatch;

package/src/config/RagConfig.ts

@@ -8,7 +8,7 @@
 // Vector DB
 // ---------------------------------------------------------------------------
 
-export type VectorDBProvider = 'pinecone' | 'pgvector' | 'mongodb' | 'rest' | 'universal_rest' | 'custom';
+export type VectorDBProvider = 'pinecone' | 'pgvector' | 'postgresql' | 'mongodb' | 'milvus' | 'qdrant' | 'chromadb' | 'redis' | 'weaviate' | 'rest' | 'universal_rest' | 'custom';
 
 export interface VectorDBConfig {
   /** Which vector database to use */

package/src/config/serverConfig.ts

@@ -7,7 +7,7 @@
 
 import { RagConfig } from './RagConfig';
 
-const VECTOR_DB_PROVIDERS = ['pinecone', 'pgvector', 'mongodb', '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;
 
@@ -43,7 +43,7 @@ function readEnum<T extends readonly string[]>(
 }
 
 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);

package/src/core/ConfigResolver.ts

@@ -0,0 +1,69 @@
+import { RagConfig } from '../config/RagConfig';
+import { mergeDefined } from '../utils/templateUtils';
+import { getRagConfig as getEnvConfig } from '../config/serverConfig';
+
+/**
+ * ConfigResolver — validates and normalizes host configuration.
+ * It merges host-provided config with environment defaults.
+ */
+export class ConfigResolver {
+  /**
+   * Resolves the final configuration by merging host-provided config with defaults.
+   * @param hostConfig - Partial configuration passed from the host application.
+   */
+  static resolve(hostConfig?: Partial<RagConfig>): RagConfig {
+    const envConfig = getEnvConfig();
+
+    if (!hostConfig) {
+      return envConfig;
+    }
+
+    // Deep merge or specific merging logic
+    return {
+      ...envConfig,
+      ...hostConfig,
+      projectId: hostConfig.projectId || envConfig.projectId,
+      vectorDb: hostConfig.vectorDb ? {
+        ...envConfig.vectorDb,
+        ...hostConfig.vectorDb,
+        options: {
+          ...envConfig.vectorDb.options,
+          ...(hostConfig.vectorDb.options || {})
+        }
+      } : envConfig.vectorDb,
+      llm: hostConfig.llm ? {
+        ...envConfig.llm,
+        ...hostConfig.llm,
+        options: {
+          ...(envConfig.llm.options || {}),
+          ...(hostConfig.llm.options || {})
+        }
+      } : envConfig.llm,
+      embedding: hostConfig.embedding ? {
+        ...envConfig.embedding,
+        ...hostConfig.embedding,
+        options: {
+          ...(envConfig.embedding.options || {}),
+          ...(hostConfig.embedding.options || {})
+        }
+      } : envConfig.embedding,
+      ui: hostConfig.ui ? mergeDefined(envConfig.ui, hostConfig.ui) : envConfig.ui,
+      rag: hostConfig.rag ? { ...envConfig.rag, ...hostConfig.rag } : envConfig.rag,
+    };
+  }
+
+  /**
+   * Validates the configuration for required fields.
+   */
+  static validate(config: RagConfig): void {
+    if (!config.projectId) {
+      throw new Error('[ConfigResolver] projectId is required');
+    }
+    if (!config.vectorDb.provider) {
+      throw new Error('[ConfigResolver] vectorDb.provider is required');
+    }
+    if (!config.llm.provider) {
+      throw new Error('[ConfigResolver] llm.provider is required');
+    }
+  }
+}

package/src/core/Pipeline.ts

@@ -0,0 +1,109 @@
+import { BaseVectorProvider } from '../providers/vectordb/BaseVectorProvider';
+import { ILLMProvider, ChatMessage } from '../llm/ILLMProvider';
+import { DocumentChunker } from '../rag/DocumentChunker';
+import { RagConfig } from '../config/RagConfig';
+import { VectorMatch } from '../types';
+import { ProviderRegistry } from './ProviderRegistry';
+
+export interface IngestDocument {
+  docId: string;
+  content: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ChatResponse {
+  reply: string;
+  sources: VectorMatch[];
+}
+
+/**
+ * Pipeline — orchestrates the RAG flow: Embed → Search → Augment → Generate.
+ */
+export class Pipeline {
+  private vectorDB!: BaseVectorProvider;
+  private llmProvider!: ILLMProvider;
+  private embeddingProvider!: ILLMProvider;
+  private chunker: DocumentChunker;
+  private config: RagConfig;
+  private initialised = false;
+
+  constructor(config: RagConfig) {
+    this.config = config;
+    this.chunker = new DocumentChunker(
+      config.rag?.chunkSize ?? 1000,
+      config.rag?.chunkOverlap ?? 200
+    );
+  }
+
+  async initialize(): Promise<void> {
+    if (this.initialised) return;
+
+    this.vectorDB = await ProviderRegistry.createVectorProvider(this.config.vectorDb);
+    this.llmProvider = ProviderRegistry.createLLMProvider(this.config.llm, this.config.embedding);
+
+    if (this.config.llm.provider === 'anthropic') {
+      // Logic for Anthropic as seen in RAGPipeline
+      const { LLMFactory } = await import('../llm/LLMFactory');
+      this.embeddingProvider = LLMFactory.createEmbeddingProvider(this.config.embedding);
+    } else {
+      this.embeddingProvider = this.llmProvider;
+    }
+
+    await this.vectorDB.initialize();
+    this.initialised = true;
+  }
+
+  async ingest(documents: IngestDocument[], namespace?: string): Promise<Array<{ docId: string; chunksIngested: number }>> {
+    await this.initialize();
+    const ns = namespace ?? this.config.projectId;
+    const results = [];
+
+    for (const doc of documents) {
+      const chunks = this.chunker.chunk(doc.content, {
+        docId: doc.docId,
+        metadata: doc.metadata,
+      });
+
+      const vectors = await this.embeddingProvider.batchEmbed(chunks.map(c => c.content));
+      const upsertDocs = chunks.map((chunk, i) => ({
+        id: chunk.id,
+        vector: vectors[i],
+        content: chunk.content,
+        metadata: chunk.metadata,
+      }));
+
+      await this.vectorDB.batchUpsert(upsertDocs, ns);
+      results.push({ docId: doc.docId, chunksIngested: chunks.length });
+    }
+    return results;
+  }
+
+  async ask(question: string, history: ChatMessage[] = [], namespace?: string): Promise<ChatResponse> {
+    await this.initialize();
+    const ns = namespace ?? this.config.projectId;
+    const topK = this.config.rag?.topK ?? 5;
+    const scoreThreshold = this.config.rag?.scoreThreshold ?? 0.0;
+
+    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')
+      : 'No relevant context found.';
+
+    const messages: ChatMessage[] = [...history, { role: 'user', content: question }];
+    const reply = await this.llmProvider.chat(messages, context);
+
+    return { reply, sources };
+  }
+
+  async health(): Promise<Record<string, boolean>> {
+    await this.initialize();
+    const [vectorDB, llm] = await Promise.all([
+      this.vectorDB.ping().catch(() => false),
+      this.llmProvider.ping().catch(() => false),
+    ]);
+    return { vectorDB, llm };
+  }
+}

package/src/core/ProviderRegistry.ts

@@ -0,0 +1,71 @@
+import { BaseVectorProvider } from '../providers/vectordb/BaseVectorProvider';
+import { VectorDBConfig, LLMConfig, EmbeddingConfig } from '../config/RagConfig';
+import { LLMFactory } from '../llm/LLMFactory';
+import { ILLMProvider } from '../llm/ILLMProvider';
+
+// We will import these as we create them
+// import { PineconeProvider } from '../providers/vectordb/PineconeProvider';
+
+/**
+ * ProviderRegistry — dynamic provider loader for Vector DBs and LLMs.
+ */
+export class ProviderRegistry {
+  private static vectorProviders: Record<string, new (config: VectorDBConfig) => BaseVectorProvider> = {};
+
+  /**
+   * Register a custom vector provider.
+   */
+  static registerVectorProvider(name: string, providerClass: new (config: VectorDBConfig) => BaseVectorProvider) {
+    this.vectorProviders[name] = providerClass;
+  }
+
+  /**
+   * Creates a vector database provider based on the configuration.
+   */
+  static async createVectorProvider(config: VectorDBConfig): Promise<BaseVectorProvider> {
+    const { provider } = config;
+
+    // Check if we have a registered provider (dynamic loading)
+    if (this.vectorProviders[provider]) {
+      return new this.vectorProviders[provider](config);
+    }
+
+    // Fallback to internal switch for built-in providers
+    switch (provider) {
+      case 'pinecone':
+        const { PineconeProvider } = await import('../providers/vectordb/PineconeProvider');
+        return new PineconeProvider(config);
+      case 'pgvector':
+      case 'postgresql':
+        const { PostgreSQLProvider } = await import('../providers/vectordb/PostgreSQLProvider');
+        return new PostgreSQLProvider(config);
+      case 'mongodb':
+        const { MongoDBProvider } = await import('../providers/vectordb/MongoDBProvider');
+        return new MongoDBProvider(config);
+      case 'milvus':
+        const { MilvusProvider } = await import('../providers/vectordb/MilvusProvider');
+        return new MilvusProvider(config);
+      case 'qdrant':
+        const { QdrantProvider } = await import('../providers/vectordb/QdrantProvider');
+        return new QdrantProvider(config);
+      case 'chromadb':
+        const { ChromaDBProvider } = await import('../providers/vectordb/ChromaDBProvider');
+        return new ChromaDBProvider(config);
+      case 'redis':
+        const { RedisProvider } = await import('../providers/vectordb/RedisProvider');
+        return new RedisProvider(config);
+      case 'weaviate':
+        const { WeaviateProvider } = await import('../providers/vectordb/WeaviateProvider');
+        return new WeaviateProvider(config);
+      default:
+        throw new Error(`[ProviderRegistry] Unsupported vector provider: ${provider}`);
+    }
+  }
+
+  /**
+   * Creates an LLM provider based on the configuration.
+   */
+  static createLLMProvider(llmConfig: LLMConfig, embeddingConfig?: EmbeddingConfig): ILLMProvider {
+    return LLMFactory.create(llmConfig, embeddingConfig);
+  }
+}

package/src/core/VectorPlugin.ts

@@ -0,0 +1,51 @@
+import { RagConfig } from '../config/RagConfig';
+import { ConfigResolver } from './ConfigResolver';
+import { Pipeline, IngestDocument, ChatResponse } from './Pipeline';
+import { ChatMessage } from '../llm/ILLMProvider';
+
+/**
+ * VectorPlugin — main orchestrator class.
+ * This is the primary interface for host applications.
+ */
+export class VectorPlugin {
+  private config: RagConfig;
+  private pipeline: Pipeline;
+
+  /**
+   * Initializes the plugin with the host configuration.
+   * @param hostConfig - Configuration object passed from the host application.
+   */
+  constructor(hostConfig?: Partial<RagConfig>) {
+    this.config = ConfigResolver.resolve(hostConfig);
+    ConfigResolver.validate(this.config);
+    this.pipeline = new Pipeline(this.config);
+  }
+
+  /**
+   * Get the current resolved configuration.
+   */
+  getConfig(): RagConfig {
+    return this.config;
+  }
+
+  /**
+   * Run a chat query.
+   */
+  async chat(message: string, history: ChatMessage[] = [], namespace?: string): Promise<ChatResponse> {
+    return this.pipeline.ask(message, history, namespace);
+  }
+
+  /**
+   * Ingest documents into the vector database.
+   */
+  async ingest(documents: IngestDocument[], namespace?: string): Promise<Array<{ docId: string; chunksIngested: number }>> {
+    return this.pipeline.ingest(documents, namespace);
+  }
+
+  /**
+   * Check the health of the connected providers.
+   */
+  async health(): Promise<Record<string, boolean>> {
+    return this.pipeline.health();
+  }
+}