@henrychong-ai/mcp-neo4j-knowledge-graph 1.0.0

package/dist/types/entity-embedding.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Interface representing a vector embedding for semantic search
+ */
+export interface EntityEmbedding {
+    /**
+     * The embedding vector
+     */
+    vector: number[];
+    /**
+     * Name/version of embedding model used
+     */
+    model: string;
+    /**
+     * Timestamp when embedding was last updated
+     */
+    lastUpdated: number;
+}
+/**
+ * Search filter for advanced filtering
+ */
+export interface SearchFilter {
+    /**
+     * Field to filter on
+     */
+    field: string;
+    /**
+     * Filter operation
+     */
+    operator: 'eq' | 'ne' | 'gt' | 'lt' | 'contains';
+    /**
+     * Filter value
+     */
+    value: any;
+}
+/**
+ * Extended SearchOptions interface with semantic search capabilities
+ */
+export interface SemanticSearchOptions {
+    /**
+     * Use vector similarity for search
+     */
+    semanticSearch?: boolean;
+    /**
+     * Combine keyword and semantic search
+     */
+    hybridSearch?: boolean;
+    /**
+     * Balance between keyword vs semantic (0.0-1.0)
+     */
+    semanticWeight?: number;
+    /**
+     * Minimum similarity threshold
+     */
+    minSimilarity?: number;
+    /**
+     * Apply query expansion
+     */
+    expandQuery?: boolean;
+    /**
+     * Include facet information in results
+     */
+    includeFacets?: boolean;
+    /**
+     * Facets to include (entityType, etc.)
+     */
+    facets?: string[];
+    /**
+     * Include score explanations
+     */
+    includeExplanations?: boolean;
+    /**
+     * Additional filters
+     */
+    filters?: SearchFilter[];
+    /**
+     * Maximum number of results to return
+     */
+    limit?: number;
+    /**
+     * Number of results to skip (for pagination)
+     */
+    offset?: number;
+    /**
+     * Include document content in search (when available)
+     */
+    includeDocuments?: boolean;
+    /**
+     * Use search result caching
+     */
+    useCache?: boolean;
+}
+/**
+ * Match details for search results
+ */
+export interface SearchMatch {
+    /**
+     * Field that matched
+     */
+    field: string;
+    /**
+     * Score for this field
+     */
+    score: number;
+    /**
+     * Text match locations
+     */
+    textMatches?: Array<{
+        start: number;
+        end: number;
+        text: string;
+    }>;
+}
+/**
+ * Search result with relevance information
+ */
+export interface SearchResult {
+    /**
+     * The matching entity
+     */
+    entity: any;
+    /**
+     * Overall relevance score
+     */
+    score: number;
+    /**
+     * Match details
+     */
+    matches?: SearchMatch[];
+    /**
+     * Explanation of the scoring (if requested)
+     */
+    explanation?: any;
+}
+/**
+ * Search response with results and metadata
+ */
+export interface SearchResponse {
+    /**
+     * Search results
+     */
+    results: SearchResult[];
+    /**
+     * Total number of matching results
+     */
+    total: number;
+    /**
+     * Facet information
+     */
+    facets?: Record<string, {
+        counts: Record<string, number>;
+    }>;
+    /**
+     * Search execution time in ms
+     */
+    timeTaken: number;
+}

package/dist/types/entity-embedding.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=entity-embedding.js.map

package/dist/types/entity-embedding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-embedding.js","sourceRoot":"","sources":["../../src/types/entity-embedding.ts"],"names":[],"mappings":""}

package/dist/types/relation.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Metadata for relations providing additional context and information
+ */
+export interface RelationMetadata {
+    /**
+     * Array of relation IDs that this relation was inferred from
+     */
+    inferredFrom?: string[];
+    /**
+     * Timestamp when the relation was last accessed/retrieved
+     */
+    lastAccessed?: number;
+    /**
+     * Timestamp when the relation was created
+     */
+    createdAt: number;
+    /**
+     * Timestamp when the relation was last updated
+     */
+    updatedAt: number;
+}
+/**
+ * Represents a relationship between two entities in the knowledge graph
+ */
+export interface Relation {
+    /**
+     * The source entity name (where the relation starts)
+     */
+    from: string;
+    /**
+     * The target entity name (where the relation ends)
+     */
+    to: string;
+    /**
+     * The type of relationship between the entities
+     */
+    relationType: string;
+    /**
+     * Optional strength of the relationship (0.0-1.0)
+     * Higher values indicate stronger relationships
+     */
+    strength?: number;
+    /**
+     * Optional confidence score (0.0-1.0)
+     * Represents how confident the system is about this relationship
+     * Particularly useful for inferred relations
+     */
+    confidence?: number;
+    /**
+     * Optional metadata providing additional context about the relation
+     */
+    metadata?: RelationMetadata;
+}
+export declare namespace Relation {
+    function isRelation(obj: any): boolean;
+    function hasStrength(obj: any): boolean;
+    function hasConfidence(obj: any): boolean;
+    function hasValidMetadata(obj: any): boolean;
+}
+export declare class RelationValidator {
+    /**
+     * Validates if an object conforms to the Relation interface
+     */
+    static isRelation(obj: any): boolean;
+    /**
+     * Checks if a relation has a strength value
+     */
+    static hasStrength(obj: any): boolean;
+    /**
+     * Checks if a relation has a confidence value
+     */
+    static hasConfidence(obj: any): boolean;
+    /**
+     * Checks if a relation has valid metadata
+     */
+    static hasValidMetadata(obj: any): boolean;
+}

package/dist/types/relation.js

@@ -0,0 +1,93 @@
+// Add static methods to the Relation interface for JavaScript tests
+// This allows tests to access validation methods directly from the interface
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Relation;
+(function (Relation) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function isRelation(obj) {
+        return RelationValidator.isRelation(obj);
+    }
+    Relation.isRelation = isRelation;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function hasStrength(obj) {
+        return RelationValidator.hasStrength(obj);
+    }
+    Relation.hasStrength = hasStrength;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function hasConfidence(obj) {
+        return RelationValidator.hasConfidence(obj);
+    }
+    Relation.hasConfidence = hasConfidence;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function hasValidMetadata(obj) {
+        return RelationValidator.hasValidMetadata(obj);
+    }
+    Relation.hasValidMetadata = hasValidMetadata;
+})(Relation || (Relation = {}));
+// Concrete class for JavaScript tests
+export class RelationValidator {
+    /**
+     * Validates if an object conforms to the Relation interface
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static isRelation(obj) {
+        return (obj &&
+            typeof obj.from === 'string' &&
+            typeof obj.to === 'string' &&
+            typeof obj.relationType === 'string' &&
+            (obj.strength === undefined || typeof obj.strength === 'number') &&
+            (obj.confidence === undefined || typeof obj.confidence === 'number') &&
+            (obj.metadata === undefined || typeof obj.metadata === 'object'));
+    }
+    /**
+     * Checks if a relation has a strength value
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static hasStrength(obj) {
+        return (this.isRelation(obj) &&
+            typeof obj.strength === 'number' &&
+            obj.strength >= 0 &&
+            obj.strength <= 1);
+    }
+    /**
+     * Checks if a relation has a confidence value
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static hasConfidence(obj) {
+        return (this.isRelation(obj) &&
+            typeof obj.confidence === 'number' &&
+            obj.confidence >= 0 &&
+            obj.confidence <= 1);
+    }
+    /**
+     * Checks if a relation has valid metadata
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static hasValidMetadata(obj) {
+        if (!this.isRelation(obj) || !obj.metadata) {
+            return false;
+        }
+        const metadata = obj.metadata;
+        // Required fields
+        if (typeof metadata.createdAt !== 'number' || typeof metadata.updatedAt !== 'number') {
+            return false;
+        }
+        // Optional fields
+        if (metadata.lastAccessed !== undefined && typeof metadata.lastAccessed !== 'number') {
+            return false;
+        }
+        if (metadata.inferredFrom !== undefined) {
+            if (!Array.isArray(metadata.inferredFrom)) {
+                return false;
+            }
+            // Verify all items in inferredFrom are strings
+            for (const id of metadata.inferredFrom) {
+                if (typeof id !== 'string') {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=relation.js.map

package/dist/types/relation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation.js","sourceRoot":"","sources":["../../src/types/relation.ts"],"names":[],"mappings":"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"}

package/dist/types/temporalEntity.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Interface for entities with temporal metadata
+ */
+import type { Entity } from '../KnowledgeGraphManager.js';
+/**
+ * Represents an entity with temporal awareness capabilities
+ * Extends the base Entity interface with time-based properties
+ */
+export interface TemporalEntity extends Entity {
+    /**
+     * Unique identifier for the entity
+     */
+    id?: string;
+    /**
+     * Timestamp when the entity was created (milliseconds since epoch)
+     */
+    createdAt: number;
+    /**
+     * Timestamp when the entity was last updated (milliseconds since epoch)
+     */
+    updatedAt: number;
+    /**
+     * Optional start time for the validity period (milliseconds since epoch)
+     */
+    validFrom?: number;
+    /**
+     * Optional end time for the validity period (milliseconds since epoch)
+     */
+    validTo?: number;
+    /**
+     * Version number, incremented with each update
+     */
+    version: number;
+    /**
+     * Optional identifier of the system or user that made the change
+     */
+    changedBy?: string;
+}
+export declare namespace TemporalEntity {
+    function isTemporalEntity(obj: any): boolean;
+    function hasValidTimeRange(obj: any): boolean;
+}
+/**
+ * TemporalEntityValidator class with validation methods
+ */
+export declare class TemporalEntityValidator {
+    /**
+     * Validates if an object conforms to the TemporalEntity interface
+     */
+    static isTemporalEntity(obj: any): boolean;
+    /**
+     * Checks if an entity has a valid temporal range
+     */
+    static hasValidTimeRange(obj: any): boolean;
+}

package/dist/types/temporalEntity.js

@@ -0,0 +1,66 @@
+// Add static methods to the TemporalEntity interface for JavaScript tests
+// This allows tests to access validation methods directly from the interface
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var TemporalEntity;
+(function (TemporalEntity) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function isTemporalEntity(obj) {
+        return TemporalEntityValidator.isTemporalEntity(obj);
+    }
+    TemporalEntity.isTemporalEntity = isTemporalEntity;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function hasValidTimeRange(obj) {
+        return TemporalEntityValidator.hasValidTimeRange(obj);
+    }
+    TemporalEntity.hasValidTimeRange = hasValidTimeRange;
+})(TemporalEntity || (TemporalEntity = {}));
+/**
+ * TemporalEntityValidator class with validation methods
+ */
+export class TemporalEntityValidator {
+    /**
+     * Validates if an object conforms to the TemporalEntity interface
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static isTemporalEntity(obj) {
+        // First ensure it's a valid Entity
+        if (!obj ||
+            typeof obj.name !== 'string' ||
+            typeof obj.entityType !== 'string' ||
+            !Array.isArray(obj.observations)) {
+            return false;
+        }
+        // Then check temporal properties
+        if (typeof obj.createdAt !== 'number' ||
+            typeof obj.updatedAt !== 'number' ||
+            typeof obj.version !== 'number') {
+            return false;
+        }
+        // Optional properties type checking
+        if (obj.validFrom !== undefined && typeof obj.validFrom !== 'number') {
+            return false;
+        }
+        if (obj.validTo !== undefined && typeof obj.validTo !== 'number') {
+            return false;
+        }
+        if (obj.changedBy !== undefined && typeof obj.changedBy !== 'string') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Checks if an entity has a valid temporal range
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static hasValidTimeRange(obj) {
+        if (!this.isTemporalEntity(obj)) {
+            return false;
+        }
+        // If both are defined, validFrom must be before validTo
+        if (obj.validFrom !== undefined && obj.validTo !== undefined) {
+            return obj.validFrom <= obj.validTo;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=temporalEntity.js.map

package/dist/types/temporalEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporalEntity.js","sourceRoot":"","sources":["../../src/types/temporalEntity.ts"],"names":[],"mappings":"AA8CA,0EAA0E;AAC1E,6EAA6E;AAC7E,2DAA2D;AAC3D,MAAM,KAAW,cAAc,CAU9B;AAVD,WAAiB,cAAc;IAC7B,8DAA8D;IAC9D,SAAgB,gBAAgB,CAAC,GAAQ;QACvC,OAAO,uBAAuB,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IACvD,CAAC;IAFe,+BAAgB,mBAE/B,CAAA;IAED,8DAA8D;IAC9D,SAAgB,iBAAiB,CAAC,GAAQ;QACxC,OAAO,uBAAuB,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;IACxD,CAAC;IAFe,gCAAiB,oBAEhC,CAAA;AACH,CAAC,EAVgB,cAAc,KAAd,cAAc,QAU9B;AAED;;GAEG;AACH,MAAM,OAAO,uBAAuB;IAClC;;OAEG;IACH,8DAA8D;IAC9D,MAAM,CAAC,gBAAgB,CAAC,GAAQ;QAC9B,mCAAmC;QACnC,IACE,CAAC,GAAG;YACJ,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ;YAC5B,OAAO,GAAG,CAAC,UAAU,KAAK,QAAQ;YAClC,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,EAChC,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,iCAAiC;QACjC,IACE,OAAO,GAAG,CAAC,SAAS,KAAK,QAAQ;YACjC,OAAO,GAAG,CAAC,SAAS,KAAK,QAAQ;YACjC,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ,EAC/B,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,oCAAoC;QACpC,IAAI,GAAG,CAAC,SAAS,KAAK,SAAS,IAAI,OAAO,GAAG,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;YACrE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,GAAG,CAAC,OAAO,KAAK,SAAS,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;YACjE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,GAAG,CAAC,SAAS,KAAK,SAAS,IAAI,OAAO,GAAG,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;YACrE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,8DAA8D;IAC9D,MAAM,CAAC,iBAAiB,CAAC,GAAQ;QAC/B,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC;YAChC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,wDAAwD;QACxD,IAAI,GAAG,CAAC,SAAS,KAAK,SAAS,IAAI,GAAG,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAC7D,OAAO,GAAG,CAAC,SAAS,IAAI,GAAG,CAAC,OAAO,CAAC;QACtC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/types/temporalRelation.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Interface for relations with temporal metadata
+ */
+import { type Relation } from './relation.js';
+/**
+ * Represents a relationship with temporal awareness capabilities
+ * Extends the base Relation interface with time-based properties
+ */
+export interface TemporalRelation extends Relation {
+    /**
+     * Unique identifier for the relation
+     */
+    id?: string;
+    /**
+     * Timestamp when the relation was created (milliseconds since epoch)
+     */
+    createdAt: number;
+    /**
+     * Timestamp when the relation was last updated (milliseconds since epoch)
+     */
+    updatedAt: number;
+    /**
+     * Optional start time for the validity period (milliseconds since epoch)
+     */
+    validFrom?: number;
+    /**
+     * Optional end time for the validity period (milliseconds since epoch)
+     */
+    validTo?: number;
+    /**
+     * Version number, incremented with each update
+     */
+    version: number;
+    /**
+     * Optional identifier of the system or user that made the change
+     */
+    changedBy?: string;
+}
+export declare namespace TemporalRelation {
+    function isTemporalRelation(obj: unknown): boolean;
+    function hasValidTimeRange(obj: unknown): boolean;
+    function isCurrentlyValid(obj: unknown, now?: number): boolean;
+}
+/**
+ * TemporalRelationValidator class with validation methods
+ */
+export declare class TemporalRelationValidator {
+    /**
+     * Validates if an object conforms to the TemporalRelation interface
+     */
+    static isTemporalRelation(obj: unknown): boolean;
+    /**
+     * Checks if a relation has a valid temporal range
+     */
+    static hasValidTimeRange(obj: unknown): boolean;
+    /**
+     * Checks if a relation is currently valid based on its temporal range
+     */
+    static isCurrentlyValid(obj: unknown, now?: number): boolean;
+}

package/dist/types/temporalRelation.js

@@ -0,0 +1,89 @@
+/**
+ * Interface for relations with temporal metadata
+ */
+import { RelationValidator } from './relation.js';
+// Add static methods to the TemporalRelation interface for JavaScript tests
+// This allows tests to access validation methods directly from the interface
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var TemporalRelation;
+(function (TemporalRelation) {
+    function isTemporalRelation(obj) {
+        return TemporalRelationValidator.isTemporalRelation(obj);
+    }
+    TemporalRelation.isTemporalRelation = isTemporalRelation;
+    function hasValidTimeRange(obj) {
+        return TemporalRelationValidator.hasValidTimeRange(obj);
+    }
+    TemporalRelation.hasValidTimeRange = hasValidTimeRange;
+    function isCurrentlyValid(obj, now = Date.now()) {
+        return TemporalRelationValidator.isCurrentlyValid(obj, now);
+    }
+    TemporalRelation.isCurrentlyValid = isCurrentlyValid;
+})(TemporalRelation || (TemporalRelation = {}));
+/**
+ * TemporalRelationValidator class with validation methods
+ */
+export class TemporalRelationValidator {
+    /**
+     * Validates if an object conforms to the TemporalRelation interface
+     */
+    static isTemporalRelation(obj) {
+        // First ensure it's a valid Relation
+        if (!RelationValidator.isRelation(obj)) {
+            return false;
+        }
+        // Use type assertion after validation
+        const temporalObj = obj;
+        // Then check temporal properties
+        if (typeof temporalObj.createdAt !== 'number' ||
+            typeof temporalObj.updatedAt !== 'number' ||
+            typeof temporalObj.version !== 'number') {
+            return false;
+        }
+        // Optional properties type checking
+        if (temporalObj.validFrom !== undefined && typeof temporalObj.validFrom !== 'number') {
+            return false;
+        }
+        if (temporalObj.validTo !== undefined && typeof temporalObj.validTo !== 'number') {
+            return false;
+        }
+        if (temporalObj.changedBy !== undefined && typeof temporalObj.changedBy !== 'string') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Checks if a relation has a valid temporal range
+     */
+    static hasValidTimeRange(obj) {
+        if (!this.isTemporalRelation(obj)) {
+            return false;
+        }
+        // Use type assertion after validation
+        const temporalObj = obj;
+        // If both are defined, validFrom must be before validTo
+        if (temporalObj.validFrom !== undefined && temporalObj.validTo !== undefined) {
+            return temporalObj.validFrom <= temporalObj.validTo;
+        }
+        return true;
+    }
+    /**
+     * Checks if a relation is currently valid based on its temporal range
+     */
+    static isCurrentlyValid(obj, now = Date.now()) {
+        if (!this.isTemporalRelation(obj)) {
+            return false;
+        }
+        // Use type assertion after validation
+        const temporalObj = obj;
+        // Check if current time is within validity period
+        if (temporalObj.validFrom !== undefined && now < temporalObj.validFrom) {
+            return false; // Before valid period
+        }
+        if (temporalObj.validTo !== undefined && now > temporalObj.validTo) {
+            return false; // After valid period
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=temporalRelation.js.map

package/dist/types/temporalRelation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporalRelation.js","sourceRoot":"","sources":["../../src/types/temporalRelation.ts"],"names":[],"mappings":"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"}

package/dist/types/vector-index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Interface for optimized vector index operations
+ */
+export interface VectorIndex {
+    /**
+     * Add a vector to the index
+     * @param id Unique identifier for the vector
+     * @param vector The vector to add
+     */
+    addVector(id: string, vector: number[]): Promise<void>;
+    /**
+     * Search for nearest neighbors
+     * @param vector The query vector
+     * @param limit Maximum number of results to return
+     * @returns Promise resolving to array of results with id and similarity score
+     */
+    search(vector: number[], limit: number): Promise<{
+        id: string;
+        score: number;
+    }[]>;
+    /**
+     * Remove a vector from the index
+     * @param id ID of the vector to remove
+     */
+    removeVector(id: string): Promise<void>;
+    /**
+     * Get index statistics
+     * @returns Object with index statistics
+     */
+    getStats(): {
+        totalVectors: number;
+        dimensionality: number;
+        indexType: string;
+        memoryUsage: number;
+        approximateSearch?: boolean;
+        quantized?: boolean;
+    };
+    /**
+     * Enable or disable approximate nearest neighbor search
+     * @param enable Whether to enable approximate search
+     */
+    setApproximateSearch(enable: boolean): void;
+    /**
+     * Enable or disable vector quantization for memory optimization
+     * @param enable Whether to enable quantization
+     */
+    setQuantization(enable: boolean): void;
+}

package/dist/types/vector-index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vector-index.js.map

package/dist/types/vector-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-index.js","sourceRoot":"","sources":["../../src/types/vector-index.ts"],"names":[],"mappings":""}