zrald/dist/operators/base-operator.d.ts

Advanced Graph RAG MCP Server with sophisticated graph structures, operators, and agentic capabilities for AI agents

import { Node, Relationship, Chunk, OperatorResult } from '../types/graph.js';
import { GraphDatabase } from '../core/graph-database.js';
import { VectorStore } from '../core/vector-store.js';
export declare abstract class BaseOperator {
    protected graphDb: GraphDatabase;
    protected vectorStore: VectorStore;
    protected name: string;
    protected type: 'node' | 'relationship' | 'chunk' | 'subgraph';
    constructor(name: string, type: 'node' | 'relationship' | 'chunk' | 'subgraph', graphDb: GraphDatabase, vectorStore: VectorStore);
    abstract execute(config: any): Promise<OperatorResult>;
    protected validateConfig(config: any, schema: any): Promise<any>;
    protected createResult(nodes?: Node[], relationships?: Relationship[], chunks?: Chunk[], scores?: Record<string, number>, metadata?: Record<string, any>): OperatorResult;
    protected measureExecutionTime<T>(operation: () => Promise<T>): Promise<{
        result: T;
        executionTime: number;
    }>;
    protected normalizeScores(scores: Record<string, number>): Record<string, number>;
    protected combineScores(scores1: Record<string, number>, scores2: Record<string, number>, weight1?: number, weight2?: number): Record<string, number>;
    protected getConnectedNodes(nodeIds: string[], direction?: 'incoming' | 'outgoing' | 'both'): Promise<Node[]>;
    protected filterNodesByType(nodes: Node[], types: string[]): Promise<Node[]>;
    protected enrichWithEmbeddings(nodes: Node[]): Promise<Node[]>;
    protected calculateRelevanceScore(node: Node, queryEmbedding?: number[], contextNodes?: Node[]): number;
    protected logExecution(config: any, result: OperatorResult, executionTime: number): Promise<void>;
    private hashConfig;
    private calculateAverageScore;
    protected batchProcess<T, R>(items: T[], processor: (item: T) => Promise<R>, batchSize?: number): Promise<R[]>;
    protected retryOperation<T>(operation: () => Promise<T>, maxRetries?: number, delay?: number): Promise<T>;
    protected preProcess(config: any): Promise<any>;
    protected postProcess(result: OperatorResult): Promise<OperatorResult>;
    run(config: any): Promise<OperatorResult>;
}
//# sourceMappingURL=base-operator.d.ts.map