@retrivora-ai/rag-engine 1.9.8 → 2.0.0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@retrivora-ai/rag-engine",
-  "version": "1.9.8",
+  "version": "2.0.0",
   "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",
+  "license": "UNLICENSED",
   "keywords": [
     "rag",
     "retrieval-augmented-generation",
@@ -126,6 +126,7 @@
     "dotenv": "^17.4.2",
     "eslint": "^9",
     "eslint-config-next": "16.2.4",
+    "next": "16.2.10",
     "tailwindcss": "^4",
     "tsup": "^8.5.1",
     "typescript": "^5"

package/src/app/page.tsx

@@ -6,6 +6,7 @@ import { Navbar } from '@/components/Navbar';
 import { Hero } from '@/components/Hero';
 import { Lifecycle } from '@/components/Lifecycle';
 import { ArchitectureCardsSection } from '@/components/ArchitectureCardsSection';
+import { RagPatternsSection } from '@/components/RagPatternsSection';
 import { Documentation } from '@/components/Documentation';
 import { ChatWidget } from '@/components/ChatWidget';
 
@@ -17,6 +18,7 @@ export default function HomePage() {
       <div className="relative z-10 container mx-auto px-6 py-12">
         <Hero />
         <Lifecycle />
+        <RagPatternsSection />
         <ArchitectureCardsSection />
         <Documentation />
       </div>

package/src/components/ChatWindow.tsx

@@ -217,11 +217,22 @@ export function ChatWindow({
     const timer = setTimeout(async () => {
       setIsSuggesting(true);
       try {
-        const response = await fetch('/api/suggestions', {
+        const base = retrivoraApiBase || '/api/retrivora';
+        const primaryUrl = `${base}/suggestions`;
+        let response = await fetch(primaryUrl, {
           method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
+          headers: { 'Content-Type': 'application/json', ...(headers || {}) },
           body: JSON.stringify({ query: input, namespace: projectId }),
         });
+
+        if (!response.ok && response.status === 404) {
+          response = await fetch('/api/suggestions', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...(headers || {}) },
+            body: JSON.stringify({ query: input, namespace: projectId }),
+          });
+        }
+
         const data = await response.json();
         if (data.suggestions) {
           setSuggestions(data.suggestions);
@@ -234,7 +245,7 @@ export function ChatWindow({
     }, 800); // 800ms debounce to save costs/latency
 
     return () => clearTimeout(timer);
-  }, [input, projectId]);
+  }, [input, projectId, retrivoraApiBase, headers]);
 
   return (
     <div

package/src/components/constants.tsx

@@ -277,3 +277,227 @@ export const BORDER_RADIUS_MAP: Record<string, string> = {
   xl: 'rounded-xl',
   full: 'rounded-3xl',
 };
+
+export interface RagPatternStep {
+  label: string;
+  type: 'input' | 'process' | 'database' | 'model' | 'output';
+  color: string;
+}
+
+export interface RagPattern {
+  id: string;
+  name: string;
+  tagline: string;
+  description: string;
+  pros: string[];
+  cons: string[];
+  snippet: string;
+  color: string;
+  flowSteps: RagPatternStep[];
+}
+
+export const RAG_PATTERNS: RagPattern[] = [
+  {
+    id: 'naive',
+    name: 'Naive RAG',
+    tagline: 'Standard semantic search pipeline',
+    description: 'The foundation pattern: splits documents into text chunks, embeddings are stored in a vector database, and relevant context is fetched via direct query similarity to augment the model prompt.',
+    pros: ['Very low latency', 'Low resource cost', 'Simple implementation'],
+    cons: ['Struggles with complex multi-hop queries', 'No ranking optimization', 'Can return irrelevant context chunks'],
+    color: '#d97706', // Amber/Brown
+    snippet: `import { Retrivora } from '@retrivora-ai/rag-engine/server';
+
+const ai = new Retrivora({
+  projectId: 'naive-rag-demo',
+  vectorDatabase: {
+    provider: 'pinecone',
+    indexName: 'knowledge-base',
+  },
+  workflow: {
+    type: 'simple-rag'
+  }
+});`,
+    flowSteps: [
+      { label: 'Documents', type: 'input', color: 'bg-amber-100 text-amber-800 dark:bg-amber-950/40 dark:text-amber-300' },
+      { label: 'Chunking', type: 'process', color: 'bg-amber-50 text-amber-700 dark:bg-amber-900/20 dark:text-amber-400' },
+      { label: 'Embedding Model', type: 'model', color: 'bg-amber-100 text-amber-900 dark:bg-amber-800/30 dark:text-amber-200' },
+      { label: 'Vector Store', type: 'database', color: 'bg-amber-200 text-amber-950 dark:bg-amber-700/40 dark:text-amber-100' },
+      { label: 'Context Prompt', type: 'process', color: 'bg-amber-50 text-amber-700 dark:bg-amber-900/20 dark:text-amber-400' },
+      { label: 'LLM Generator', type: 'model', color: 'bg-indigo-100 text-indigo-900 dark:bg-indigo-800/30 dark:text-indigo-200' },
+    ]
+  },
+  {
+    id: 'retrieve-and-rerank',
+    name: 'Retrieve-and-rerank',
+    tagline: 'High-precision contextual relevance',
+    description: 'Enhances standard RAG by fetching a larger pool of vector candidates and feeding them through a cross-encoder Reranker model. The reranker scores context chunks dynamically relative to query intent, filtering noise.',
+    pros: ['Extremely high context precision', 'Better generation accuracy', 'Mitigates hallucination rates'],
+    cons: ['Adds slight latency bottleneck (~100-300ms)', 'Higher computational requirements'],
+    color: '#2563eb', // Blue
+    snippet: `import { Retrivora } from '@retrivora-ai/rag-engine/server';
+
+const ai = new Retrivora({
+  projectId: 'rerank-rag-demo',
+  vectorDatabase: {
+    provider: 'pinecone',
+    indexName: 'knowledge-base',
+  },
+  retrieval: {
+    strategy: 'contextual-compression',
+    useReranking: true, // Enables cross-encoder re-evaluation
+    topK: 5,
+  }
+});`,
+    flowSteps: [
+      { label: 'Query Input', type: 'input', color: 'bg-blue-100 text-blue-800 dark:bg-blue-950/40 dark:text-blue-300' },
+      { label: 'Vector Retrieval', type: 'database', color: 'bg-blue-200 text-blue-950 dark:bg-blue-700/40 dark:text-blue-100' },
+      { label: 'Reranker Model', type: 'model', color: 'bg-indigo-100 text-indigo-950 dark:bg-indigo-700/40 dark:text-indigo-100' },
+      { label: 'Filtered Context', type: 'process', color: 'bg-blue-50 text-blue-700 dark:bg-blue-900/20 dark:text-blue-400' },
+      { label: 'Generative Model', type: 'model', color: 'bg-violet-100 text-violet-900 dark:bg-violet-800/30 dark:text-violet-200' },
+    ]
+  },
+  {
+    id: 'multimodal',
+    name: 'Multimodal RAG',
+    tagline: 'Search and reason across text and media',
+    description: 'Ingests both unstructured text documents and visual/audio/structured assets. It queries multi-modal embeddings, feeding retrieved visuals and matched context fragments to multimodal LLMs (like Gemini or Claude) to support diagrams, tables, and media outputs.',
+    pros: ['Handles images, PDFs, charts, audio', 'Deeper context retrieval', 'Generates visual answers'],
+    cons: ['Multimodal embeddings are computationally expensive', 'Higher token payload sizes'],
+    color: '#7c3aed', // Purple
+    snippet: `import { Retrivora } from '@retrivora-ai/rag-engine/server';
+
+const ai = new Retrivora({
+  projectId: 'multimodal-rag-demo',
+  llm: {
+    provider: 'gemini',
+    model: 'gemini-2.5-flash', // Multimodal reasoning model
+  },
+  embedding: {
+    provider: 'gemini',
+    model: 'text-embedding-004',
+  },
+  workflow: {
+    type: 'multimodal-rag'
+  }
+});`,
+    flowSteps: [
+      { label: 'Multi-modal Docs', type: 'input', color: 'bg-purple-100 text-purple-800 dark:bg-purple-950/40 dark:text-purple-300' },
+      { label: 'Multi-modal Embed', type: 'model', color: 'bg-purple-50 text-purple-700 dark:bg-purple-900/20 dark:text-purple-400' },
+      { label: 'Vector Store', type: 'database', color: 'bg-purple-200 text-purple-950 dark:bg-purple-700/40 dark:text-purple-100' },
+      { label: 'Media Context', type: 'process', color: 'bg-purple-100 text-purple-950 dark:bg-purple-800/40 dark:text-purple-100' },
+      { label: 'Multimodal LLM', type: 'model', color: 'bg-violet-100 text-violet-900 dark:bg-violet-800/30 dark:text-violet-200' },
+    ]
+  },
+  {
+    id: 'graph',
+    name: 'Graph RAG',
+    tagline: 'Entity-relationship semantic reasoning',
+    description: 'Builds a knowledge graph structure from raw documents using an LLM extractor. Entity-to-entity and entity-to-document relationships are resolved, allowing queries to retrieve structured semantic contexts (nodes & relationships) to resolve structural, relational, and hierarchy-based questions.',
+    pros: ['Excellent for tracing connections', 'Resolves hierarchy and relationships', 'Grounded fact validation'],
+    cons: ['Heavy write-time pipeline ingestion cost', 'Requires graph database setup'],
+    color: '#059669', // Emerald
+    snippet: `import { Retrivora } from '@retrivora-ai/rag-engine/server';
+
+const ai = new Retrivora({
+  projectId: 'graph-rag-demo',
+  graphDb: {
+    provider: 'neo4j',
+    options: { uri: 'neo4j://localhost:7687' },
+  },
+  workflow: {
+    type: 'graph-rag'
+  }
+});`,
+    flowSteps: [
+      { label: 'Documents', type: 'input', color: 'bg-emerald-100 text-emerald-800 dark:bg-emerald-950/40 dark:text-emerald-300' },
+      { label: 'LLM Extractor', type: 'model', color: 'bg-emerald-50 text-emerald-700 dark:bg-emerald-900/20 dark:text-emerald-400' },
+      { label: 'Graph Database', type: 'database', color: 'bg-emerald-200 text-emerald-950 dark:bg-emerald-700/40 dark:text-emerald-100' },
+      { label: 'Relation Search', type: 'process', color: 'bg-emerald-100 text-emerald-950 dark:bg-emerald-800/40 dark:text-emerald-100' },
+      { label: 'LLM Reasoner', type: 'model', color: 'bg-indigo-100 text-indigo-900 dark:bg-indigo-800/30 dark:text-indigo-200' },
+    ]
+  },
+  {
+    id: 'hybrid',
+    name: 'Hybrid RAG',
+    tagline: 'Best of both worlds: Vector + Graph',
+    description: 'Queries both a vector database for semantic match proximity and a graph database for topological linkages. It joins vector search results and sub-graph entity contexts into a unified prompt, resolving complex interconnected schemas.',
+    pros: ['Unparalleled query coverage', 'Combines semantic proximity and graph relationships', 'Robust grounding'],
+    cons: ['Most complex RAG configuration', 'Double database query overhead'],
+    color: '#d97706', // Orange
+    snippet: `import { Retrivora } from '@retrivora-ai/rag-engine/server';
+
+const ai = new Retrivora({
+  projectId: 'hybrid-rag-demo',
+  vectorDatabase: { provider: 'mongodb', indexName: 'default' },
+  graphDb: { provider: 'neo4j', options: { uri: 'neo4j://...' } },
+  workflow: {
+    type: 'hybrid-rag'
+  }
+});`,
+    flowSteps: [
+      { label: 'Query', type: 'input', color: 'bg-amber-100 text-amber-800 dark:bg-amber-950/40 dark:text-amber-300' },
+      { label: 'Vector Store', type: 'database', color: 'bg-orange-100 text-orange-950 dark:bg-orange-700/40 dark:text-orange-100' },
+      { label: 'Graph Database', type: 'database', color: 'bg-emerald-100 text-emerald-950 dark:bg-emerald-700/40 dark:text-emerald-100' },
+      { label: 'Unified Context', type: 'process', color: 'bg-amber-50 text-amber-700 dark:bg-amber-900/20 dark:text-amber-400' },
+      { label: 'LLM Reasoner', type: 'model', color: 'bg-indigo-100 text-indigo-900 dark:bg-indigo-800/30 dark:text-indigo-200' },
+    ]
+  },
+  {
+    id: 'agentic-router',
+    name: 'Agentic RAG (Router)',
+    tagline: 'Dynamic intent-based query routing',
+    description: 'Uses an intelligent fast router agent to analyze the intent of the incoming query. The router dynamically decides whether to fetch data from the Vector DB, query a Graph DB, fallback to web search, or trigger external API tools.',
+    pros: ['Highly adaptive workflow', 'Saves tokens on simple queries', 'Automatically invokes external API tools'],
+    cons: ['Adds slight routing classification latency', 'Dependent on router accuracy'],
+    color: '#0891b2', // Cyan
+    snippet: `import { Retrivora } from '@retrivora-ai/rag-engine/server';
+
+const ai = new Retrivora({
+  projectId: 'agentic-router-demo',
+  workflow: {
+    type: 'agentic-router'
+  }
+});`,
+    flowSteps: [
+      { label: 'User Query', type: 'input', color: 'bg-cyan-100 text-cyan-800 dark:bg-cyan-950/40 dark:text-cyan-300' },
+      { label: 'Router Agent', type: 'model', color: 'bg-indigo-100 text-indigo-900 dark:bg-indigo-800/30 dark:text-indigo-200' },
+      { label: 'Vector / Graph / Tools', type: 'database', color: 'bg-cyan-200 text-cyan-950 dark:bg-cyan-700/40 dark:text-cyan-100' },
+      { label: 'Selected Context', type: 'process', color: 'bg-cyan-50 text-cyan-700 dark:bg-cyan-900/20 dark:text-cyan-400' },
+      { label: 'LLM Generator', type: 'model', color: 'bg-violet-100 text-violet-900 dark:bg-violet-800/30 dark:text-violet-200' },
+    ]
+  },
+  {
+    id: 'multi-agent',
+    name: 'Agent RAG (Multi-Agent)',
+    tagline: 'Collaborative swarm-based problem solving',
+    description: 'Deploys a supervisor agent that coordinates a group of specialized worker agents (e.g., search agent, tool executor agent, web crawler agent). Agents collaborate, pass information, check each other\'s facts, and compile a final answer.',
+    pros: ['Excellent for complex research tasks', 'Self-correcting query pipelines', 'Multi-step action sequences'],
+    cons: ['High latency (requires multiple LLM cycles)', 'Higher cost per query', 'Complex state synchronization'],
+    color: '#ec4899', // Pink
+    snippet: `import { Retrivora } from '@retrivora-ai/rag-engine/server';
+
+const ai = new Retrivora({
+  projectId: 'multi-agent-demo',
+  workflow: {
+    type: 'multi-agent'
+  },
+  mcpServers: [
+    {
+      name: 'search-engine',
+      transport: 'stdio',
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-web-search']
+    }
+  ]
+});`,
+    flowSteps: [
+      { label: 'Goal Query', type: 'input', color: 'bg-pink-100 text-pink-800 dark:bg-pink-950/40 dark:text-pink-300' },
+      { label: 'Supervisor Agent', type: 'model', color: 'bg-pink-200 text-pink-950 dark:bg-pink-800/30 dark:text-pink-100' },
+      { label: 'Specialist Agents', type: 'model', color: 'bg-indigo-100 text-indigo-900 dark:bg-indigo-900/30 dark:text-indigo-200' },
+      { label: 'Tools / Vector DBs', type: 'database', color: 'bg-pink-200 text-pink-950 dark:bg-pink-700/40 dark:text-pink-100' },
+      { label: 'Consensus Context', type: 'process', color: 'bg-pink-50 text-pink-700 dark:bg-pink-900/20 dark:text-pink-400' },
+      { label: 'Final Output', type: 'output', color: 'bg-indigo-600 text-white shadow-sm' },
+    ]
+  }
+];
+

package/src/config/RagConfig.ts

@@ -182,7 +182,7 @@ export interface RAGConfig {
   /** Characters used to split text, in order of priority */
   separators?: string[];
   /** Overall RAG architecture pattern */
-  architecture?: 'simple' | 'graph' | 'hybrid' | 'agentic';
+  architecture?: 'simple' | 'graph' | 'hybrid' | 'agentic' | 'naive' | 'retrieve-and-rerank' | 'multimodal' | 'agentic-router' | 'multi-agent';
   /** Chunking strategy to use during ingestion */
   chunkingStrategy?: 'recursive' | 'markdown' | 'semantic' | 'llamaindex';
   /** Whether to use query transformation (e.g. HyDE) */
@@ -249,7 +249,7 @@ export interface RetrievalConfig {
 
 export interface WorkflowConfig {
   /** High-level workflow selector from the SDK prompt. */
-  type?: 'simple-rag' | 'rag' | 'hybrid-rag' | 'graph-rag' | 'agentic-rag' | 'agentic';
+  type?: 'simple-rag' | 'rag' | 'hybrid-rag' | 'graph-rag' | 'agentic-rag' | 'agentic' | 'naive-rag' | 'retrieve-and-rerank' | 'multimodal-rag' | 'agentic-router' | 'multi-agent-rag' | 'multi-agent';
   /** Future workflow/provider-specific options. */
   options?: Record<string, unknown>;
 }

package/src/config/serverConfig.ts

@@ -64,6 +64,19 @@ export function getEnvConfig(env: Record<string, string | undefined> = process.e
     base?.projectId ??
     '__default__';
 
+  const licenseKey =
+    readString(env, 'RAG_LICENSE_KEY') ??
+    readString(env, 'RETRIVORA_LICENSE_KEY') ??
+    readString(env, 'NEXT_PUBLIC_RETRIVORA_LICENSE_KEY') ??
+    readString(env, 'LICENSE_KEY') ??
+    base?.licenseKey;
+
+  const telemetryEnabled =
+    readString(env, 'TELEMETRY_ENABLED') === 'true' ||
+    readString(env, 'NEXT_PUBLIC_TELEMETRY_ENABLED') === 'true' ||
+    base?.telemetry?.enabled ||
+    Boolean(licenseKey);
+
   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);
@@ -219,7 +232,7 @@ export function getEnvConfig(env: Record<string, string | undefined> = process.e
       })(),
     },
     telemetry: {
-      enabled: readString(env, 'TELEMETRY_ENABLED') === 'true' || readString(env, 'NEXT_PUBLIC_TELEMETRY_ENABLED') === 'true' || base?.telemetry?.enabled || false,
+      enabled: telemetryEnabled,
       url: readString(env, 'TELEMETRY_URL') ?? readString(env, 'NEXT_PUBLIC_TELEMETRY_URL') ?? base?.telemetry?.url ?? '/api/telemetry',
     },
     // Optional graph DB — driven by GRAPH_DB_PROVIDER env var

package/src/core/ConfigResolver.ts

@@ -117,22 +117,48 @@ export class ConfigResolver {
       normalized.useReranking = retrieval.useReranking ?? normalized.useReranking;
 
       if (retrieval.strategy === 'hybrid') normalized.architecture = normalized.architecture ?? 'hybrid';
-      if (retrieval.strategy === 'agentic') normalized.architecture = 'agentic';
-      if (retrieval.strategy === 'contextual-compression') normalized.useReranking = true;
+      if (retrieval.strategy === 'agentic') normalized.architecture = 'multi-agent';
+      if (retrieval.strategy === 'contextual-compression') {
+        normalized.useReranking = true;
+        normalized.architecture = normalized.architecture ?? 'retrieve-and-rerank';
+      }
     }
 
     if (workflow?.type) {
       const type = workflow.type;
-      if (type === 'agentic' || type === 'agentic-rag') normalized.architecture = 'agentic';
-      else if (type === 'hybrid-rag') normalized.architecture = 'hybrid';
-      else if (type === 'graph-rag') {
+      if (type === 'naive-rag') {
+        normalized.architecture = 'naive';
+        normalized.useReranking = false;
+        normalized.useGraphRetrieval = false;
+      } else if (type === 'retrieve-and-rerank') {
+        normalized.architecture = 'retrieve-and-rerank';
+        normalized.useReranking = true;
+      } else if (type === 'multimodal-rag') {
+        normalized.architecture = 'multimodal';
+      } else if (type === 'graph-rag') {
         normalized.architecture = 'graph';
         normalized.useGraphRetrieval = true;
+      } else if (type === 'hybrid-rag') {
+        normalized.architecture = 'hybrid';
+      } else if (type === 'agentic-router') {
+        normalized.architecture = 'agentic-router';
+      } else if (type === 'multi-agent-rag' || type === 'multi-agent' || type === 'agentic' || type === 'agentic-rag') {
+        normalized.architecture = 'multi-agent';
       } else if (type === 'simple-rag' || type === 'rag') {
-        normalized.architecture = normalized.architecture ?? 'simple';
+        normalized.architecture = normalized.architecture ?? 'naive';
       }
     }
 
+    // Default fallbacks based on architecture configuration
+    if (normalized.architecture === 'retrieve-and-rerank') {
+      normalized.useReranking = true;
+    } else if (normalized.architecture === 'graph') {
+      normalized.useGraphRetrieval = true;
+    } else if (normalized.architecture === 'naive') {
+      normalized.useReranking = false;
+      normalized.useGraphRetrieval = false;
+    }
+
     return normalized;
   }
 }

package/src/core/LicenseVerifier.ts

@@ -12,6 +12,13 @@ export interface LicensePayload {
  * Enables zero-latency local license validation without external network calls.
  */
 export class LicenseVerifier {
+  // A simple in-memory cache to save CPU overhead of cryptographic signature checks.
+  private static readonly cache = new Map<
+    string,
+    { payload: LicensePayload; cachedAt: number }
+  >();
+  private static readonly CACHE_TTL_MS = 60 * 1000; // Cache verified license for 60 seconds
+
   // Retrivora's Public Key used to verify the license key signature.
   // In production, this matches the private key held by Retrivora SaaS.
   private static readonly PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
@@ -38,6 +45,22 @@ MwIDAQAB
     publicKeyOverride?: string
   ): LicensePayload {
     const isProduction = process.env.NODE_ENV === 'production';
+    const now = Date.now();
+
+    // Check verification cache to bypass crypto computations on hot paths
+    if (licenseKey) {
+      const cacheKey = `${licenseKey}:${currentProjectId}:${provider || ''}:${publicKeyOverride || ''}`;
+      const cached = this.cache.get(cacheKey);
+      if (cached && now - cached.cachedAt < this.CACHE_TTL_MS) {
+        // Enforce expiration check even for cached items
+        const currentTimestampSec = Math.floor(now / 1000);
+        if (cached.payload.expiresAt && currentTimestampSec > cached.payload.expiresAt) {
+          this.cache.delete(cacheKey);
+        } else {
+          return cached.payload;
+        }
+      }
+    }
 
     // 1. Development Fallback (Fail-open locally but log warning)
     if (!licenseKey) {
@@ -143,6 +166,11 @@ MwIDAQAB
         // Enterprise has access to all databases (including redis, weaviate, custom ones)
       }
 
+      if (licenseKey) {
+        const cacheKey = `${licenseKey}:${currentProjectId}:${provider || ''}:${publicKeyOverride || ''}`;
+        this.cache.set(cacheKey, { payload, cachedAt: now });
+      }
+
       return payload;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -151,4 +179,82 @@ MwIDAQAB
       );
     }
   }
+
+  static async verifyIP(licenseKey: string | undefined): Promise<void> {
+    if (!licenseKey) return;
+    try {
+      const parts = licenseKey.split('.');
+      if (parts.length !== 3) return;
+      const [, payloadB64] = parts;
+      const payload: LicensePayload & { ipv4?: string; ipv6?: string } = JSON.parse(
+        Buffer.from(payloadB64, 'base64url').toString('utf8')
+      );
+
+      const tier = (payload.tier || '').toLowerCase();
+      // Skip check if Enterprise or Custom
+      if (tier === 'enterprise' || tier === 'custom') {
+        return;
+      }
+
+      // If Hobby (free_trial) or Developer Pro, perform the check
+      if (payload.ipv4 || payload.ipv6) {
+        let currentIpv4 = '';
+        let currentIpv6 = '';
+        
+        try {
+          const res = await fetch('https://api4.ipify.org?format=json', { signal: AbortSignal.timeout(3000) });
+          const data = await res.json();
+          currentIpv4 = data.ip;
+        } catch (e) {}
+        
+        try {
+          const res = await fetch('https://api6.ipify.org?format=json', { signal: AbortSignal.timeout(3000) });
+          const data = await res.json();
+          currentIpv6 = data.ip;
+        } catch (e) {}
+
+        const localIps: string[] = [];
+        try {
+          const osModule = require('os');
+          const interfaces = osModule.networkInterfaces();
+          for (const name of Object.keys(interfaces)) {
+            for (const iface of interfaces[name] || []) {
+              if (!iface.internal) {
+                localIps.push(iface.address);
+              }
+            }
+          }
+        } catch (e) {}
+        
+        const isIpv4Match = payload.ipv4 && (
+          currentIpv4 === payload.ipv4 || 
+          localIps.includes(payload.ipv4)
+        );
+        const isIpv6Match = payload.ipv6 && (
+          currentIpv6 === payload.ipv6 || 
+          localIps.includes(payload.ipv6)
+        );
+
+        if (payload.ipv4 && payload.ipv6) {
+          if (!isIpv4Match && !isIpv6Match) {
+            throw new Error(
+              `License key access restricted. This license key was created for a different system (authorized IPv4: ${payload.ipv4}, IPv6: ${payload.ipv6}) and cannot be used on this machine.`
+            );
+          }
+        } else if (payload.ipv4 && !isIpv4Match) {
+          throw new Error(
+            `License key access restricted. This license key was created for a different system (authorized IPv4: ${payload.ipv4}) and cannot be used on this machine.`
+          );
+        } else if (payload.ipv6 && !isIpv6Match) {
+          throw new Error(
+            `License key access restricted. This license key was created for a different system (authorized IPv6: ${payload.ipv6}) and cannot be used on this machine.`
+          );
+        }
+      }
+    } catch (err: any) {
+      if (err.message.includes('License key access restricted')) {
+        throw new ConfigurationException(`[Retrivora SDK] ${err.message}`);
+      }
+    }
+  }
 }

package/src/core/Pipeline.ts

@@ -256,7 +256,7 @@ You are a helpful assistant. Use the provided context to answer questions accura
 
     await this.vectorDB.initialize();
 
-    if (this.config.rag?.architecture === 'agentic' || (this.config.mcpServers && this.config.mcpServers.length > 0)) {
+    if (this.config.rag?.architecture === 'agentic' || this.config.rag?.architecture === 'multi-agent' || (this.config.mcpServers && this.config.mcpServers.length > 0)) {
       this.mcpRegistry = new MCPRegistry(this.config.mcpServers || []);
       this.multiAgentCoordinator = new MultiAgentCoordinator({
         llmProvider: this.llmProvider,
@@ -448,7 +448,7 @@ You are a helpful assistant. Use the provided context to answer questions accura
   async ask(question: string, history: ChatMessage[] = [], namespace?: string): Promise<ChatResponse> {
     await this.initialize();
 
-    if ((this.config.rag?.architecture === 'agentic' || (this.config.mcpServers && this.config.mcpServers.length > 0)) && this.multiAgentCoordinator) {
+    if ((this.config.rag?.architecture === 'agentic' || this.config.rag?.architecture === 'multi-agent' || (this.config.mcpServers && this.config.mcpServers.length > 0)) && this.multiAgentCoordinator) {
       return await this.multiAgentCoordinator.run(question, history);
     }
 
@@ -475,7 +475,7 @@ You are a helpful assistant. Use the provided context to answer questions accura
 
   async *askStream(question: string, history: ChatMessage[] = [], namespace?: string): AsyncIterable<string | ChatResponse> {
     await this.initialize();
-    if ((this.config.rag?.architecture === 'agentic' || (this.config.mcpServers && this.config.mcpServers.length > 0)) && this.multiAgentCoordinator) {
+    if ((this.config.rag?.architecture === 'agentic' || this.config.rag?.architecture === 'multi-agent' || (this.config.mcpServers && this.config.mcpServers.length > 0)) && this.multiAgentCoordinator) {
       const stream = this.multiAgentCoordinator.runStream(question, history);
       for await (const chunk of stream) {
         yield chunk;
@@ -535,7 +535,8 @@ You are a helpful assistant. Use the provided context to answer questions accura
       const cacheKey = `${ns}::${searchQuery}`;
       const cachedVector = this.embeddingCache.get(cacheKey);
 
-      const useGraph = this.graphDB && this.config.rag?.useGraphRetrieval;
+      const arch = this.config.rag?.architecture;
+      const useGraph = arch !== 'naive' && arch !== 'retrieve-and-rerank' && this.graphDB && this.config.rag?.useGraphRetrieval;
       const [strategyResult, embeddedVector] = await Promise.all([
         QueryProcessor.determineRetrievalStrategy(
           searchQuery,
@@ -579,7 +580,8 @@ You are a helpful assistant. Use the provided context to answer questions accura
         ? structuredSources
         : structuredSources.filter((m) => m.score >= scoreThreshold);
       const rerankLimit = wantsExhaustiveList ? retrievalLimit : topK;
-      if (!hasNumericPredicates && this.config.rag?.useReranking) {
+      const useReranking = arch !== 'naive' && (arch === 'retrieve-and-rerank' || this.config.rag?.useReranking);
+      if (!hasNumericPredicates && useReranking) {
         fullSources = await this.reranker.rerank(fullSources, question, rerankLimit);
       } else if (!wantsExhaustiveList) {
         fullSources = fullSources.slice(0, topK);
@@ -830,7 +832,7 @@ You are a helpful assistant. Use the provided context to answer questions accura
       const latency: LatencyBreakdown = {
         embedMs: Math.round(embedMs),
         retrieveMs: Math.round(retrieveMs),
-        rerankMs: this.config.rag?.useReranking ? Math.round(rerankMs) : undefined,
+        rerankMs: (arch !== 'naive' && (arch === 'retrieve-and-rerank' || this.config.rag?.useReranking)) ? Math.round(rerankMs) : undefined,
         generateMs: Math.round(generateMs),
         totalMs: Math.round(totalMs),
       };
@@ -879,8 +881,9 @@ You are a helpful assistant. Use the provided context to answer questions accura
       const trace = buildTrace(hallucinationResult);
 
       // Asynchronously trigger telemetry logging without blocking response yield
-      if (this.config.telemetry?.enabled) {
-        const telemetryUrl = this.config.telemetry.url || '/api/telemetry';
+      const isTelemetryActive = this.config.telemetry?.enabled ?? Boolean(this.config.licenseKey);
+      if (isTelemetryActive) {
+        const telemetryUrl = this.config.telemetry?.url || '/api/telemetry';
         const absoluteUrl = telemetryUrl.startsWith('http')
           ? telemetryUrl
           : (process.env.NEXT_PUBLIC_APP_URL || `http://localhost:${process.env.PORT || 3000}`) + telemetryUrl;

package/src/core/Retrivora.ts

@@ -29,6 +29,7 @@ export class Retrivora {
         this.config.projectId,
         this.config.vectorDb?.provider
       );
+      await LicenseVerifier.verifyIP(this.config.licenseKey);
     } catch (err) {
       throw wrapError(err, 'CONFIGURATION_ERROR');
     }