@retrivora-ai/rag-engine 0.1.7 → 0.1.9

package/src/providers/vectordb/MilvusProvider.ts

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

package/src/providers/vectordb/MultiTablePostgresProvider.ts

@@ -0,0 +1,164 @@
+import { Pool, PoolClient } from 'pg';
+import { BaseVectorProvider } from './BaseVectorProvider';
+import { VectorMatch, UpsertDocument } from '../../types';
+import { VectorDBConfig } from '../../config/RagConfig';
+
+/**
+ * MultiTablePostgresProvider — PostgreSQL implementation that searches across
+ * multiple existing tables with pre-existing embeddings.
+ *
+ * Extends BaseVectorProvider so it can be registered with ProviderRegistry.
+ * Upsert operations are not supported — data is assumed to be managed externally
+ * or via custom ingestion scripts that write directly to each table.
+ */
+export class MultiTablePostgresProvider extends BaseVectorProvider {
+  private pool!: Pool;
+  private readonly dimensions: number;
+  private readonly connectionString: string;
+  private readonly tables: string[];
+
+  constructor(config: VectorDBConfig) {
+    super(config);
+    const opts = config.options || {};
+    if (!opts.connectionString) {
+      throw new Error('[MultiTablePostgresProvider] options.connectionString is required');
+    }
+    this.connectionString = opts.connectionString as string;
+    this.dimensions = (opts.dimensions as number) ?? 768;
+
+    // Tables can come from options.tables (custom key) or be derived from VECTOR_DB_TABLES env var
+    const rawTables: string | string[] =
+      (opts.tables as string | string[]) ??
+      process.env.VECTOR_DB_TABLES ??
+      '';
+    
+    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(): Promise<void> {
+    this.pool = new Pool({ connectionString: this.connectionString });
+    // Verify connectivity
+    const client: PoolClient = 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: UpsertDocument, _namespace?: string): Promise<void> { // eslint-disable-line @typescript-eslint/no-unused-vars
+    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: UpsertDocument[], _namespace?: string): Promise<void> { // eslint-disable-line @typescript-eslint/no-unused-vars
+    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: number[],
+    topK: number,
+    _namespace?: string, // eslint-disable-line @typescript-eslint/no-unused-vars
+    _filter?: Record<string, unknown> // eslint-disable-line @typescript-eslint/no-unused-vars
+  ): Promise<VectorMatch[]> {
+    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: VectorMatch[] = [];
+
+    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 { score, id, ...rest } = row as Record<string, unknown>;
+          // Remove embedding from rest to avoid including it in content
+          delete rest.embedding;
+
+          // Build a human-readable content string from ALL available columns.
+          // This ensures the LLM sees the name, website, description, etc. together.
+          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: { ...rest, source_table: table },
+          });
+        }
+      } catch (err) {
+        console.error(
+          `[MultiTablePostgresProvider] Error querying table "${table}":`,
+          (err as Error).message
+        );
+      }
+    }
+
+    // Merge and rank by score descending
+    const sortedResults = allResults.sort((a, b) => b.score - a.score);
+    
+    if (sortedResults.length > 0) {
+      console.log(`[MultiTablePostgresProvider] Top match from "${sortedResults[0].metadata?.source_table ?? 'unknown'}" with score ${sortedResults[0].score.toFixed(4)}`);
+    }
+
+    return sortedResults.slice(0, topK);
+  }
+
+  async delete(_id: string | number, _namespace?: string): Promise<void> { // eslint-disable-line @typescript-eslint/no-unused-vars
+    console.warn('[MultiTablePostgresProvider] delete() is a no-op for multi-table mode.');
+  }
+
+  async deleteNamespace(_namespace: string): Promise<void> { // eslint-disable-line @typescript-eslint/no-unused-vars
+    console.warn('[MultiTablePostgresProvider] deleteNamespace() is a no-op for multi-table mode.');
+  }
+
+  async ping(): Promise<boolean> {
+    try {
+      await this.pool.query('SELECT 1');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.pool) {
+      await this.pool.end();
+    }
+  }
+}

package/src/providers/vectordb/PineconeProvider.ts

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

package/src/providers/vectordb/QdrantProvider.ts

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

package/src/providers/vectordb/RedisProvider.ts

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

package/src/providers/vectordb/UniversalVectorProvider.ts

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

package/src/providers/vectordb/WeaviateProvider.ts

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