@retrivora-ai/rag-engine 1.9.7 → 1.9.9

package/src/config/RagConfig.ts

@@ -157,6 +157,19 @@ export interface UIConfig {
 // RAG Pipeline Tuning
 // ---------------------------------------------------------------------------
 
+export interface CAGConfig {
+  /** Enable Cold RAG (Cache Augmented Generation) */
+  enabled?: boolean;
+  /** Namespace containing the cold data (e.g., static manuals/guides) */
+  coldNamespace?: string;
+  /** Limit of cold documents to retrieve at initialization and keep in cache/context */
+  coldLimit?: number;
+  /** Specific search query to retrieve the cold documents (e.g., "manual", "documentation") */
+  coldQuery?: string;
+  /** Specific document IDs to load as cold context */
+  coldDocumentIds?: string[];
+}
+
 export interface RAGConfig {
   /** Number of top-K chunks retrieved per query */
   topK?: number;
@@ -169,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) */
@@ -197,6 +210,18 @@ export interface RAGConfig {
    * Defaults to built-in list (find, search, tell me about, etc.).
    */
   vectorKeywords?: string[];
+  /** Cold RAG (Cache Augmented Generation) configuration */
+  cag?: CAGConfig;
+  /** Chat history configuration */
+  history?: {
+    enabled?: boolean;
+    tableName?: string;
+  };
+  /** User feedback configuration */
+  feedback?: {
+    enabled?: boolean;
+    tableName?: string;
+  };
 }
 
 export interface RetrievalConfig {
@@ -224,16 +249,28 @@ 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>;
 }
 
+export interface MCPServerConfig {
+  name: string;
+  transport: 'stdio' | 'sse';
+  url?: string;      // Required for SSE transport
+  command?: string;  // Required for Stdio transport
+  args?: string[];   // Optional for Stdio transport
+  env?: Record<string, string>; // Optional env variables for Stdio child process
+}
+
 // ---------------------------------------------------------------------------
 // Root Config
 // ---------------------------------------------------------------------------
 
 export interface RagConfig {
+  /** License key for commercial production validation */
+  licenseKey?: string;
+
   /**
    * Unique identifier for the consuming project.
    * Used as the vector DB namespace to achieve multi-tenancy.
@@ -257,6 +294,15 @@ export interface RagConfig {
 
   /** Optional Graph database configuration */
   graphDb?: GraphDBConfig;
+
+  /** Optional Telemetry configuration for observability logging */
+  telemetry?: {
+    enabled?: boolean;
+    url?: string;
+  };
+
+  /** Optional Model Context Protocol (MCP) server configurations */
+  mcpServers?: MCPServerConfig[];
 }
 
 /**

package/src/config/constants.ts

@@ -26,6 +26,8 @@ export const LLM_PROVIDERS = [
   'anthropic',
   'ollama',
   'gemini',
+  'groq',
+  'qwen',
   'rest',
   'universal_rest',
   'custom',
@@ -35,6 +37,7 @@ export const EMBEDDING_PROVIDERS = [
   'openai',
   'ollama',
   'gemini',
+  'qwen',
   'rest',
   'universal_rest',
   'custom',
@@ -51,6 +54,7 @@ export const PROVIDERS_WITH_EMBEDDINGS = [
   'openai',
   'ollama',
   'gemini',
+  'qwen',
   'rest',
   'universal_rest',
 ] as const;

package/src/config/serverConfig.ts

@@ -149,6 +149,7 @@ export function getEnvConfig(env: Record<string, string | undefined> = process.e
 
   return {
     projectId,
+    licenseKey: readString(env, 'RETRIVORA_LICENSE_KEY') ?? readString(env, 'LICENSE_KEY') ?? base?.licenseKey,
     vectorDb: {
       provider: vectorProvider,
       indexName:
@@ -217,6 +218,10 @@ export function getEnvConfig(env: Record<string, string | undefined> = process.e
         try { return JSON.parse(raw) as Record<string, string>; } catch { return undefined; }
       })(),
     },
+    telemetry: {
+      enabled: readString(env, 'TELEMETRY_ENABLED') === 'true' || readString(env, 'NEXT_PUBLIC_TELEMETRY_ENABLED') === 'true' || base?.telemetry?.enabled || false,
+      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
     ...(readString(env, 'GRAPH_DB_PROVIDER') ? {
       graphDb: {
@@ -228,5 +233,15 @@ export function getEnvConfig(env: Record<string, string | undefined> = process.e
         },
       },
     } : {}),
+    mcpServers: (() => {
+      const raw = readString(env, 'MCP_SERVERS') ?? readString(env, 'NEXT_PUBLIC_MCP_SERVERS');
+      if (!raw) return undefined;
+      try {
+        return JSON.parse(raw);
+      } catch (e) {
+        console.warn('[serverConfig] Failed to parse MCP_SERVERS env:', e);
+        return undefined;
+      }
+    })(),
   };
 }

package/src/core/ConfigResolver.ts

@@ -61,6 +61,12 @@ export class ConfigResolver {
         : envConfig.embedding,
       ui: hostConfig.ui ? mergeDefined(envConfig.ui, hostConfig.ui) : envConfig.ui,
       rag: hostConfig.rag ? { ...envConfig.rag, ...hostConfig.rag } : envConfig.rag,
+      telemetry: hostConfig.telemetry
+        ? {
+          ...envConfig.telemetry,
+          ...hostConfig.telemetry,
+        }
+        : envConfig.telemetry,
     };
   }
 
@@ -111,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/DatabaseStorage.ts

@@ -0,0 +1,469 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { RagConfig } from '../config/RagConfig';
+import { LicenseVerifier } from './LicenseVerifier';
+
+export interface HistoryMessage {
+  id: string;
+  role: string;
+  content: string;
+  sources?: any;
+  uiTransformation?: any;
+  trace?: any;
+  createdAt?: string;
+}
+
+export interface FeedbackItem {
+  id: string;
+  messageId: string;
+  sessionId: string;
+  rating: string;
+  comment?: string;
+  createdAt?: string;
+}
+
+export class DatabaseStorage {
+  private config: RagConfig;
+  private provider: string;
+  // Dynamic PG Pool
+  private pgPool: any = null;
+  // Dynamic MongoDB Client
+  private mongoClient: any = null;
+  private mongoDbName = '';
+
+  private historyTableName: string;
+  private feedbackTableName: string;
+
+  // Filesystem fallback configuration
+  private fallbackDir = path.join(process.cwd(), '.retrivora');
+  private historyFile = path.join(this.fallbackDir, 'history.json');
+  private feedbackFile = path.join(this.fallbackDir, 'feedback.json');
+
+  constructor(config: RagConfig) {
+    this.config = config;
+    this.provider = config.vectorDb?.provider || 'fs';
+
+    // Retrieve and sanitize table/collection names (alphanumeric + underscores only)
+    const rawHistoryTable = config.rag?.history?.tableName || 'retrivora_history';
+    const rawFeedbackTable = config.rag?.feedback?.tableName || 'retrivora_feedback';
+    this.historyTableName = rawHistoryTable.replace(/[^a-zA-Z0-9_]/g, '_');
+    this.feedbackTableName = rawFeedbackTable.replace(/[^a-zA-Z0-9_]/g, '_');
+  }
+
+  /**
+   * Asserts the user is running a valid Premium/Enterprise license in production.
+   * In non-production (development / test) environments this is a complete no-op —
+   * all History and Feedback features are freely accessible for local development.
+   */
+  private checkPremiumSubscription() {
+    // ── Development / test: fully open, no checks ────────────────────────────
+    if (process.env.NODE_ENV !== 'production') {
+      return;
+    }
+
+    // ── Production: license key required ────────────────────────────────────
+    if (!this.config.licenseKey) {
+      throw new Error(
+        '[Retrivora SDK] Chat History and Feedback features require a Premium or Enterprise license key in production.'
+      );
+    }
+
+    try {
+      const payload = LicenseVerifier.verify(this.config.licenseKey, this.config.projectId);
+      const tier = (payload.tier || '').toLowerCase();
+      if (
+        tier !== 'premium' &&
+        tier !== 'enterprise' &&
+        tier !== 'growth' &&
+        tier !== 'pro' &&
+        tier !== 'developer_pro'
+      ) {
+        throw new Error(
+          `[Retrivora SDK] Chat History and Feedback features are not available on the "${tier}" tier. ` +
+          `Please upgrade to a Developer Pro or Enterprise plan.`
+        );
+      }
+    } catch (err) {
+      throw new Error(
+        `[Retrivora SDK] Subscription check failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+
+  private checkHistoryEnabled() {
+    this.checkPremiumSubscription();
+    if (this.config.rag?.history?.enabled === false) {
+      throw new Error('[Retrivora SDK] Chat History is disabled in RagConfig.');
+    }
+  }
+
+  private checkFeedbackEnabled() {
+    this.checkPremiumSubscription();
+    if (this.config.rag?.feedback?.enabled === false) {
+      throw new Error('[Retrivora SDK] User Feedback is disabled in RagConfig.');
+    }
+  }
+
+  private async getPGPool() {
+    const globalKey = `__retrivora_pg_pool_${this.config.projectId}`;
+    const _g = global as any;
+    if (_g[globalKey]) {
+      this.pgPool = _g[globalKey];
+      return this.pgPool;
+    }
+    const opts = this.config.vectorDb.options as Record<string, any>;
+    if (!opts.connectionString) {
+      throw new Error('[DatabaseStorage] pg connectionString option is missing.');
+    }
+    const { Pool } = await import('pg');
+    this.pgPool = new Pool({ connectionString: opts.connectionString });
+    _g[globalKey] = this.pgPool;
+
+    // Initialize tables using dynamic sanitized table names
+    const client = await this.pgPool.connect();
+    try {
+      await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.historyTableName} (
+          id                TEXT PRIMARY KEY,
+          session_id        TEXT NOT NULL,
+          role              TEXT NOT NULL,
+          content           TEXT NOT NULL,
+          sources           JSONB,
+          ui_transformation JSONB,
+          trace             JSONB,
+          created_at        TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+      await client.query(`
+        CREATE TABLE IF NOT EXISTS ${this.feedbackTableName} (
+          id          TEXT PRIMARY KEY,
+          message_id  TEXT NOT NULL UNIQUE,
+          session_id  TEXT NOT NULL,
+          rating      TEXT NOT NULL,
+          comment     TEXT,
+          created_at  TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+    } finally {
+      client.release();
+    }
+    return this.pgPool;
+  }
+
+  private async getMongoClient() {
+    const globalKey = `__retrivora_mongo_client_${this.config.projectId}`;
+    const _g = global as any;
+    if (_g[globalKey]) {
+      this.mongoClient = _g[globalKey];
+      this.mongoDbName = (this.config.vectorDb.options as any).database;
+      return this.mongoClient;
+    }
+    const opts = this.config.vectorDb.options as Record<string, any>;
+    if (!opts.uri || !opts.database) {
+      throw new Error('[DatabaseStorage] mongo uri and database options are missing.');
+    }
+    const { MongoClient } = await import('mongodb');
+    this.mongoClient = new MongoClient(opts.uri);
+    await this.mongoClient.connect();
+    _g[globalKey] = this.mongoClient;
+    this.mongoDbName = opts.database;
+    return this.mongoClient;
+  }
+
+  private getMongoDb() {
+    return this.mongoClient.db(this.mongoDbName);
+  }
+
+  // Helper for FS fallback reads
+  private readLocalFile(filePath: string): any[] {
+    if (!fs.existsSync(filePath)) return [];
+    try {
+      const raw = fs.readFileSync(filePath, 'utf-8');
+      return JSON.parse(raw) || [];
+    } catch {
+      return [];
+    }
+  }
+
+  // Helper for FS fallback writes
+  private writeLocalFile(filePath: string, data: any[]): void {
+    if (!fs.existsSync(this.fallbackDir)) {
+      fs.mkdirSync(this.fallbackDir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+  }
+
+  // ─── Message History Operations ──────────────────────────────────────────
+
+  async saveMessage(
+    sessionId: string,
+    message: Omit<HistoryMessage, 'createdAt'>
+  ): Promise<void> {
+    this.checkHistoryEnabled();
+    const createdAt = new Date().toISOString();
+    const msgId = message.id || `msg_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+
+    if (this.provider === 'postgresql' || this.provider === 'pgvector') {
+      const pool = await this.getPGPool();
+      await pool.query(
+        `INSERT INTO ${this.historyTableName} (id, session_id, role, content, sources, ui_transformation, trace, created_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+         ON CONFLICT (id) DO UPDATE 
+         SET content = EXCLUDED.content, sources = EXCLUDED.sources, ui_transformation = EXCLUDED.ui_transformation, trace = EXCLUDED.trace`,
+        [
+          msgId,
+          sessionId,
+          message.role,
+          message.content,
+          message.sources ? JSON.stringify(message.sources) : null,
+          message.uiTransformation ? JSON.stringify(message.uiTransformation) : null,
+          message.trace ? JSON.stringify(message.trace) : null,
+          createdAt,
+        ]
+      );
+    } else if (this.provider === 'mongodb') {
+      await this.getMongoClient();
+      const db = this.getMongoDb();
+      const col = db.collection(this.historyTableName);
+      await col.updateOne(
+        { id: msgId },
+        {
+          $set: {
+            id: msgId,
+            session_id: sessionId,
+            role: message.role,
+            content: message.content,
+            sources: message.sources || null,
+            ui_transformation: message.uiTransformation || null,
+            trace: message.trace || null,
+            created_at: createdAt,
+          },
+        },
+        { upsert: true }
+      );
+    } else {
+      // Local FS fallback
+      const history = this.readLocalFile(this.historyFile);
+      const index = history.findIndex((h) => h.id === msgId);
+      const item = {
+        id: msgId,
+        session_id: sessionId,
+        role: message.role,
+        content: message.content,
+        sources: message.sources || null,
+        ui_transformation: message.uiTransformation || null,
+        trace: message.trace || null,
+        created_at: createdAt,
+      };
+
+      if (index !== -1) {
+        history[index] = item;
+      } else {
+        history.push(item);
+      }
+      this.writeLocalFile(this.historyFile, history);
+    }
+  }
+
+  async getHistory(sessionId: string): Promise<HistoryMessage[]> {
+    this.checkHistoryEnabled();
+    if (this.provider === 'postgresql' || this.provider === 'pgvector') {
+      const pool = await this.getPGPool();
+      const res = await pool.query(
+        `SELECT id, role, content, sources, ui_transformation as "uiTransformation", trace, created_at as "createdAt"
+         FROM ${this.historyTableName} 
+         WHERE session_id = $1 
+         ORDER BY created_at ASC`,
+        [sessionId]
+      );
+      return res.rows;
+    } else if (this.provider === 'mongodb') {
+      await this.getMongoClient();
+      const db = this.getMongoDb();
+      const col = db.collection(this.historyTableName);
+      const items = await col
+        .find({ session_id: sessionId })
+        .sort({ created_at: 1 })
+        .toArray();
+      return items.map((item: any) => ({
+        id: item.id,
+        role: item.role,
+        content: item.content,
+        sources: item.sources,
+        uiTransformation: item.ui_transformation,
+        trace: item.trace,
+        createdAt: item.created_at,
+      }));
+    } else {
+      const history = this.readLocalFile(this.historyFile);
+      return history
+        .filter((h) => h.session_id === sessionId)
+        .sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+    }
+  }
+
+  async clearHistory(sessionId: string): Promise<void> {
+    this.checkHistoryEnabled();
+    if (this.provider === 'postgresql' || this.provider === 'pgvector') {
+      const pool = await this.getPGPool();
+      await pool.query(`DELETE FROM ${this.historyTableName} WHERE session_id = $1`, [sessionId]);
+      await pool.query(`DELETE FROM ${this.feedbackTableName} WHERE session_id = $1`, [sessionId]);
+    } else if (this.provider === 'mongodb') {
+      await this.getMongoClient();
+      const db = this.getMongoDb();
+      await db.collection(this.historyTableName).deleteMany({ session_id: sessionId });
+      await db.collection(this.feedbackTableName).deleteMany({ session_id: sessionId });
+    } else {
+      const history = this.readLocalFile(this.historyFile);
+      const filteredHistory = history.filter((h) => h.session_id !== sessionId);
+      this.writeLocalFile(this.historyFile, filteredHistory);
+
+      const feedback = this.readLocalFile(this.feedbackFile);
+      const filteredFeedback = feedback.filter((f) => f.session_id !== sessionId);
+      this.writeLocalFile(this.feedbackFile, filteredFeedback);
+    }
+  }
+
+  async listSessions(): Promise<string[]> {
+    this.checkHistoryEnabled();
+    if (this.provider === 'postgresql' || this.provider === 'pgvector') {
+      const pool = await this.getPGPool();
+      const res = await pool.query(`SELECT DISTINCT session_id FROM ${this.historyTableName}`);
+      return res.rows.map((r: any) => r.session_id);
+    } else if (this.provider === 'mongodb') {
+      await this.getMongoClient();
+      const db = this.getMongoDb();
+      return db.collection(this.historyTableName).distinct('session_id');
+    } else {
+      const history = this.readLocalFile(this.historyFile);
+      const sessions = new Set<string>(history.map((h) => h.session_id));
+      return Array.from(sessions);
+    }
+  }
+
+  // ─── Feedback Operations ──────────────────────────────────────────────────
+
+  async saveFeedback(feedback: Omit<FeedbackItem, 'id' | 'createdAt'>): Promise<void> {
+    this.checkFeedbackEnabled();
+    const id = `fb_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const createdAt = new Date().toISOString();
+
+    if (this.provider === 'postgresql' || this.provider === 'pgvector') {
+      const pool = await this.getPGPool();
+      await pool.query(
+        `INSERT INTO ${this.feedbackTableName} (id, message_id, session_id, rating, comment, created_at)
+         VALUES ($1, $2, $3, $4, $5, $6)
+         ON CONFLICT (message_id) DO UPDATE 
+         SET rating = EXCLUDED.rating, comment = EXCLUDED.comment`,
+        [id, feedback.messageId, feedback.sessionId, feedback.rating, feedback.comment || null, createdAt]
+      );
+    } else if (this.provider === 'mongodb') {
+      await this.getMongoClient();
+      const db = this.getMongoDb();
+      const col = db.collection(this.feedbackTableName);
+      await col.updateOne(
+        { message_id: feedback.messageId },
+        {
+          $set: {
+            id,
+            message_id: feedback.messageId,
+            session_id: feedback.sessionId,
+            rating: feedback.rating,
+            comment: feedback.comment || null,
+            created_at: createdAt,
+          },
+        },
+        { upsert: true }
+      );
+    } else {
+      const list = this.readLocalFile(this.feedbackFile);
+      const index = list.findIndex((f) => f.message_id === feedback.messageId);
+      const item = {
+        id,
+        message_id: feedback.messageId,
+        session_id: feedback.sessionId,
+        rating: feedback.rating,
+        comment: feedback.comment || null,
+        created_at: createdAt,
+      };
+
+      if (index !== -1) {
+        list[index] = item;
+      } else {
+        list.push(item);
+      }
+      this.writeLocalFile(this.feedbackFile, list);
+    }
+  }
+
+  async getFeedback(messageId: string): Promise<FeedbackItem | null> {
+    this.checkFeedbackEnabled();
+    if (this.provider === 'postgresql' || this.provider === 'pgvector') {
+      const pool = await this.getPGPool();
+      const res = await pool.query(
+        `SELECT id, message_id as "messageId", session_id as "sessionId", rating, comment, created_at as "createdAt"
+         FROM ${this.feedbackTableName} 
+         WHERE message_id = $1`,
+        [messageId]
+      );
+      return res.rows[0] || null;
+    } else if (this.provider === 'mongodb') {
+      await this.getMongoClient();
+      const db = this.getMongoDb();
+      const col = db.collection(this.feedbackTableName);
+      const item = await col.findOne({ message_id: messageId });
+      if (!item) return null;
+      return {
+        id: item.id,
+        messageId: item.message_id,
+        sessionId: item.session_id,
+        rating: item.rating,
+        comment: item.comment,
+        createdAt: item.created_at,
+      };
+    } else {
+      const list = this.readLocalFile(this.feedbackFile);
+      return list.find((f) => f.message_id === messageId) || null;
+    }
+  }
+
+  async listFeedback(): Promise<FeedbackItem[]> {
+    this.checkFeedbackEnabled();
+    if (this.provider === 'postgresql' || this.provider === 'pgvector') {
+      const pool = await this.getPGPool();
+      const res = await pool.query(
+        `SELECT id, message_id as "messageId", session_id as "sessionId", rating, comment, created_at as "createdAt"
+         FROM ${this.feedbackTableName} 
+         ORDER BY created_at DESC`
+      );
+      return res.rows;
+    } else if (this.provider === 'mongodb') {
+      await this.getMongoClient();
+      const db = this.getMongoDb();
+      const col = db.collection(this.feedbackTableName);
+      const items = await col.find({}).sort({ created_at: -1 }).toArray();
+      return items.map((item: any) => ({
+        id: item.id,
+        messageId: item.message_id,
+        sessionId: item.session_id,
+        rating: item.rating,
+        comment: item.comment,
+        createdAt: item.created_at,
+      }));
+    } else {
+      const list = this.readLocalFile(this.feedbackFile);
+      return [...list].sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+    }
+  }
+
+  async disconnect() {
+    if (this.pgPool) {
+      await this.pgPool.end();
+      this.pgPool = null;
+    }
+    if (this.mongoClient) {
+      await this.mongoClient.close();
+      this.mongoClient = null;
+    }
+  }
+}