@retrivora-ai/rag-engine 2.1.7 → 2.2.0

package/src/providers/vectordb/PineconeProvider.ts

@@ -4,19 +4,19 @@ import { BaseVectorProvider } from './BaseVectorProvider';
 import { VectorMatch, UpsertDocument } from '../../types';
 import { IProviderValidator, IProviderHealthChecker, HealthCheckResult } from '../../core/ProviderInterfaces';
 import { ValidationError } from '../../core/ConfigValidator';
+import { ConfigFetcher } from '../../core/ConfigFetcher';
 
 /**
  * PineconeProvider — Pinecone vector database implementation.
  */
 export class PineconeProvider extends BaseVectorProvider {
   private client!: Pinecone;
-  private readonly apiKey: string;
+  private apiKey: string;
 
   constructor(config: VectorDBConfig) {
     super(config);
-    const opts = config.options as Record<string, string>;
-    if (!opts.apiKey) throw new Error('[PineconeProvider] options.apiKey is required');
-    this.apiKey = opts.apiKey;
+    const opts = (config.options || {}) as Record<string, string>;
+    this.apiKey = opts.apiKey || process.env.PINECONE_API_KEY || '';
   }
 
   static getValidator(): IProviderValidator {
@@ -24,12 +24,17 @@ export class PineconeProvider extends BaseVectorProvider {
       validate(config: Record<string, unknown>): ValidationError[] {
         const errors: ValidationError[] = [];
         const opts = (config.options || {}) as Record<string, unknown>;
+        const hasLicenseKey = Boolean(
+          config.licenseKey ||
+          process.env.RETRIVORA_LICENSE_KEY ||
+          process.env.NEXT_PUBLIC_RETRIVORA_LICENSE_KEY
+        );
 
-        if (!opts.apiKey) {
+        if (!opts.apiKey && !hasLicenseKey) {
           errors.push({
             field: 'vectorDb.options.apiKey',
-            message: 'Pinecone API key is required',
-            suggestion: 'Set PINECONE_API_KEY environment variable',
+            message: 'Pinecone API key is required when RETRIVORA_LICENSE_KEY is not set',
+            suggestion: 'Set PINECONE_API_KEY environment variable or supply RETRIVORA_LICENSE_KEY for keyless vector storage',
             severity: 'error',
           });
         }
@@ -78,23 +83,55 @@ export class PineconeProvider extends BaseVectorProvider {
   }
 
   async initialize(): Promise<void> {
-    this.client = new Pinecone({ apiKey: this.apiKey });
-    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. Available: ${names.join(', ')}`
-      );
+    if (this.client) return;
+
+    let key = this.apiKey || process.env.PINECONE_API_KEY || '';
+
+    if (!key) {
+      const projectId = process.env.RAG_PROJECT_ID || process.env.NEXT_PUBLIC_RAG_PROJECT_ID || 'my-rag-app';
+      const licenseKey = process.env.RETRIVORA_LICENSE_KEY || process.env.NEXT_PUBLIC_RETRIVORA_LICENSE_KEY;
+      
+      const remoteConfig = await ConfigFetcher.fetchRemoteVectorConfig(projectId, licenseKey);
+      if (remoteConfig?.apiKey) {
+        key = remoteConfig.apiKey;
+        this.apiKey = key;
+        if (remoteConfig.indexName) {
+          this.indexName = remoteConfig.indexName;
+        }
+      }
+    }
+
+    if (!key) {
+      console.warn('[PineconeProvider] Warning: No Pinecone API key available locally or remotely.');
+      return;
+    }
+
+    this.client = new Pinecone({ apiKey: key });
+    try {
+      const indexes = await this.client.listIndexes();
+      const names = indexes.indexes?.map((i) => i.name) ?? [];
+      if (!names.includes(this.indexName)) {
+        console.warn(`[PineconeProvider] Target index "${this.indexName}" not listed. Proceeding with configured index name.`);
+      }
+    } catch (err) {
+      console.warn('[PineconeProvider] List index verification warning:', err instanceof Error ? err.message : String(err));
     }
   }
 
-  private index(namespace?: string) {
+  private async getActiveIndex(namespace?: string) {
+    if (!this.client) {
+      await this.initialize();
+    }
+    if (!this.client) {
+      throw new Error('[PineconeProvider] Cannot execute vector operation: Pinecone client failed to initialize.');
+    }
     const idx = this.client.index(this.indexName);
     return namespace ? idx.namespace(namespace) : idx.namespace('');
   }
 
   async upsert(doc: UpsertDocument, namespace?: string): Promise<void> {
-    await this.index(namespace).upsert({
+    const targetIdx = await this.getActiveIndex(namespace);
+    await targetIdx.upsert({
       records: [{
         id: String(doc.id),
         values: doc.vector,
@@ -104,6 +141,7 @@ export class PineconeProvider extends BaseVectorProvider {
   }
 
   async batchUpsert(docs: UpsertDocument[], namespace?: string): Promise<void> {
+    const targetIdx = await this.getActiveIndex(namespace);
     const BATCH = 100;
     for (let i = 0; i < docs.length; i += BATCH) {
       const records = docs.slice(i, i + BATCH).map((d) => ({
@@ -111,7 +149,7 @@ export class PineconeProvider extends BaseVectorProvider {
         values: d.vector,
         metadata: { content: d.content, ...(d.metadata ?? {}) } as RecordMetadata,
       }));
-      await this.index(namespace).upsert({ records });
+      await targetIdx.upsert({ records });
     }
   }
 
@@ -121,8 +159,9 @@ export class PineconeProvider extends BaseVectorProvider {
     namespace?: string,
     filter?: Record<string, unknown>
   ): Promise<VectorMatch[]> {
+    const targetIdx = await this.getActiveIndex(namespace);
     const pineconeFilter = this.sanitizeFilter(filter);
-    const result = await this.index(namespace).query({
+    const result = await targetIdx.query({
       vector,
       topK,
       includeMetadata: true,
@@ -137,15 +176,19 @@ export class PineconeProvider extends BaseVectorProvider {
   }
 
   async delete(id: string | number, namespace?: string): Promise<void> {
-    await this.index(namespace).deleteOne({ id: String(id) });
+    const targetIdx = await this.getActiveIndex(namespace);
+    await targetIdx.deleteOne({ id: String(id) });
   }
 
   async deleteNamespace(namespace: string): Promise<void> {
-    await this.client.index(this.indexName).namespace(namespace).deleteAll();
+    const targetIdx = await this.getActiveIndex(namespace);
+    await targetIdx.deleteAll();
   }
 
   async ping(): Promise<boolean> {
     try {
+      if (!this.client) await this.initialize();
+      if (!this.client) return false;
       await this.client.listIndexes();
       return true;
     } catch {