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

package/dist/storage/neo4j/Neo4jStorageProvider.d.ts

@@ -0,0 +1,225 @@
+import type { StorageProvider, SearchOptions } from '../StorageProvider.js';
+import type { KnowledgeGraph } from '../../KnowledgeGraphManager.js';
+import type { Relation } from '../../types/relation.js';
+import type { EntityEmbedding, SemanticSearchOptions } from '../../types/entity-embedding.js';
+import { Neo4jConnectionManager } from './Neo4jConnectionManager.js';
+import { type Neo4jConfig } from './Neo4jConfig.js';
+/**
+ * Configuration options for Neo4j storage provider
+ */
+export interface Neo4jStorageProviderOptions {
+    /**
+     * Neo4j connection configuration
+     */
+    config?: Partial<Neo4jConfig>;
+    /**
+     * Pre-configured connection manager (optional)
+     */
+    connectionManager?: Neo4jConnectionManager;
+    /**
+     * Configuration for temporal confidence decay
+     */
+    decayConfig?: {
+        /**
+         * Whether confidence decay is enabled
+         */
+        enabled: boolean;
+        /**
+         * Number of days for confidence to decay by half (default: 30)
+         */
+        halfLifeDays?: number;
+        /**
+         * Minimum confidence threshold below which confidence won't decay (default: 0.1)
+         */
+        minConfidence?: number;
+    };
+}
+/**
+ * Extended SemanticSearchOptions with additional properties needed for Neo4j
+ */
+interface Neo4jSemanticSearchOptions extends SemanticSearchOptions {
+    queryVector?: number[];
+}
+/**
+ * Knowledge graph with optional diagnostics
+ */
+interface KnowledgeGraphWithDiagnostics extends KnowledgeGraph {
+    diagnostics?: Record<string, unknown>;
+}
+/**
+ * A storage provider that uses Neo4j to store the knowledge graph
+ */
+export declare class Neo4jStorageProvider implements StorageProvider {
+    private connectionManager;
+    private schemaManager;
+    private readonly config;
+    private readonly decayConfig;
+    private vectorStore;
+    private embeddingService;
+    /**
+     * Create a new Neo4jStorageProvider
+     * @param options Configuration options
+     */
+    constructor(options?: Neo4jStorageProviderOptions);
+    /**
+     * Get the connection manager (primarily for testing)
+     */
+    getConnectionManager(): Neo4jConnectionManager;
+    /**
+     * Initialize Neo4j schema
+     */
+    private initializeSchema;
+    /**
+     * Close Neo4j connections
+     */
+    close(): Promise<void>;
+    /**
+     * Convert a Neo4j node to an entity object
+     * @param node Neo4j node properties
+     * @returns Entity object
+     */
+    private nodeToEntity;
+    /**
+     * Parse a Neo4j relationship into a relation object
+     * @param rel Relationship properties
+     * @param fromNode From node name
+     * @param toNode To node name
+     * @returns Relation object
+     */
+    /**
+     * Parse a Neo4j relationship into a relation object
+     * @param rel Relationship properties
+     * @param fromNode From node name
+     * @param toNode To node name
+     * @returns Relation object
+     */
+    private relationshipToRelation;
+    /**
+     * Load the complete knowledge graph from Neo4j
+     */
+    loadGraph(): Promise<KnowledgeGraph>;
+    /**
+     * Save a complete knowledge graph to Neo4j (warning: this will overwrite existing data)
+     * @param graph The knowledge graph to save
+     */
+    saveGraph(graph: KnowledgeGraph): Promise<void>;
+    /**
+     * Search for nodes in the graph that match the query
+     * @param query The search query string
+     * @param options Optional search parameters
+     */
+    searchNodes(query: string, options?: SearchOptions): Promise<KnowledgeGraph>;
+    /**
+     * Open specific nodes by their exact names
+     * @param names Array of node names to open
+     */
+    openNodes(names: string[]): Promise<KnowledgeGraph>;
+    /**
+     * Create new entities in the knowledge graph
+     * @param entities Array of entities to create
+     */
+    createEntities(entities: any[]): Promise<any[]>;
+    /**
+     * Create new relations between entities
+     * @param relations Array of relations to create
+     */
+    createRelations(relations: Relation[]): Promise<Relation[]>;
+    /**
+     * Add observations to entities
+     * @param observations Array of objects with entity name and observation contents
+     */
+    addObservations(observations: {
+        entityName: string;
+        contents: string[];
+    }[]): Promise<{
+        entityName: string;
+        addedObservations: string[];
+    }[]>;
+    /**
+     * Delete entities and their relations
+     * @param entityNames Array of entity names to delete
+     */
+    deleteEntities(entityNames: string[]): Promise<void>;
+    /**
+     * Delete observations from entities
+     * @param deletions Array of objects with entity name and observations to delete
+     */
+    deleteObservations(deletions: {
+        entityName: string;
+        observations: string[];
+    }[]): Promise<void>;
+    /**
+     * Delete relations from the graph
+     * @param relations Array of relations to delete
+     */
+    deleteRelations(relations: Relation[]): Promise<void>;
+    /**
+     * Get an entity by name
+     * @param entityName Name of the entity to retrieve
+     */
+    getEntity(entityName: string): Promise<any | null>;
+    /**
+     * Get a specific relation by its source, target, and type
+     * @param from Source entity name
+     * @param to Target entity name
+     * @param type Relation type
+     */
+    getRelation(from: string, to: string, type: string): Promise<Relation | null>;
+    /**
+     * Update an existing relation with new properties
+     * @param relation The relation with updated properties
+     */
+    updateRelation(relation: Relation): Promise<void>;
+    /**
+     * Get the history of all versions of an entity
+     * @param entityName The name of the entity to retrieve history for
+     */
+    getEntityHistory(entityName: string): Promise<any[]>;
+    /**
+     * Get the history of all versions of a relation
+     * @param from Source entity name
+     * @param to Target entity name
+     * @param relationType Type of the relation
+     */
+    getRelationHistory(from: string, to: string, relationType: string): Promise<any[]>;
+    /**
+     * Get the state of the knowledge graph at a specific point in time
+     * @param timestamp The timestamp to get the graph state at
+     */
+    getGraphAtTime(timestamp: number): Promise<KnowledgeGraph>;
+    /**
+     * Get the current knowledge graph with confidence decay applied to relations
+     * based on their age and the configured decay settings
+     */
+    getDecayedGraph(): Promise<KnowledgeGraph>;
+    /**
+     * Store or update the embedding vector for an entity
+     * @param entityName The name of the entity to update
+     * @param embedding The embedding data to store
+     */
+    updateEntityEmbedding(entityName: string, embedding: EntityEmbedding): Promise<void>;
+    /**
+     * Get the embedding vector for an entity
+     * @param entityName The name of the entity
+     * @returns Promise resolving to the EntityEmbedding or null if not found
+     */
+    getEntityEmbedding(entityName: string): Promise<EntityEmbedding | null>;
+    /**
+     * Find entities similar to a query vector
+     * @param queryVector The vector to compare against
+     * @param limit Maximum number of results to return
+     */
+    findSimilarEntities(queryVector: number[], limit?: number): Promise<any[]>;
+    /**
+     * Search for entities using semantic search
+     * @param query The search query text
+     * @param options Search options including semantic search parameters
+     */
+    semanticSearch(query: string, options?: SearchOptions & Neo4jSemanticSearchOptions): Promise<KnowledgeGraphWithDiagnostics>;
+    /**
+     * Direct diagnostic method to check Neo4j vector embeddings
+     * Bypasses all abstractions to query the database directly
+     */
+    diagnoseVectorSearch(): Promise<Record<string, unknown>>;
+}
+export {};