@mhalder/qdrant-mcp-server 1.5.0 → 2.0.0

package/src/qdrant/client.test.ts

@@ -2,70 +2,112 @@ import { QdrantClient } from "@qdrant/js-client-rest";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { QdrantManager } from "./client.js";
 
+const mockClient = {
+  createCollection: vi.fn().mockResolvedValue({}),
+  getCollection: vi.fn().mockResolvedValue({}),
+  getCollections: vi.fn().mockResolvedValue({ collections: [] }),
+  deleteCollection: vi.fn().mockResolvedValue({}),
+  upsert: vi.fn().mockResolvedValue({}),
+  search: vi.fn().mockResolvedValue([]),
+  retrieve: vi.fn().mockResolvedValue([]),
+  delete: vi.fn().mockResolvedValue({}),
+  query: vi.fn().mockResolvedValue({ points: [] }),
+};
+
 vi.mock("@qdrant/js-client-rest", () => ({
-  QdrantClient: vi.fn(),
+  QdrantClient: vi.fn().mockImplementation(function () {
+    return mockClient;
+  }),
 }));
 
 describe("QdrantManager", () => {
   let manager: QdrantManager;
-  let mockClient: any;
 
   beforeEach(() => {
-    mockClient = {
-      createCollection: vi.fn(),
-      getCollection: vi.fn(),
-      getCollections: vi.fn(),
-      deleteCollection: vi.fn(),
-      upsert: vi.fn(),
-      search: vi.fn(),
-      retrieve: vi.fn(),
-      delete: vi.fn(),
-    };
-
-    vi.mocked(QdrantClient).mockImplementation(() => mockClient as any);
-
+    // Reset mocks and restore default implementations
+    mockClient.createCollection.mockReset().mockResolvedValue({});
+    mockClient.getCollection.mockReset().mockResolvedValue({});
+    mockClient.getCollections
+      .mockReset()
+      .mockResolvedValue({ collections: [] });
+    mockClient.deleteCollection.mockReset().mockResolvedValue({});
+    mockClient.upsert.mockReset().mockResolvedValue({});
+    mockClient.search.mockReset().mockResolvedValue([]);
+    mockClient.retrieve.mockReset().mockResolvedValue([]);
+    mockClient.delete.mockReset().mockResolvedValue({});
+    mockClient.query.mockReset().mockResolvedValue({ points: [] });
+    vi.mocked(QdrantClient).mockClear();
     manager = new QdrantManager("http://localhost:6333");
   });
 
+  describe("constructor", () => {
+    it("should pass apiKey to QdrantClient when provided", () => {
+      new QdrantManager("http://localhost:6333", "test-api-key");
+
+      expect(QdrantClient).toHaveBeenCalledWith({
+        url: "http://localhost:6333",
+        apiKey: "test-api-key",
+      });
+    });
+
+    it("should work without apiKey for unauthenticated instances", () => {
+      new QdrantManager("http://localhost:6333");
+
+      expect(QdrantClient).toHaveBeenCalledWith({
+        url: "http://localhost:6333",
+        apiKey: undefined,
+      });
+    });
+  });
+
   describe("createCollection", () => {
     it("should create a collection with default distance metric", async () => {
       await manager.createCollection("test-collection", 1536);
 
-      expect(mockClient.createCollection).toHaveBeenCalledWith("test-collection", {
-        vectors: {
-          size: 1536,
-          distance: "Cosine",
+      expect(mockClient.createCollection).toHaveBeenCalledWith(
+        "test-collection",
+        {
+          vectors: {
+            size: 1536,
+            distance: "Cosine",
+          },
         },
-      });
+      );
     });
 
     it("should create a collection with custom distance metric", async () => {
       await manager.createCollection("test-collection", 1536, "Euclid");
 
-      expect(mockClient.createCollection).toHaveBeenCalledWith("test-collection", {
-        vectors: {
-          size: 1536,
-          distance: "Euclid",
+      expect(mockClient.createCollection).toHaveBeenCalledWith(
+        "test-collection",
+        {
+          vectors: {
+            size: 1536,
+            distance: "Euclid",
+          },
         },
-      });
+      );
     });
 
     it("should create a hybrid collection with sparse vectors enabled", async () => {
       await manager.createCollection("test-collection", 1536, "Cosine", true);
 
-      expect(mockClient.createCollection).toHaveBeenCalledWith("test-collection", {
-        vectors: {
-          dense: {
-            size: 1536,
-            distance: "Cosine",
+      expect(mockClient.createCollection).toHaveBeenCalledWith(
+        "test-collection",
+        {
+          vectors: {
+            dense: {
+              size: 1536,
+              distance: "Cosine",
+            },
           },
-        },
-        sparse_vectors: {
-          text: {
-            modifier: "idf",
+          sparse_vectors: {
+            text: {
+              modifier: "idf",
+            },
           },
         },
-      });
+      );
     });
   });
 
@@ -91,12 +133,20 @@ describe("QdrantManager", () => {
   describe("listCollections", () => {
     it("should return list of collection names", async () => {
       mockClient.getCollections.mockResolvedValue({
-        collections: [{ name: "collection1" }, { name: "collection2" }, { name: "collection3" }],
+        collections: [
+          { name: "collection1" },
+          { name: "collection2" },
+          { name: "collection3" },
+        ],
       });
 
       const collections = await manager.listCollections();
 
-      expect(collections).toEqual(["collection1", "collection2", "collection3"]);
+      expect(collections).toEqual([
+        "collection1",
+        "collection2",
+        "collection3",
+      ]);
     });
 
     it("should return empty array when no collections exist", async () => {
@@ -191,7 +241,9 @@ describe("QdrantManager", () => {
     it("should delete a collection", async () => {
       await manager.deleteCollection("test-collection");
 
-      expect(mockClient.deleteCollection).toHaveBeenCalledWith("test-collection");
+      expect(mockClient.deleteCollection).toHaveBeenCalledWith(
+        "test-collection",
+      );
     });
   });
 
@@ -240,7 +292,7 @@ describe("QdrantManager", () => {
       const normalizedId = calls[0][1].points[0].id;
       // Check that it's a valid UUID format
       expect(normalizedId).toMatch(
-        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
       );
       // Ensure it's not the original ID
       expect(normalizedId).not.toBe("my-custom-id");
@@ -248,7 +300,9 @@ describe("QdrantManager", () => {
 
     it("should preserve UUID format IDs without modification", async () => {
       const uuidId = "123e4567-e89b-12d3-a456-426614174000";
-      const points = [{ id: uuidId, vector: [0.1, 0.2, 0.3], payload: { text: "test" } }];
+      const points = [
+        { id: uuidId, vector: [0.1, 0.2, 0.3], payload: { text: "test" } },
+      ];
 
       await manager.addPoints("test-collection", points);
 
@@ -276,8 +330,10 @@ describe("QdrantManager", () => {
         },
       });
 
-      await expect(manager.addPoints("test-collection", points)).rejects.toThrow(
-        'Failed to add points to collection "test-collection": Vector dimension mismatch'
+      await expect(
+        manager.addPoints("test-collection", points),
+      ).rejects.toThrow(
+        'Failed to add points to collection "test-collection": Vector dimension mismatch',
       );
     });
 
@@ -286,8 +342,10 @@ describe("QdrantManager", () => {
 
       mockClient.upsert.mockRejectedValue(new Error("Network error"));
 
-      await expect(manager.addPoints("test-collection", points)).rejects.toThrow(
-        'Failed to add points to collection "test-collection": Network error'
+      await expect(
+        manager.addPoints("test-collection", points),
+      ).rejects.toThrow(
+        'Failed to add points to collection "test-collection": Network error',
       );
     });
 
@@ -296,8 +354,10 @@ describe("QdrantManager", () => {
 
       mockClient.upsert.mockRejectedValue("Unknown error");
 
-      await expect(manager.addPoints("test-collection", points)).rejects.toThrow(
-        'Failed to add points to collection "test-collection": Unknown error'
+      await expect(
+        manager.addPoints("test-collection", points),
+      ).rejects.toThrow(
+        'Failed to add points to collection "test-collection": Unknown error',
       );
     });
   });
@@ -325,7 +385,11 @@ describe("QdrantManager", () => {
         { id: 2, score: 0.85, payload: { text: "result2" } },
       ]);
 
-      const results = await manager.search("test-collection", [0.1, 0.2, 0.3], 5);
+      const results = await manager.search(
+        "test-collection",
+        [0.1, 0.2, 0.3],
+        5,
+      );
 
       expect(results).toEqual([
         { id: 1, score: 0.95, payload: { text: "result1" } },
@@ -424,7 +488,9 @@ describe("QdrantManager", () => {
     });
 
     it("should handle null payload in results", async () => {
-      mockClient.search.mockResolvedValue([{ id: 1, score: 0.95, payload: null }]);
+      mockClient.search.mockResolvedValue([
+        { id: 1, score: 0.95, payload: null },
+      ]);
 
       const results = await manager.search("test-collection", [0.1, 0.2, 0.3]);
 
@@ -453,11 +519,19 @@ describe("QdrantManager", () => {
         },
       });
 
-      mockClient.search.mockResolvedValue([{ id: 1, score: 0.95, payload: { text: "result1" } }]);
+      mockClient.search.mockResolvedValue([
+        { id: 1, score: 0.95, payload: { text: "result1" } },
+      ]);
 
-      const results = await manager.search("hybrid-collection", [0.1, 0.2, 0.3], 5);
+      const results = await manager.search(
+        "hybrid-collection",
+        [0.1, 0.2, 0.3],
+        5,
+      );
 
-      expect(results).toEqual([{ id: 1, score: 0.95, payload: { text: "result1" } }]);
+      expect(results).toEqual([
+        { id: 1, score: 0.95, payload: { text: "result1" } },
+      ]);
       expect(mockClient.search).toHaveBeenCalledWith("hybrid-collection", {
         vector: { name: "dense", vector: [0.1, 0.2, 0.3] },
         limit: 5,
@@ -480,11 +554,19 @@ describe("QdrantManager", () => {
         },
       });
 
-      mockClient.search.mockResolvedValue([{ id: 1, score: 0.95, payload: { text: "result1" } }]);
+      mockClient.search.mockResolvedValue([
+        { id: 1, score: 0.95, payload: { text: "result1" } },
+      ]);
 
-      const results = await manager.search("standard-collection", [0.1, 0.2, 0.3], 5);
+      const results = await manager.search(
+        "standard-collection",
+        [0.1, 0.2, 0.3],
+        5,
+      );
 
-      expect(results).toEqual([{ id: 1, score: 0.95, payload: { text: "result1" } }]);
+      expect(results).toEqual([
+        { id: 1, score: 0.95, payload: { text: "result1" } },
+      ]);
       expect(mockClient.search).toHaveBeenCalledWith("standard-collection", {
         vector: [0.1, 0.2, 0.3],
         limit: 5,
@@ -495,7 +577,9 @@ describe("QdrantManager", () => {
 
   describe("getPoint", () => {
     it("should retrieve a point by id", async () => {
-      mockClient.retrieve.mockResolvedValue([{ id: 1, payload: { text: "test" } }]);
+      mockClient.retrieve.mockResolvedValue([
+        { id: 1, payload: { text: "test" } },
+      ]);
 
       const point = await manager.getPoint("test-collection", 1);
 
@@ -566,7 +650,11 @@ describe("QdrantManager", () => {
         ],
       });
 
-      const results = await manager.hybridSearch("test-collection", denseVector, sparseVector);
+      const results = await manager.hybridSearch(
+        "test-collection",
+        denseVector,
+        sparseVector,
+      );
 
       expect(results).toEqual([
         { id: 1, score: 0.95, payload: { text: "result1" } },
@@ -602,7 +690,12 @@ describe("QdrantManager", () => {
 
       mockClient.query.mockResolvedValue({ points: [] });
 
-      await manager.hybridSearch("test-collection", denseVector, sparseVector, 10);
+      await manager.hybridSearch(
+        "test-collection",
+        denseVector,
+        sparseVector,
+        10,
+      );
 
       expect(mockClient.query).toHaveBeenCalledWith(
         "test-collection",
@@ -611,7 +704,7 @@ describe("QdrantManager", () => {
             expect.objectContaining({ limit: 40 }), // 10 * 4
           ]),
           limit: 10,
-        })
+        }),
       );
     });
 
@@ -622,7 +715,13 @@ describe("QdrantManager", () => {
 
       mockClient.query.mockResolvedValue({ points: [] });
 
-      await manager.hybridSearch("test-collection", denseVector, sparseVector, 5, filter);
+      await manager.hybridSearch(
+        "test-collection",
+        denseVector,
+        sparseVector,
+        5,
+        filter,
+      );
 
       expect(mockClient.query).toHaveBeenCalledWith("test-collection", {
         prefetch: [
@@ -664,7 +763,13 @@ describe("QdrantManager", () => {
 
       mockClient.query.mockResolvedValue({ points: [] });
 
-      await manager.hybridSearch("test-collection", denseVector, sparseVector, 5, filter);
+      await manager.hybridSearch(
+        "test-collection",
+        denseVector,
+        sparseVector,
+        5,
+        filter,
+      );
 
       const call = mockClient.query.mock.calls[0][1];
       expect(call.prefetch[0].filter).toEqual(filter);
@@ -674,11 +779,19 @@ describe("QdrantManager", () => {
     it("should handle Qdrant format filter (should)", async () => {
       const denseVector = [0.1, 0.2, 0.3];
       const sparseVector = { indices: [1], values: [0.5] };
-      const filter = { should: [{ key: "tag", match: { value: "important" } }] };
+      const filter = {
+        should: [{ key: "tag", match: { value: "important" } }],
+      };
 
       mockClient.query.mockResolvedValue({ points: [] });
 
-      await manager.hybridSearch("test-collection", denseVector, sparseVector, 5, filter);
+      await manager.hybridSearch(
+        "test-collection",
+        denseVector,
+        sparseVector,
+        5,
+        filter,
+      );
 
       const call = mockClient.query.mock.calls[0][1];
       expect(call.prefetch[0].filter).toEqual(filter);
@@ -688,11 +801,19 @@ describe("QdrantManager", () => {
     it("should handle Qdrant format filter (must_not)", async () => {
       const denseVector = [0.1, 0.2, 0.3];
       const sparseVector = { indices: [1], values: [0.5] };
-      const filter = { must_not: [{ key: "status", match: { value: "deleted" } }] };
+      const filter = {
+        must_not: [{ key: "status", match: { value: "deleted" } }],
+      };
 
       mockClient.query.mockResolvedValue({ points: [] });
 
-      await manager.hybridSearch("test-collection", denseVector, sparseVector, 5, filter);
+      await manager.hybridSearch(
+        "test-collection",
+        denseVector,
+        sparseVector,
+        5,
+        filter,
+      );
 
       const call = mockClient.query.mock.calls[0][1];
       expect(call.prefetch[0].filter).toEqual(filter);
@@ -705,7 +826,13 @@ describe("QdrantManager", () => {
 
       mockClient.query.mockResolvedValue({ points: [] });
 
-      await manager.hybridSearch("test-collection", denseVector, sparseVector, 5, {});
+      await manager.hybridSearch(
+        "test-collection",
+        denseVector,
+        sparseVector,
+        5,
+        {},
+      );
 
       const call = mockClient.query.mock.calls[0][1];
       expect(call.prefetch[0].filter).toBeUndefined();
@@ -720,7 +847,11 @@ describe("QdrantManager", () => {
         points: [{ id: 1, score: 0.95, payload: null }],
       });
 
-      const results = await manager.hybridSearch("test-collection", denseVector, sparseVector);
+      const results = await manager.hybridSearch(
+        "test-collection",
+        denseVector,
+        sparseVector,
+      );
 
       expect(results).toEqual([{ id: 1, score: 0.95, payload: undefined }]);
     });
@@ -738,9 +869,9 @@ describe("QdrantManager", () => {
       });
 
       await expect(
-        manager.hybridSearch("test-collection", denseVector, sparseVector)
+        manager.hybridSearch("test-collection", denseVector, sparseVector),
       ).rejects.toThrow(
-        'Hybrid search failed on collection "test-collection": Named vector not found'
+        'Hybrid search failed on collection "test-collection": Named vector not found',
       );
     });
 
@@ -751,8 +882,10 @@ describe("QdrantManager", () => {
       mockClient.query.mockRejectedValue(new Error("Network timeout"));
 
       await expect(
-        manager.hybridSearch("test-collection", denseVector, sparseVector)
-      ).rejects.toThrow('Hybrid search failed on collection "test-collection": Network timeout');
+        manager.hybridSearch("test-collection", denseVector, sparseVector),
+      ).rejects.toThrow(
+        'Hybrid search failed on collection "test-collection": Network timeout',
+      );
     });
 
     it("should throw error with String(error) fallback", async () => {
@@ -762,8 +895,10 @@ describe("QdrantManager", () => {
       mockClient.query.mockRejectedValue("Unknown error");
 
       await expect(
-        manager.hybridSearch("test-collection", denseVector, sparseVector)
-      ).rejects.toThrow('Hybrid search failed on collection "test-collection": Unknown error');
+        manager.hybridSearch("test-collection", denseVector, sparseVector),
+      ).rejects.toThrow(
+        'Hybrid search failed on collection "test-collection": Unknown error',
+      );
     });
   });
 
@@ -854,7 +989,7 @@ describe("QdrantManager", () => {
       const normalizedId = calls[0][1].points[0].id;
       // Check that it's a valid UUID format
       expect(normalizedId).toMatch(
-        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
       );
       expect(normalizedId).not.toBe("my-doc-id");
     });
@@ -904,8 +1039,10 @@ describe("QdrantManager", () => {
         },
       });
 
-      await expect(manager.addPointsWithSparse("test-collection", points)).rejects.toThrow(
-        'Failed to add points with sparse vectors to collection "test-collection": Sparse vector not configured'
+      await expect(
+        manager.addPointsWithSparse("test-collection", points),
+      ).rejects.toThrow(
+        'Failed to add points with sparse vectors to collection "test-collection": Sparse vector not configured',
       );
     });
 
@@ -920,8 +1057,10 @@ describe("QdrantManager", () => {
 
       mockClient.upsert.mockRejectedValue(new Error("Connection refused"));
 
-      await expect(manager.addPointsWithSparse("test-collection", points)).rejects.toThrow(
-        'Failed to add points with sparse vectors to collection "test-collection": Connection refused'
+      await expect(
+        manager.addPointsWithSparse("test-collection", points),
+      ).rejects.toThrow(
+        'Failed to add points with sparse vectors to collection "test-collection": Connection refused',
       );
     });
 
@@ -936,8 +1075,10 @@ describe("QdrantManager", () => {
 
       mockClient.upsert.mockRejectedValue("Unexpected error");
 
-      await expect(manager.addPointsWithSparse("test-collection", points)).rejects.toThrow(
-        'Failed to add points with sparse vectors to collection "test-collection": Unexpected error'
+      await expect(
+        manager.addPointsWithSparse("test-collection", points),
+      ).rejects.toThrow(
+        'Failed to add points with sparse vectors to collection "test-collection": Unexpected error',
       );
     });
   });

package/src/qdrant/client.ts

@@ -23,8 +23,8 @@ export interface SparseVector {
 export class QdrantManager {
   private client: QdrantClient;
 
-  constructor(url: string = "http://localhost:6333") {
-    this.client = new QdrantClient({ url });
+  constructor(url: string = "http://localhost:6333", apiKey?: string) {
+    this.client = new QdrantClient({ url, apiKey });
   }
 
   /**
@@ -37,7 +37,8 @@ export class QdrantManager {
     }
 
     // Check if already a valid UUID (8-4-4-4-12 format)
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const uuidRegex =
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     if (uuidRegex.test(id)) {
       return id;
     }
@@ -51,7 +52,7 @@ export class QdrantManager {
     name: string,
     vectorSize: number,
     distance: "Cosine" | "Euclid" | "Dot" = "Cosine",
-    enableSparse: boolean = false
+    enableSparse: boolean = false,
   ): Promise<void> {
     const config: any = {};
 
@@ -139,7 +140,7 @@ export class QdrantManager {
       id: string | number;
       vector: number[];
       payload?: Record<string, any>;
-    }>
+    }>,
   ): Promise<void> {
     try {
       // Normalize all IDs to ensure string IDs are in UUID format
@@ -153,8 +154,11 @@ export class QdrantManager {
         points: normalizedPoints,
       });
     } catch (error: any) {
-      const errorMessage = error?.data?.status?.error || error?.message || String(error);
-      throw new Error(`Failed to add points to collection "${collectionName}": ${errorMessage}`);
+      const errorMessage =
+        error?.data?.status?.error || error?.message || String(error);
+      throw new Error(
+        `Failed to add points to collection "${collectionName}": ${errorMessage}`,
+      );
     }
   }
 
@@ -162,7 +166,7 @@ export class QdrantManager {
     collectionName: string,
     vector: number[],
     limit: number = 5,
-    filter?: Record<string, any>
+    filter?: Record<string, any>,
   ): Promise<SearchResult[]> {
     // Convert simple key-value filter to Qdrant filter format
     // Accepts either:
@@ -202,7 +206,7 @@ export class QdrantManager {
 
   async getPoint(
     collectionName: string,
-    id: string | number
+    id: string | number,
   ): Promise<{ id: string | number; payload?: Record<string, any> } | null> {
     try {
       const normalizedId = this.normalizeId(id);
@@ -223,7 +227,10 @@ export class QdrantManager {
     }
   }
 
-  async deletePoints(collectionName: string, ids: (string | number)[]): Promise<void> {
+  async deletePoints(
+    collectionName: string,
+    ids: (string | number)[],
+  ): Promise<void> {
     // Normalize IDs to ensure string IDs are in UUID format
     const normalizedIds = ids.map((id) => this.normalizeId(id));
 
@@ -243,7 +250,7 @@ export class QdrantManager {
     sparseVector: SparseVector,
     limit: number = 5,
     filter?: Record<string, any>,
-    _semanticWeight: number = 0.7
+    _semanticWeight: number = 0.7,
   ): Promise<SearchResult[]> {
     // Convert simple key-value filter to Qdrant filter format
     let qdrantFilter;
@@ -293,8 +300,11 @@ export class QdrantManager {
         payload: result.payload || undefined,
       }));
     } catch (error: any) {
-      const errorMessage = error?.data?.status?.error || error?.message || String(error);
-      throw new Error(`Hybrid search failed on collection "${collectionName}": ${errorMessage}`);
+      const errorMessage =
+        error?.data?.status?.error || error?.message || String(error);
+      throw new Error(
+        `Hybrid search failed on collection "${collectionName}": ${errorMessage}`,
+      );
     }
   }
 
@@ -308,7 +318,7 @@ export class QdrantManager {
       vector: number[];
       sparseVector: SparseVector;
       payload?: Record<string, any>;
-    }>
+    }>,
   ): Promise<void> {
     try {
       // Normalize all IDs to ensure string IDs are in UUID format
@@ -326,9 +336,10 @@ export class QdrantManager {
         points: normalizedPoints,
       });
     } catch (error: any) {
-      const errorMessage = error?.data?.status?.error || error?.message || String(error);
+      const errorMessage =
+        error?.data?.status?.error || error?.message || String(error);
       throw new Error(
-        `Failed to add points with sparse vectors to collection "${collectionName}": ${errorMessage}`
+        `Failed to add points with sparse vectors to collection "${collectionName}": ${errorMessage}`,
       );
     }
   }

package/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
+    "target": "ES2023",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
     "outDir": "./build",
     "rootDir": "./src",
     "strict": true,
@@ -12,7 +12,8 @@
     "resolveJsonModule": true,
     "declaration": true,
     "declarationMap": true,
-    "sourceMap": true
+    "sourceMap": true,
+    "noImplicitOverride": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "build"]