@retrivora-ai/rag-engine 0.1.8 → 0.1.10

package/dist/server.mjs

@@ -1,15 +1,15 @@
 import {
   ChromaDBProvider
-} from "./chunk-XZPVJS2B.mjs";
+} from "./chunk-VKE5ZW7Y.mjs";
 import {
   RedisProvider
-} from "./chunk-7BQI4A5J.mjs";
+} from "./chunk-HOMXEE3M.mjs";
 import {
   WeaviateProvider
-} from "./chunk-TSX6DQXX.mjs";
+} from "./chunk-RUKZC3ON.mjs";
 import {
   UniversalVectorProvider
-} from "./chunk-Y6HQZDCJ.mjs";
+} from "./chunk-VV2ML6TM.mjs";
 import {
   AnthropicProvider,
   BatchProcessor,
@@ -34,29 +34,31 @@ import {
   createIngestHandler,
   createUploadHandler,
   getRagConfig
-} from "./chunk-YIYDJQJM.mjs";
-import "./chunk-UKDXCXW7.mjs";
+} from "./chunk-2VR5ZMXV.mjs";
+import "./chunk-EDLTMSNY.mjs";
 import {
   PineconeProvider
-} from "./chunk-MFWJZVF3.mjs";
+} from "./chunk-BMHJTWSU.mjs";
 import {
   PostgreSQLProvider
 } from "./chunk-IUTAZ7QR.mjs";
 import {
   MongoDBProvider
-} from "./chunk-QEYVWVT5.mjs";
+} from "./chunk-5HXNKSCR.mjs";
 import {
   MilvusProvider
-} from "./chunk-YST6KYBJ.mjs";
+} from "./chunk-VEJNRS4B.mjs";
 import {
   QdrantProvider
-} from "./chunk-26EMHLIN.mjs";
+} from "./chunk-W2PQR3UK.mjs";
 import {
   BaseVectorProvider
 } from "./chunk-VOIWNO5O.mjs";
 import {
+  __objRest,
+  __spreadProps,
   __spreadValues
-} from "./chunk-I4E63NIC.mjs";
+} from "./chunk-FWCSY2DS.mjs";
 
 // src/config/ConfigBuilder.ts
 var ConfigBuilder = class {
@@ -330,6 +332,116 @@ function createFromPreset(presetName) {
   const preset = PRESETS[presetName];
   return new ConfigBuilder().vectorDb(preset.vectorDb, { apiKey: process.env[`${preset.vectorDb.toUpperCase()}_API_KEY`] }).llm(preset.llm, void 0, process.env[`${preset.llm.toUpperCase()}_API_KEY`]).embedding(preset.embedding, void 0, process.env[`${preset.embedding.toUpperCase()}_API_KEY`]);
 }
+
+// src/providers/vectordb/MultiTablePostgresProvider.ts
+import { Pool } from "pg";
+var MultiTablePostgresProvider = class extends BaseVectorProvider {
+  constructor(config) {
+    var _a, _b, _c;
+    super(config);
+    const opts = config.options || {};
+    if (!opts.connectionString) {
+      throw new Error("[MultiTablePostgresProvider] options.connectionString is required");
+    }
+    this.connectionString = opts.connectionString;
+    this.dimensions = (_a = opts.dimensions) != null ? _a : 768;
+    const rawTables = (_c = (_b = opts.tables) != null ? _b : process.env.VECTOR_DB_TABLES) != null ? _c : "";
+    this.tables = typeof rawTables === "string" ? rawTables.split(",").map((t) => t.trim()).filter(Boolean) : rawTables;
+    if (this.tables.length === 0) {
+      console.warn(
+        "[MultiTablePostgresProvider] No tables configured. Set VECTOR_DB_TABLES as a comma-separated list of table names or pass options.tables."
+      );
+    }
+  }
+  async initialize() {
+    this.pool = new Pool({ connectionString: this.connectionString });
+    const client = await this.pool.connect();
+    client.release();
+    console.log(
+      `[MultiTablePostgresProvider] Connected. Searching across ${this.tables.length} table(s): ${this.tables.join(", ")}`
+    );
+  }
+  /**
+   * Upsert is not supported for MultiTablePostgresProvider as it's designed for 
+   * searching across pre-existing tables with varying schemas.
+   */
+  async upsert(_doc, _namespace) {
+    throw new Error(
+      "[MultiTablePostgresProvider] upsert() is not supported in multi-table mode. Please use the standard PostgreSQLProvider for single-table managed indices."
+    );
+  }
+  /**
+   * Batch upsert is not supported for MultiTablePostgresProvider.
+   */
+  async batchUpsert(_docs, _namespace) {
+    throw new Error(
+      "[MultiTablePostgresProvider] batchUpsert() is not supported in multi-table mode."
+    );
+  }
+  /**
+   * Query all configured tables and merge results, sorted by cosine similarity score.
+   */
+  async query(vector, topK, _namespace, _filter) {
+    var _b, _c;
+    if (!this.pool) {
+      throw new Error("[MultiTablePostgresProvider] Provider not initialized. Call initialize() first.");
+    }
+    console.log(`[MultiTablePostgresProvider] Querying ${this.tables.length} table(s) with vector dim=${vector.length}`);
+    const vectorLiteral = `[${vector.join(",")}]`;
+    const allResults = [];
+    for (const table of this.tables) {
+      try {
+        const result = await this.pool.query(
+          `SELECT *, 1 - (embedding <=> $1::vector) AS score
+           FROM "${table}"
+           ORDER BY embedding <=> $1::vector
+           LIMIT $2`,
+          [vectorLiteral, topK]
+        );
+        for (const row of result.rows) {
+          const _a = row, { score, id } = _a, rest = __objRest(_a, ["score", "id"]);
+          delete rest.embedding;
+          const content = Object.entries(rest).filter(([k, v]) => v !== null && typeof v !== "object" && k !== "id").map(([k, v]) => `${k}: ${v}`).join("\n");
+          allResults.push({
+            id: `${table}-${id}`,
+            score: parseFloat(String(score)),
+            content,
+            metadata: __spreadProps(__spreadValues({}, rest), { source_table: table })
+          });
+        }
+      } catch (err) {
+        console.error(
+          `[MultiTablePostgresProvider] Error querying table "${table}":`,
+          err.message
+        );
+      }
+    }
+    const sortedResults = allResults.sort((a, b) => b.score - a.score);
+    if (sortedResults.length > 0) {
+      console.log(`[MultiTablePostgresProvider] Top match from "${(_c = (_b = sortedResults[0].metadata) == null ? void 0 : _b.source_table) != null ? _c : "unknown"}" with score ${sortedResults[0].score.toFixed(4)}`);
+    }
+    return sortedResults.slice(0, Math.max(topK, 15));
+  }
+  async delete(_id, _namespace) {
+    console.warn("[MultiTablePostgresProvider] delete() is a no-op for multi-table mode.");
+  }
+  async deleteNamespace(_namespace) {
+    console.warn("[MultiTablePostgresProvider] deleteNamespace() is a no-op for multi-table mode.");
+  }
+  async ping() {
+    try {
+      await this.pool.query("SELECT 1");
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+    }
+  }
+};
 export {
   AnthropicProvider,
   BaseVectorProvider,
@@ -346,6 +458,7 @@ export {
   LLM_PROFILES,
   MilvusProvider,
   MongoDBProvider,
+  MultiTablePostgresProvider,
   OllamaProvider,
   OpenAIProvider,
   PRESETS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retrivora-ai/rag-engine",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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/constants.tsx

@@ -0,0 +1,220 @@
+import React from 'react';
+import {
+  Zap,
+  Database,
+  Layers,
+  Search,
+  Box,
+  Package,
+  Activity,
+  Hexagon,
+  Sparkles,
+  Bot,
+  Brain,
+  Rabbit,
+  Code,
+  Terminal,
+  FileText,
+  Puzzle,
+  MessageSquare,
+} from 'lucide-react';
+import { ArchitectureCardProps, Snippet, PipelineStep, ProviderPill } from './types';
+
+export const LANDING_PAGE_CONTENT = {
+  hero: {
+    badge: 'Dynamic & Universal Retrivora AI',
+    title: 'The Universal Bridge for Generative AI',
+    subtitle: 'Retrivora AI is a vendor-agnostic RAG engine that connects any Document to any LLM and Vector Database in minutes.',
+  },
+  lifecycle: {
+    title: 'The RAG Lifecycle',
+  },
+  guide: {
+    title: 'Interactive Guide',
+    subtitle: 'Universal RAG integration for your Next.js applications in minutes.',
+  }
+};
+
+export const VECTOR_DATABASES: ProviderPill[] = [
+  { Icon: Zap, label: 'Pinecone' },
+  { Icon: Database, label: 'PostgreSQL' },
+  { Icon: Layers, label: 'MongoDB' },
+  { Icon: Search, label: 'Milvus' },
+  { Icon: Box, label: 'Qdrant' },
+  { Icon: Package, label: 'ChromaDB' },
+  { Icon: Activity, label: 'Redis' },
+  { Icon: Hexagon, label: 'Weaviate' },
+];
+
+export const AI_MODELS: ProviderPill[] = [
+  { Icon: Sparkles, label: 'OpenAI' },
+  { Icon: Bot, label: 'Anthropic' },
+  { Icon: Brain, label: 'Gemini' },
+  { Icon: Rabbit, label: 'Ollama' },
+  { Icon: Code, label: 'Copilot' },
+  { Icon: Terminal, label: 'LiteLLM' },
+];
+
+export const PIPELINE_STEPS: PipelineStep[] = [
+  {
+    step: '01',
+    Icon: FileText,
+    title: 'Ingest',
+    desc: 'Universal support for PDF, DOCX, CSV, and JSON. Documents are parsed, chunked, and embedded.',
+    colors: { from: '#10b981', to: '#14b8a6' },
+  },
+  {
+    step: '02',
+    Icon: Search,
+    title: 'Retrieve',
+    desc: 'Queries are converted to vectors. Semantic search finds context across any configured Vector DB.',
+    colors: { from: '#14b8a6', to: '#06b6d4' },
+  },
+  {
+    step: '03',
+    Icon: Puzzle,
+    title: 'Augment',
+    desc: 'Retrieved context is injected into the LLM prompt with namespaced project isolation.',
+    colors: { from: '#06b6d4', to: '#3b82f6' },
+  },
+  {
+    step: '04',
+    Icon: MessageSquare,
+    title: 'Generate',
+    desc: 'Providers like OpenAI, Anthropic, or Gemini produce grounded, source-cited responses.',
+    colors: { from: '#3b82f6', to: '#6366f1' },
+  },
+];
+
+export const SNIPPETS: Snippet[] = [
+  {
+    id: 'pipeline',
+    title: 'Pipeline API',
+    language: 'typescript',
+    description: 'Orchestrate the full RAG flow programmatically with the Pipeline class.',
+    code: `import { Pipeline, getRagConfig } from '@retrivora-ai/rag-engine/server';
+
+const config = getRagConfig();
+const pipeline = new Pipeline(config);
+
+// Ingest documents
+await pipeline.ingest([{
+  docId: 'doc-1',
+  content: 'Retrivora AI simplifies RAG...',
+  metadata: { source: 'docs' }
+}]);
+
+// Ask a question
+const { reply, sources } = await pipeline.ask('How does Retrivora work?');`,
+  },
+  {
+    id: 'handlers',
+    title: 'Route Handlers',
+    language: 'typescript',
+    description: 'Deploy production-ready API endpoints in seconds using pre-built factories.',
+    code: `import { createChatHandler, createUploadHandler, getRagConfig } from '@retrivora-ai/rag-engine/server';
+
+const config = getRagConfig();
+
+// src/app/api/chat/route.ts
+export const POST = createChatHandler(config);
+
+// src/app/api/upload/route.ts
+export const POST = createUploadHandler(config);`,
+  },
+  {
+    id: 'ui',
+    title: 'React Components',
+    language: 'typescript',
+    description: 'Embed beautiful, themeable AI interfaces with headless logic or pre-built widgets.',
+    code: `import { ConfigProvider, ChatWidget } from '@retrivora-ai/rag-engine';
+
+export default function Layout({ children }) {
+  return (
+    <ConfigProvider config={{ projectId: 'demo' }}>
+      {children}
+      <ChatWidget position="bottom-right" />
+    </ConfigProvider>
+  );
+}`,
+  },
+  {
+    id: 'config',
+    title: 'Config Builder',
+    language: 'typescript',
+    description: 'Fluent, type-safe configuration builder for granular control over providers.',
+    code: `import { ConfigBuilder } from '@retrivora-ai/rag-engine/server';
+
+const config = new ConfigBuilder()
+  .vectorDb('pinecone', { apiKey: '...', indexName: 'docs' })
+  .llm('ollama', 'llama3.2')
+  .embedding('ollama', 'nomic-embed-text')
+  .build();`,
+  },
+  {
+    id: 'env',
+    title: 'Environment',
+    language: 'bash',
+    description: 'The exact environment variable structure required for auto-configuration.',
+    code: `# Project Identity
+RAG_PROJECT_ID=my-project
+
+# Vector DB
+VECTOR_DB_PROVIDER=pinecone
+PINECONE_API_KEY=pcsk_...
+VECTOR_DB_INDEX=products
+
+# AI Services
+LLM_PROVIDER=openai
+LLM_MODEL=gpt-4o
+OPENAI_API_KEY=sk-...`,
+  },
+];
+
+export const ARCHITECTURE_CARDS: ArchitectureCardProps[] = [
+  {
+    icon: <Database className="text-indigo-600" />,
+    title: 'Vector Store',
+    description: 'Universal support for Pinecone, PGVector, MongoDB, Milvus, Qdrant, and more.',
+    badge: 'Vector DB',
+    badgeColor: 'bg-indigo-50 dark:bg-indigo-500/10 text-indigo-600 dark:text-indigo-400 border-indigo-200 dark:border-indigo-500/20',
+  },
+  {
+    icon: <Zap className="text-amber-500" />,
+    title: 'Embeddings',
+    description: 'Seamlessly switch between OpenAI, Ollama, or custom embedding providers.',
+    badge: 'Models',
+    badgeColor: 'bg-amber-50 dark:bg-amber-500/10 text-amber-600 dark:text-amber-400 border-amber-200 dark:border-amber-500/20',
+  },
+  {
+    icon: <Bot className="text-emerald-500" />,
+    title: 'LLM Orchestration',
+    description: 'Optimized inference across OpenAI, Anthropic, Gemini, and local LLMs.',
+    badge: 'Inference',
+    badgeColor: 'bg-emerald-50 dark:bg-emerald-500/10 text-emerald-600 dark:text-emerald-400 border-emerald-200 dark:border-emerald-500/20',
+  },
+];
+
+export const QUICK_START_STEPS = [
+  'Install @retrivora-ai/rag-engine',
+  'Configure your .env.local',
+  'Mount the API handlers',
+  'Drop the ChatWidget'
+];
+
+export const API_ENDPOINTS = ['chat', 'health', 'ingest', 'upload'];
+
+export const CHAT_SUGGESTIONS = [
+  'What can you help me with?',
+  'Summarise the key topics',
+  'Show me an example'
+];
+
+export const BORDER_RADIUS_MAP: Record<string, string> = {
+  none: 'rounded-none',
+  sm: 'rounded-sm',
+  md: 'rounded-md',
+  lg: 'rounded-lg',
+  xl: 'rounded-xl',
+  full: 'rounded-3xl',
+};