graphzep/dist/graphzep.d.ts

GraphZep: A temporal knowledge graph memory system for AI agents based on the Zep paper

import { GraphDriver, EpisodicNode, EpisodeType } from './types/index.js';
import { Node } from './core/nodes.js';
import { Edge } from './core/edges.js';
import { BaseLLMClient } from './llm/client.js';
import { BaseEmbedderClient } from './embedders/client.js';
import { ZepMemory, ZepFact, MemoryType, ZepSearchParams, ZepSearchResult } from './zep/types.js';
export interface GraphzepConfig {
    driver: GraphDriver;
    llmClient: BaseLLMClient;
    embedder: BaseEmbedderClient;
    groupId?: string;
    ensureAscii?: boolean;
    customOntologyPath?: string;
    rdfConfig?: {
        includeEmbeddings?: boolean;
        embeddingSchema?: 'base64' | 'vector-ref' | 'compressed';
    };
}
export interface AddEpisodeParams {
    content: string;
    episodeType?: EpisodeType;
    referenceId?: string;
    groupId?: string;
    metadata?: Record<string, any>;
}
export interface SearchParams {
    query: string;
    groupId?: string;
    limit?: number;
    searchType?: 'semantic' | 'keyword' | 'hybrid';
    nodeTypes?: ('entity' | 'episodic' | 'community')[];
}
export interface ExtractedEntity {
    name: string;
    entityType: string;
    summary: string;
    metadata?: Record<string, any>;
}
export interface ExtractedRelation {
    sourceName: string;
    targetName: string;
    relationName: string;
    metadata?: Record<string, any>;
}
export declare class Graphzep {
    private driver;
    private llmClient;
    private embedder;
    private defaultGroupId;
    private ensureAscii;
    private rdfMapper?;
    private ontologyManager?;
    private sparqlInterface?;
    private isRDFEnabled;
    constructor(config: GraphzepConfig);
    private initializeRDFComponents;
    addEpisode(params: AddEpisodeParams): Promise<EpisodicNode>;
    private extractEntitiesAndRelations;
    private processExtractedEntities;
    private findExistingEntity;
    private linkEpisodeToEntities;
    private processExtractedRelations;
    private findExistingRelation;
    search(params: SearchParams): Promise<Node[]>;
    getNode(uuid: string): Promise<Node | null>;
    getEdge(uuid: string): Promise<Edge | null>;
    deleteNode(uuid: string): Promise<void>;
    deleteEdge(uuid: string): Promise<void>;
    close(): Promise<void>;
    executeQuery<T = any>(query: string, params?: Record<string, any>): Promise<T>;
    createIndexes(): Promise<void>;
    clearDatabase(): Promise<void>;
    testConnection(): Promise<void>;
    /**
     * Execute SPARQL query (RDF drivers only)
     */
    sparqlQuery(query: string, options?: any): Promise<any>;
    /**
     * Add semantic fact (RDF drivers only)
     */
    addFact(fact: Omit<ZepFact, 'uuid'>): Promise<string>;
    /**
     * Search memories using Zep-specific search parameters (RDF drivers)
     */
    searchMemories(params: ZepSearchParams): Promise<ZepSearchResult[]>;
    /**
     * Get memories at a specific time (RDF drivers only)
     */
    getMemoriesAtTime(timestamp: Date, memoryTypes?: MemoryType[]): Promise<ZepMemory[]>;
    /**
     * Get facts about an entity (RDF drivers only)
     */
    getFactsAboutEntity(entityName: string, validAt?: Date): Promise<ZepFact[]>;
    /**
     * Find related entities using graph traversal (RDF drivers only)
     */
    findRelatedEntities(entityName: string, maxHops?: number, minConfidence?: number): Promise<any[]>;
    /**
     * Export current knowledge graph as RDF (works with all drivers)
     */
    exportToRDF(format?: 'turtle' | 'rdf-xml' | 'json-ld' | 'n-triples'): Promise<string>;
    /**
     * Load custom ontology (RDF drivers only)
     */
    loadOntology(ontologyPath: string): Promise<string>;
    /**
     * Generate extraction guidance for LLM using ontology
     */
    generateExtractionGuidance(content: string): Promise<string>;
    /**
     * Get ontology statistics (RDF drivers only)
     */
    getOntologyStats(): any;
    /**
     * Check if RDF support is enabled
     */
    isRDFSupported(): boolean;
    /**
     * Get available SPARQL query templates
     */
    getSPARQLTemplates(): Record<string, string>;
    private generateTraditionalExtractionPrompt;
}