@mhalder/qdrant-mcp-server 3.3.2 → 3.3.4

package/src/code/indexer.ts

@@ -8,10 +8,10 @@ import { promises as fs } from "node:fs";
 import { extname, join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import picomatch from "picomatch";
-import logger from "../logger.js";
 import type { EmbeddingProvider } from "../embeddings/base.js";
 import { BM25SparseVectorGenerator } from "../embeddings/sparse.js";
 import { normalizeRemoteUrl } from "../git/extractor.js";
+import logger from "../logger.js";
 import type { QdrantManager } from "../qdrant/client.js";
 import { TreeSitterChunker } from "./chunker/tree-sitter-chunker.js";
 import { MetadataExtractor } from "./metadata.js";
@@ -40,7 +40,7 @@ export class CodeIndexer {
   constructor(
     private qdrant: QdrantManager,
     private embeddings: EmbeddingProvider,
-    private config: CodeConfig,
+    private config: CodeConfig
   ) {}
 
   /**
@@ -57,7 +57,7 @@ export class CodeIndexer {
       // For now, we just ensure the path exists and is resolved
       // In a more restrictive environment, you could check against an allowlist
       return realPath;
-    } catch (error) {
+    } catch (_error) {
       // If realpath fails, the path doesn't exist yet or is invalid
       // For operations like indexing, we still need to accept non-existent paths
       // so we just return the resolved absolute path
@@ -71,7 +71,7 @@ export class CodeIndexer {
   async indexCodebase(
     path: string,
     options?: IndexOptions,
-    progressCallback?: ProgressCallback,
+    progressCallback?: ProgressCallback
   ): Promise<IndexStats> {
     const startTime = Date.now();
     const stats: IndexStats = {
@@ -99,11 +99,9 @@ export class CodeIndexer {
       });
 
       const scanner = new FileScanner({
-        supportedExtensions:
-          options?.extensions || this.config.supportedExtensions,
+        supportedExtensions: options?.extensions || this.config.supportedExtensions,
         ignorePatterns: this.config.ignorePatterns,
-        customIgnorePatterns:
-          options?.ignorePatterns || this.config.customIgnorePatterns,
+        customIgnorePatterns: options?.ignorePatterns || this.config.customIgnorePatterns,
       });
 
       await scanner.loadIgnorePatterns(absolutePath);
@@ -119,8 +117,7 @@ export class CodeIndexer {
       }
 
       // 2. Create or verify collection
-      const collectionExists =
-        await this.qdrant.collectionExists(collectionName);
+      const collectionExists = await this.qdrant.collectionExists(collectionName);
 
       if (options?.forceReindex && collectionExists) {
         await this.qdrant.deleteCollection(collectionName);
@@ -132,7 +129,7 @@ export class CodeIndexer {
           collectionName,
           vectorSize,
           "Cosine",
-          this.config.enableHybridSearch,
+          this.config.enableHybridSearch
         );
         this.log.debug({ collectionName, vectorSize }, "Collection created");
       }
@@ -163,9 +160,7 @@ export class CodeIndexer {
 
           // Check for secrets (basic detection)
           if (metadataExtractor.containsSecrets(code)) {
-            stats.errors?.push(
-              `Skipped ${filePath}: potential secrets detected`,
-            );
+            stats.errors?.push(`Skipped ${filePath}: potential secrets detected`);
             continue;
           }
 
@@ -182,10 +177,7 @@ export class CodeIndexer {
             allChunks.push({ chunk, id });
 
             // Check total chunk limit
-            if (
-              this.config.maxTotalChunks &&
-              allChunks.length >= this.config.maxTotalChunks
-            ) {
+            if (this.config.maxTotalChunks && allChunks.length >= this.config.maxTotalChunks) {
               break;
             }
           }
@@ -193,15 +185,11 @@ export class CodeIndexer {
           stats.filesIndexed++;
 
           // Check total chunk limit
-          if (
-            this.config.maxTotalChunks &&
-            allChunks.length >= this.config.maxTotalChunks
-          ) {
+          if (this.config.maxTotalChunks && allChunks.length >= this.config.maxTotalChunks) {
             break;
           }
         } catch (error) {
-          const errorMessage =
-            error instanceof Error ? error.message : String(error);
+          const errorMessage = error instanceof Error ? error.message : String(error);
           stats.errors?.push(`Failed to process ${filePath}: ${errorMessage}`);
         }
       }
@@ -214,8 +202,7 @@ export class CodeIndexer {
         await synchronizer.updateSnapshot(files);
       } catch (error) {
         // Snapshot failure shouldn't fail the entire indexing
-        const errorMessage =
-          error instanceof Error ? error.message : String(error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
         this.log.error({ err: error }, "Failed to save snapshot");
         stats.errors?.push(`Snapshot save failed: ${errorMessage}`);
       }
@@ -230,10 +217,7 @@ export class CodeIndexer {
 
       // 4. Generate embeddings and store in batches
       const batchSize = this.config.batchSize;
-      this.log.debug(
-        { totalChunks: allChunks.length, batchSize },
-        "Starting embedding generation",
-      );
+      this.log.debug({ totalChunks: allChunks.length, batchSize }, "Starting embedding generation");
       for (let i = 0; i < allChunks.length; i += batchSize) {
         const batch = allChunks.slice(i, i + batchSize);
 
@@ -241,8 +225,7 @@ export class CodeIndexer {
           phase: "embedding",
           current: i + batch.length,
           total: allChunks.length,
-          percentage:
-            40 + Math.round(((i + batch.length) / allChunks.length) * 30), // 40-70%
+          percentage: 40 + Math.round(((i + batch.length) / allChunks.length) * 30), // 40-70%
           message: `Generating embeddings ${i + batch.length}/${allChunks.length}`,
         });
 
@@ -274,8 +257,7 @@ export class CodeIndexer {
             phase: "storing",
             current: i + batch.length,
             total: allChunks.length,
-            percentage:
-              70 + Math.round(((i + batch.length) / allChunks.length) * 30), // 70-100%
+            percentage: 70 + Math.round(((i + batch.length) / allChunks.length) * 30), // 70-100%
             message: `Storing chunks ${i + batch.length}/${allChunks.length}`,
           });
 
@@ -307,11 +289,8 @@ export class CodeIndexer {
             await this.qdrant.addPoints(collectionName, points);
           }
         } catch (error) {
-          const errorMessage =
-            error instanceof Error ? error.message : String(error);
-          stats.errors?.push(
-            `Failed to process batch at index ${i}: ${errorMessage}`,
-          );
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          stats.errors?.push(`Failed to process batch at index ${i}: ${errorMessage}`);
           stats.status = "partial";
         }
       }
@@ -326,12 +305,11 @@ export class CodeIndexer {
           chunksCreated: stats.chunksCreated,
           durationMs: stats.durationMs,
         },
-        "Indexing complete",
+        "Indexing complete"
       );
       return stats;
     } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
       stats.status = "failed";
       stats.errors?.push(`Indexing failed: ${errorMessage}`);
       stats.durationMs = Date.now() - startTime;
@@ -343,18 +321,14 @@ export class CodeIndexer {
    * Store an indexing status marker in the collection.
    * Called at the start of indexing with complete=false, and at the end with complete=true.
    */
-  private async storeIndexingMarker(
-    collectionName: string,
-    complete: boolean,
-  ): Promise<void> {
+  private async storeIndexingMarker(collectionName: string, complete: boolean): Promise<void> {
     try {
       // Create a dummy vector of zeros (required by Qdrant)
       const vectorSize = this.embeddings.getDimensions();
       const zeroVector = new Array(vectorSize).fill(0);
 
       // Check if collection uses hybrid mode
-      const collectionInfo =
-        await this.qdrant.getCollectionInfo(collectionName);
+      const collectionInfo = await this.qdrant.getCollectionInfo(collectionName);
 
       const payload = {
         _type: "indexing_metadata",
@@ -394,7 +368,7 @@ export class CodeIndexer {
   async searchCode(
     path: string,
     query: string,
-    options?: SearchOptions,
+    options?: SearchOptions
   ): Promise<CodeSearchResult[]> {
     const absolutePath = await this.validatePath(path);
     const collectionName = await this.getCollectionName(absolutePath);
@@ -408,8 +382,7 @@ export class CodeIndexer {
     // Check if collection has hybrid search enabled
     const collectionInfo = await this.qdrant.getCollectionInfo(collectionName);
     const useHybrid =
-      (options?.useHybrid ?? this.config.enableHybridSearch) &&
-      collectionInfo.hybridEnabled;
+      (options?.useHybrid ?? this.config.enableHybridSearch) && collectionInfo.hybridEnabled;
 
     // Generate query embedding
     const { embedding } = await this.embeddings.embed(query);
@@ -429,9 +402,7 @@ export class CodeIndexer {
 
     // Prepare pathPattern matcher for post-filtering
     // Qdrant doesn't support regex/glob filtering, so we filter results in JS
-    const pathMatcher = options?.pathPattern
-      ? picomatch(options.pathPattern, { dot: true })
-      : null;
+    const pathMatcher = options?.pathPattern ? picomatch(options.pathPattern, { dot: true }) : null;
 
     // When using pathPattern, fetch more results to account for filtering
     const fetchLimit = pathMatcher
@@ -448,15 +419,10 @@ export class CodeIndexer {
         embedding,
         sparseVector,
         fetchLimit,
-        filter,
+        filter
       );
     } else {
-      results = await this.qdrant.search(
-        collectionName,
-        embedding,
-        fetchLimit,
-        filter,
-      );
+      results = await this.qdrant.search(collectionName, embedding, fetchLimit, filter);
     }
 
     // Apply pathPattern post-filtering if specified
@@ -470,9 +436,7 @@ export class CodeIndexer {
 
     // Apply score threshold if specified
     if (options?.scoreThreshold) {
-      filteredResults = filteredResults.filter(
-        (r) => r.score >= (options.scoreThreshold || 0),
-      );
+      filteredResults = filteredResults.filter((r) => r.score >= (options.scoreThreshold || 0));
     }
 
     // Apply the requested limit after all filtering
@@ -504,10 +468,7 @@ export class CodeIndexer {
     }
 
     // Check for indexing marker in Qdrant (persisted across instances)
-    const indexingMarker = await this.qdrant.getPoint(
-      collectionName,
-      INDEXING_METADATA_ID,
-    );
+    const indexingMarker = await this.qdrant.getPoint(collectionName, INDEXING_METADATA_ID);
     const info = await this.qdrant.getCollectionInfo(collectionName);
 
     // Check marker status
@@ -515,9 +476,7 @@ export class CodeIndexer {
     const isInProgress = indexingMarker?.payload?.indexingComplete === false;
 
     // Subtract 1 from points count if marker exists (metadata point doesn't count as a chunk)
-    const actualChunksCount = indexingMarker
-      ? Math.max(0, info.pointsCount - 1)
-      : info.pointsCount;
+    const actualChunksCount = indexingMarker ? Math.max(0, info.pointsCount - 1) : info.pointsCount;
 
     if (isInProgress) {
       // Indexing in progress - marker exists with indexingComplete=false
@@ -565,10 +524,7 @@ export class CodeIndexer {
   /**
    * Incrementally re-index only changed files
    */
-  async reindexChanges(
-    path: string,
-    progressCallback?: ProgressCallback,
-  ): Promise<ChangeStats> {
+  async reindexChanges(path: string, progressCallback?: ProgressCallback): Promise<ChangeStats> {
     const startTime = Date.now();
     const stats: ChangeStats = {
       filesAdded: 0,
@@ -596,9 +552,7 @@ export class CodeIndexer {
       const hasSnapshot = await synchronizer.initialize();
 
       if (!hasSnapshot) {
-        throw new Error(
-          "No previous snapshot found. Use index_codebase for initial indexing.",
-        );
+        throw new Error("No previous snapshot found. Use index_codebase for initial indexing.");
       }
 
       // Scan current files
@@ -625,11 +579,7 @@ export class CodeIndexer {
       stats.filesModified = changes.modified.length;
       stats.filesDeleted = changes.deleted.length;
 
-      if (
-        stats.filesAdded === 0 &&
-        stats.filesModified === 0 &&
-        stats.filesDeleted === 0
-      ) {
+      if (stats.filesAdded === 0 && stats.filesModified === 0 && stats.filesDeleted === 0) {
         stats.durationMs = Date.now() - startTime;
         return stats;
       }
@@ -661,10 +611,7 @@ export class CodeIndexer {
             await this.qdrant.deletePointsByFilter(collectionName, filter);
           } catch (error) {
             // Log but don't fail - file might not have any chunks
-            this.log.error(
-              { relativePath, err: error },
-              "Failed to delete chunks during reindex",
-            );
+            this.log.error({ relativePath, err: error }, "Failed to delete chunks during reindex");
           }
         }
       }
@@ -698,10 +645,7 @@ export class CodeIndexer {
             allChunks.push({ chunk, id });
           }
         } catch (error) {
-          this.log.error(
-            { filePath, err: error },
-            "Failed to process file during reindex",
-          );
+          this.log.error({ filePath, err: error }, "Failed to process file during reindex");
         }
       }
 
@@ -716,8 +660,7 @@ export class CodeIndexer {
           phase: "embedding",
           current: i + batch.length,
           total: allChunks.length,
-          percentage:
-            40 + Math.round(((i + batch.length) / allChunks.length) * 30),
+          percentage: 40 + Math.round(((i + batch.length) / allChunks.length) * 30),
           message: `Generating embeddings ${i + batch.length}/${allChunks.length}`,
         });
 
@@ -747,8 +690,7 @@ export class CodeIndexer {
           phase: "storing",
           current: i + batch.length,
           total: allChunks.length,
-          percentage:
-            70 + Math.round(((i + batch.length) / allChunks.length) * 30),
+          percentage: 70 + Math.round(((i + batch.length) / allChunks.length) * 30),
           message: `Storing chunks ${i + batch.length}/${allChunks.length}`,
         });
 
@@ -756,9 +698,7 @@ export class CodeIndexer {
           const sparseGenerator = new BM25SparseVectorGenerator();
           const hybridPoints = points.map((point, idx) => ({
             ...point,
-            sparseVector: sparseGenerator.generate(
-              allChunks[i + idx].chunk.content,
-            ),
+            sparseVector: sparseGenerator.generate(allChunks[i + idx].chunk.content),
           }));
           await this.qdrant.addPointsWithSparse(collectionName, hybridPoints);
         } else {
@@ -778,12 +718,11 @@ export class CodeIndexer {
           chunksAdded: stats.chunksAdded,
           durationMs: stats.durationMs,
         },
-        "Reindex complete",
+        "Reindex complete"
       );
       return stats;
     } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
       throw new Error(`Incremental re-indexing failed: ${errorMessage}`);
     }
   }
@@ -830,17 +769,16 @@ export class CodeIndexer {
       const { stdout: gitRootResult } = await execFileAsync(
         "git",
         ["rev-parse", "--show-toplevel"],
-        { cwd: absolutePath, env: cleanEnv },
+        { cwd: absolutePath, env: cleanEnv }
       );
       const gitRoot = gitRootResult.trim();
 
       // Only use git remote if this path IS the git root
       if (gitRoot === absolutePath) {
-        const { stdout } = await execFileAsync(
-          "git",
-          ["remote", "get-url", "origin"],
-          { cwd: absolutePath, env: cleanEnv },
-        );
+        const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], {
+          cwd: absolutePath,
+          env: cleanEnv,
+        });
         const normalized = normalizeRemoteUrl(stdout.trim());
         if (normalized) {
           const hash = createHash("md5").update(normalized).digest("hex");

package/src/code/scanner.ts

@@ -19,7 +19,7 @@ export class FileScanner {
    * Load ignore patterns from .gitignore, .dockerignore, .npmignore, and .contextignore
    */
   async loadIgnorePatterns(rootPath: string): Promise<void> {
-    const ignoreFiles = [".gitignore", ".dockerignore", ".npmignore", ".contextignore"];
+    const ignoreFiles = [".gitignore", ".dockerignore", ".contextignore"];
 
     for (const ignoreFile of ignoreFiles) {
       const ignorePath = join(rootPath, ignoreFile);

package/src/embeddings/cohere.test.ts

@@ -40,36 +40,23 @@ describe("CohereEmbeddings", () => {
     });
 
     it("should use custom model", () => {
-      const customEmbeddings = new CohereEmbeddings(
-        "test-api-key",
-        "embed-multilingual-v3.0",
-      );
+      const customEmbeddings = new CohereEmbeddings("test-api-key", "embed-multilingual-v3.0");
       expect(customEmbeddings.getModel()).toBe("embed-multilingual-v3.0");
       expect(customEmbeddings.getDimensions()).toBe(1024);
     });
 
     it("should use custom dimensions", () => {
-      const customEmbeddings = new CohereEmbeddings(
-        "test-api-key",
-        "embed-english-v3.0",
-        512,
-      );
+      const customEmbeddings = new CohereEmbeddings("test-api-key", "embed-english-v3.0", 512);
       expect(customEmbeddings.getDimensions()).toBe(512);
     });
 
     it("should use default dimensions for light models", () => {
-      const lightEmbeddings = new CohereEmbeddings(
-        "test-api-key",
-        "embed-english-light-v3.0",
-      );
+      const lightEmbeddings = new CohereEmbeddings("test-api-key", "embed-english-light-v3.0");
       expect(lightEmbeddings.getDimensions()).toBe(384);
     });
 
     it("should default to 1024 for unknown models", () => {
-      const unknownEmbeddings = new CohereEmbeddings(
-        "test-api-key",
-        "custom-model",
-      );
+      const unknownEmbeddings = new CohereEmbeddings("test-api-key", "custom-model");
       expect(unknownEmbeddings.getDimensions()).toBe(1024);
     });
 
@@ -79,7 +66,7 @@ describe("CohereEmbeddings", () => {
         "embed-english-v3.0",
         undefined,
         undefined,
-        "search_query",
+        "search_query"
       );
       expect(searchQueryEmbeddings).toBeInstanceOf(CohereEmbeddings);
     });
@@ -130,7 +117,7 @@ describe("CohereEmbeddings", () => {
       const customEmbeddings = new CohereEmbeddings(
         "test-api-key",
         "embed-multilingual-v3.0",
-        1024,
+        1024
       );
       const mockEmbedding = Array(1024).fill(0.1);
       mockClient.embed.mockResolvedValue({
@@ -153,7 +140,7 @@ describe("CohereEmbeddings", () => {
       });
 
       await expect(embeddings.embed("test")).rejects.toThrow(
-        "No embedding returned from Cohere API",
+        "No embedding returned from Cohere API"
       );
     });
 
@@ -166,11 +153,7 @@ describe("CohereEmbeddings", () => {
 
   describe("embedBatch", () => {
     it("should generate embeddings for multiple texts", async () => {
-      const mockEmbeddings = [
-        Array(1024).fill(0.1),
-        Array(1024).fill(0.2),
-        Array(1024).fill(0.3),
-      ];
+      const mockEmbeddings = [Array(1024).fill(0.1), Array(1024).fill(0.2), Array(1024).fill(0.3)];
       mockClient.embed.mockResolvedValue({
         embeddings: mockEmbeddings,
       });
@@ -235,16 +218,14 @@ describe("CohereEmbeddings", () => {
       mockClient.embed.mockResolvedValue({});
 
       await expect(embeddings.embedBatch(["text1"])).rejects.toThrow(
-        "No embeddings returned from Cohere API",
+        "No embeddings returned from Cohere API"
       );
     });
 
     it("should propagate errors in batch", async () => {
       mockClient.embed.mockRejectedValue(new Error("Batch API Error"));
 
-      await expect(embeddings.embedBatch(["text1", "text2"])).rejects.toThrow(
-        "Batch API Error",
-      );
+      await expect(embeddings.embedBatch(["text1", "text2"])).rejects.toThrow("Batch API Error");
     });
   });
 
@@ -254,11 +235,7 @@ describe("CohereEmbeddings", () => {
     });
 
     it("should return custom dimensions", () => {
-      const customEmbeddings = new CohereEmbeddings(
-        "test-api-key",
-        "embed-english-v3.0",
-        512,
-      );
+      const customEmbeddings = new CohereEmbeddings("test-api-key", "embed-english-v3.0", 512);
       expect(customEmbeddings.getDimensions()).toBe(512);
     });
   });
@@ -269,10 +246,7 @@ describe("CohereEmbeddings", () => {
     });
 
     it("should return custom model", () => {
-      const customEmbeddings = new CohereEmbeddings(
-        "test-api-key",
-        "embed-multilingual-v3.0",
-      );
+      const customEmbeddings = new CohereEmbeddings("test-api-key", "embed-multilingual-v3.0");
       expect(customEmbeddings.getModel()).toBe("embed-multilingual-v3.0");
     });
   });
@@ -331,7 +305,7 @@ describe("CohereEmbeddings", () => {
         {
           retryAttempts: 3,
           retryDelayMs: 100,
-        },
+        }
       );
 
       const mockEmbedding = Array(1024).fill(0.5);
@@ -361,7 +335,7 @@ describe("CohereEmbeddings", () => {
         {
           retryAttempts: 2,
           retryDelayMs: 100,
-        },
+        }
       );
 
       const rateLimitError = {
@@ -372,7 +346,7 @@ describe("CohereEmbeddings", () => {
       mockClient.embed.mockRejectedValue(rateLimitError);
 
       await expect(rateLimitEmbeddings.embed("test text")).rejects.toThrow(
-        "Cohere API rate limit exceeded after 2 retry attempts",
+        "Cohere API rate limit exceeded after 2 retry attempts"
       );
 
       expect(mockClient.embed).toHaveBeenCalledTimes(3);
@@ -397,9 +371,7 @@ describe("CohereEmbeddings", () => {
       const apiError = new Error("Invalid API key");
       mockClient.embed.mockRejectedValue(apiError);
 
-      await expect(embeddings.embed("test text")).rejects.toThrow(
-        "Invalid API key",
-      );
+      await expect(embeddings.embed("test text")).rejects.toThrow("Invalid API key");
       expect(mockClient.embed).toHaveBeenCalledTimes(1);
     });
 
@@ -412,7 +384,7 @@ describe("CohereEmbeddings", () => {
           maxRequestsPerMinute: 200,
           retryAttempts: 5,
           retryDelayMs: 2000,
-        },
+        }
       );
 
       expect(customEmbeddings).toBeDefined();

package/src/embeddings/cohere.ts

@@ -1,7 +1,7 @@
-import { CohereClient } from "cohere-ai";
 import Bottleneck from "bottleneck";
+import { CohereClient } from "cohere-ai";
 import logger from "../logger.js";
-import { EmbeddingProvider, EmbeddingResult, RateLimitConfig } from "./base.js";
+import type { EmbeddingProvider, EmbeddingResult, RateLimitConfig } from "./base.js";
 
 interface CohereError {
   status?: number;
@@ -17,11 +17,7 @@ export class CohereEmbeddings implements EmbeddingProvider {
   private limiter: Bottleneck;
   private retryAttempts: number;
   private retryDelayMs: number;
-  private inputType:
-    | "search_document"
-    | "search_query"
-    | "classification"
-    | "clustering";
+  private inputType: "search_document" | "search_query" | "classification" | "clustering";
 
   constructor(
     apiKey: string,
@@ -32,7 +28,7 @@ export class CohereEmbeddings implements EmbeddingProvider {
       | "search_document"
       | "search_query"
       | "classification"
-      | "clustering" = "search_document",
+      | "clustering" = "search_document"
   ) {
     this.client = new CohereClient({ token: apiKey });
     this.model = model;
@@ -62,10 +58,7 @@ export class CohereEmbeddings implements EmbeddingProvider {
     });
   }
 
-  private async retryWithBackoff<T>(
-    fn: () => Promise<T>,
-    attempt: number = 0,
-  ): Promise<T> {
+  private async retryWithBackoff<T>(fn: () => Promise<T>, attempt: number = 0): Promise<T> {
     try {
       return await fn();
     } catch (error: unknown) {
@@ -76,7 +69,7 @@ export class CohereEmbeddings implements EmbeddingProvider {
         apiError?.message?.toLowerCase().includes("rate limit");
 
       if (isRateLimitError && attempt < this.retryAttempts) {
-        const delayMs = this.retryDelayMs * Math.pow(2, attempt);
+        const delayMs = this.retryDelayMs * 2 ** attempt;
         const waitTimeSeconds = (delayMs / 1000).toFixed(1);
         this.log.warn(
           {
@@ -84,7 +77,7 @@ export class CohereEmbeddings implements EmbeddingProvider {
             attempt: attempt + 1,
             maxAttempts: this.retryAttempts,
           },
-          "Rate limit reached, retrying",
+          "Rate limit reached, retrying"
         );
 
         await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -93,7 +86,7 @@ export class CohereEmbeddings implements EmbeddingProvider {
 
       if (isRateLimitError) {
         throw new Error(
-          `Cohere API rate limit exceeded after ${this.retryAttempts} retry attempts. Please try again later or reduce request frequency.`,
+          `Cohere API rate limit exceeded after ${this.retryAttempts} retry attempts. Please try again later or reduce request frequency.`
         );
       }
 
@@ -121,7 +114,7 @@ export class CohereEmbeddings implements EmbeddingProvider {
           embedding: embeddings[0],
           dimensions: this.dimensions,
         };
-      }),
+      })
     );
   }
 
@@ -146,7 +139,7 @@ export class CohereEmbeddings implements EmbeddingProvider {
           embedding,
           dimensions: this.dimensions,
         }));
-      }),
+      })
     );
   }