@juspay/neurolink 9.1.1 → 9.3.0

package/dist/lib/rag/errors/RAGError.d.ts

@@ -0,0 +1,244 @@
+/**
+ * RAG Error Types
+ *
+ * Provides typed errors for all RAG operations including chunking,
+ * metadata extraction, embedding, vector queries, and reranking.
+ * Uses the NeuroLinkFeatureError pattern for consistency.
+ */
+import { NeuroLinkFeatureError } from "../../core/infrastructure/index.js";
+/**
+ * RAG error codes for all RAG-related operations
+ */
+export declare const RAGErrorCodes: {
+    readonly CHUNKING_ERROR: "RAG_CHUNKING_ERROR";
+    readonly CHUNKING_INVALID_CONFIG: "RAG_CHUNKING_INVALID_CONFIG";
+    readonly CHUNKING_STRATEGY_NOT_FOUND: "RAG_CHUNKING_STRATEGY_NOT_FOUND";
+    readonly CHUNKING_EMPTY_CONTENT: "RAG_CHUNKING_EMPTY_CONTENT";
+    readonly CHUNKING_SIZE_EXCEEDED: "RAG_CHUNKING_SIZE_EXCEEDED";
+    readonly METADATA_EXTRACTION_ERROR: "RAG_METADATA_EXTRACTION_ERROR";
+    readonly METADATA_EXTRACTION_TIMEOUT: "RAG_METADATA_EXTRACTION_TIMEOUT";
+    readonly METADATA_SCHEMA_INVALID: "RAG_METADATA_SCHEMA_INVALID";
+    readonly METADATA_EXTRACTOR_NOT_FOUND: "RAG_METADATA_EXTRACTOR_NOT_FOUND";
+    readonly EMBEDDING_ERROR: "RAG_EMBEDDING_ERROR";
+    readonly EMBEDDING_DIMENSION_MISMATCH: "RAG_EMBEDDING_DIMENSION_MISMATCH";
+    readonly EMBEDDING_RATE_LIMIT: "RAG_EMBEDDING_RATE_LIMIT";
+    readonly EMBEDDING_PROVIDER_ERROR: "RAG_EMBEDDING_PROVIDER_ERROR";
+    readonly VECTOR_QUERY_ERROR: "RAG_VECTOR_QUERY_ERROR";
+    readonly VECTOR_QUERY_TIMEOUT: "RAG_VECTOR_QUERY_TIMEOUT";
+    readonly VECTOR_STORE_UNAVAILABLE: "RAG_VECTOR_STORE_UNAVAILABLE";
+    readonly VECTOR_STORE_CONNECTION_ERROR: "RAG_VECTOR_STORE_CONNECTION_ERROR";
+    readonly VECTOR_INDEX_NOT_FOUND: "RAG_VECTOR_INDEX_NOT_FOUND";
+    readonly RERANKER_ERROR: "RAG_RERANKER_ERROR";
+    readonly RERANKER_NOT_FOUND: "RAG_RERANKER_NOT_FOUND";
+    readonly RERANKER_API_ERROR: "RAG_RERANKER_API_ERROR";
+    readonly GRAPH_RAG_ERROR: "RAG_GRAPH_ERROR";
+    readonly GRAPH_TRAVERSAL_ERROR: "RAG_GRAPH_TRAVERSAL_ERROR";
+    readonly GRAPH_NODE_NOT_FOUND: "RAG_GRAPH_NODE_NOT_FOUND";
+    readonly PIPELINE_ERROR: "RAG_PIPELINE_ERROR";
+    readonly PIPELINE_STAGE_FAILED: "RAG_PIPELINE_STAGE_FAILED";
+    readonly PIPELINE_PARTIAL_FAILURE: "RAG_PIPELINE_PARTIAL_FAILURE";
+    readonly CIRCUIT_BREAKER_OPEN: "RAG_CIRCUIT_BREAKER_OPEN";
+    readonly CIRCUIT_BREAKER_HALF_OPEN_LIMIT: "RAG_CIRCUIT_BREAKER_HALF_OPEN_LIMIT";
+    readonly OPERATION_TIMEOUT: "RAG_OPERATION_TIMEOUT";
+    readonly RETRY_EXHAUSTED: "RAG_RETRY_EXHAUSTED";
+    readonly INVALID_CONFIGURATION: "RAG_INVALID_CONFIGURATION";
+};
+export type RAGErrorCode = (typeof RAGErrorCodes)[keyof typeof RAGErrorCodes];
+/**
+ * RAG error factory using the infrastructure pattern
+ */
+export declare const RAGErrorFactory: {
+    codes: {
+        readonly CHUNKING_ERROR: "RAG_CHUNKING_ERROR";
+        readonly CHUNKING_INVALID_CONFIG: "RAG_CHUNKING_INVALID_CONFIG";
+        readonly CHUNKING_STRATEGY_NOT_FOUND: "RAG_CHUNKING_STRATEGY_NOT_FOUND";
+        readonly CHUNKING_EMPTY_CONTENT: "RAG_CHUNKING_EMPTY_CONTENT";
+        readonly CHUNKING_SIZE_EXCEEDED: "RAG_CHUNKING_SIZE_EXCEEDED";
+        readonly METADATA_EXTRACTION_ERROR: "RAG_METADATA_EXTRACTION_ERROR";
+        readonly METADATA_EXTRACTION_TIMEOUT: "RAG_METADATA_EXTRACTION_TIMEOUT";
+        readonly METADATA_SCHEMA_INVALID: "RAG_METADATA_SCHEMA_INVALID";
+        readonly METADATA_EXTRACTOR_NOT_FOUND: "RAG_METADATA_EXTRACTOR_NOT_FOUND";
+        readonly EMBEDDING_ERROR: "RAG_EMBEDDING_ERROR";
+        readonly EMBEDDING_DIMENSION_MISMATCH: "RAG_EMBEDDING_DIMENSION_MISMATCH";
+        readonly EMBEDDING_RATE_LIMIT: "RAG_EMBEDDING_RATE_LIMIT";
+        readonly EMBEDDING_PROVIDER_ERROR: "RAG_EMBEDDING_PROVIDER_ERROR";
+        readonly VECTOR_QUERY_ERROR: "RAG_VECTOR_QUERY_ERROR";
+        readonly VECTOR_QUERY_TIMEOUT: "RAG_VECTOR_QUERY_TIMEOUT";
+        readonly VECTOR_STORE_UNAVAILABLE: "RAG_VECTOR_STORE_UNAVAILABLE";
+        readonly VECTOR_STORE_CONNECTION_ERROR: "RAG_VECTOR_STORE_CONNECTION_ERROR";
+        readonly VECTOR_INDEX_NOT_FOUND: "RAG_VECTOR_INDEX_NOT_FOUND";
+        readonly RERANKER_ERROR: "RAG_RERANKER_ERROR";
+        readonly RERANKER_NOT_FOUND: "RAG_RERANKER_NOT_FOUND";
+        readonly RERANKER_API_ERROR: "RAG_RERANKER_API_ERROR";
+        readonly GRAPH_RAG_ERROR: "RAG_GRAPH_ERROR";
+        readonly GRAPH_TRAVERSAL_ERROR: "RAG_GRAPH_TRAVERSAL_ERROR";
+        readonly GRAPH_NODE_NOT_FOUND: "RAG_GRAPH_NODE_NOT_FOUND";
+        readonly PIPELINE_ERROR: "RAG_PIPELINE_ERROR";
+        readonly PIPELINE_STAGE_FAILED: "RAG_PIPELINE_STAGE_FAILED";
+        readonly PIPELINE_PARTIAL_FAILURE: "RAG_PIPELINE_PARTIAL_FAILURE";
+        readonly CIRCUIT_BREAKER_OPEN: "RAG_CIRCUIT_BREAKER_OPEN";
+        readonly CIRCUIT_BREAKER_HALF_OPEN_LIMIT: "RAG_CIRCUIT_BREAKER_HALF_OPEN_LIMIT";
+        readonly OPERATION_TIMEOUT: "RAG_OPERATION_TIMEOUT";
+        readonly RETRY_EXHAUSTED: "RAG_RETRY_EXHAUSTED";
+        readonly INVALID_CONFIGURATION: "RAG_INVALID_CONFIGURATION";
+    };
+    create: (code: "INVALID_CONFIGURATION" | "CHUNKING_ERROR" | "CHUNKING_INVALID_CONFIG" | "CHUNKING_STRATEGY_NOT_FOUND" | "CHUNKING_EMPTY_CONTENT" | "CHUNKING_SIZE_EXCEEDED" | "METADATA_EXTRACTION_ERROR" | "METADATA_EXTRACTION_TIMEOUT" | "METADATA_SCHEMA_INVALID" | "METADATA_EXTRACTOR_NOT_FOUND" | "EMBEDDING_ERROR" | "EMBEDDING_DIMENSION_MISMATCH" | "EMBEDDING_RATE_LIMIT" | "EMBEDDING_PROVIDER_ERROR" | "VECTOR_QUERY_ERROR" | "VECTOR_QUERY_TIMEOUT" | "VECTOR_STORE_UNAVAILABLE" | "VECTOR_STORE_CONNECTION_ERROR" | "VECTOR_INDEX_NOT_FOUND" | "RERANKER_ERROR" | "RERANKER_NOT_FOUND" | "RERANKER_API_ERROR" | "GRAPH_RAG_ERROR" | "GRAPH_TRAVERSAL_ERROR" | "GRAPH_NODE_NOT_FOUND" | "PIPELINE_ERROR" | "PIPELINE_STAGE_FAILED" | "PIPELINE_PARTIAL_FAILURE" | "CIRCUIT_BREAKER_OPEN" | "CIRCUIT_BREAKER_HALF_OPEN_LIMIT" | "OPERATION_TIMEOUT" | "RETRY_EXHAUSTED", message: string, options?: {
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+    } | undefined) => NeuroLinkFeatureError;
+};
+/**
+ * Base RAG error class extending NeuroLinkFeatureError
+ */
+export declare class RAGError extends NeuroLinkFeatureError {
+    constructor(message: string, code: RAGErrorCode, options?: {
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Chunking-specific error
+ */
+export declare class ChunkingError extends RAGError {
+    readonly strategy?: string;
+    readonly contentLength?: number;
+    constructor(message: string, options?: {
+        code?: RAGErrorCode;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+        strategy?: string;
+        contentLength?: number;
+    });
+}
+/**
+ * Metadata extraction error
+ */
+export declare class MetadataExtractionError extends RAGError {
+    readonly extractorType?: string;
+    readonly chunkId?: string;
+    constructor(message: string, options?: {
+        code?: RAGErrorCode;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+        extractorType?: string;
+        chunkId?: string;
+    });
+}
+/**
+ * Embedding error
+ */
+export declare class EmbeddingError extends RAGError {
+    readonly provider?: string;
+    readonly batchSize?: number;
+    constructor(message: string, options?: {
+        code?: RAGErrorCode;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+        provider?: string;
+        batchSize?: number;
+    });
+}
+/**
+ * Vector query error
+ */
+export declare class VectorQueryError extends RAGError {
+    readonly storeType?: string;
+    readonly queryLength?: number;
+    readonly indexName?: string;
+    constructor(message: string, options?: {
+        code?: RAGErrorCode;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+        storeType?: string;
+        queryLength?: number;
+        indexName?: string;
+    });
+}
+/**
+ * Reranker error
+ */
+export declare class RerankerError extends RAGError {
+    readonly rerankerType?: string;
+    readonly documentCount?: number;
+    constructor(message: string, options?: {
+        code?: RAGErrorCode;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+        rerankerType?: string;
+        documentCount?: number;
+    });
+}
+/**
+ * Graph RAG error
+ */
+export declare class GraphRAGError extends RAGError {
+    readonly traversalStrategy?: string;
+    readonly nodeId?: string;
+    constructor(message: string, options?: {
+        code?: RAGErrorCode;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+        traversalStrategy?: string;
+        nodeId?: string;
+    });
+}
+/**
+ * Pipeline error with partial failure support
+ */
+export declare class PipelineError extends RAGError {
+    readonly stageName?: string;
+    readonly successfulChunks?: number;
+    readonly failedChunks?: number;
+    readonly partialResults?: unknown[];
+    constructor(message: string, options?: {
+        code?: RAGErrorCode;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+        cause?: Error;
+        stageName?: string;
+        successfulChunks?: number;
+        failedChunks?: number;
+        partialResults?: unknown[];
+    });
+    /**
+     * Check if this is a partial failure (some chunks succeeded)
+     */
+    isPartialFailure(): boolean;
+    /**
+     * Get success rate as a percentage
+     */
+    getSuccessRate(): number;
+}
+/**
+ * Circuit breaker specific error for RAG operations
+ */
+export declare class RAGCircuitBreakerError extends RAGError {
+    readonly circuitName?: string;
+    readonly nextRetryTime?: Date;
+    constructor(message: string, options?: {
+        code?: RAGErrorCode;
+        details?: Record<string, unknown>;
+        circuitName?: string;
+        nextRetryTime?: Date;
+    });
+}
+/**
+ * Type guard for RAG errors
+ */
+export declare function isRAGError(error: unknown): error is RAGError;
+/**
+ * Type guard for retryable errors
+ */
+export declare function isRetryableRAGError(error: unknown): boolean;
+/**
+ * Type guard for partial failure errors
+ */
+export declare function isPartialFailure(error: unknown): error is PipelineError;

package/dist/lib/rag/errors/RAGError.js

@@ -0,0 +1,275 @@
+/**
+ * RAG Error Types
+ *
+ * Provides typed errors for all RAG operations including chunking,
+ * metadata extraction, embedding, vector queries, and reranking.
+ * Uses the NeuroLinkFeatureError pattern for consistency.
+ */
+import { NeuroLinkFeatureError, createErrorFactory, } from "../../core/infrastructure/index.js";
+/**
+ * RAG error codes for all RAG-related operations
+ */
+export const RAGErrorCodes = {
+    // Chunking errors
+    CHUNKING_ERROR: "RAG_CHUNKING_ERROR",
+    CHUNKING_INVALID_CONFIG: "RAG_CHUNKING_INVALID_CONFIG",
+    CHUNKING_STRATEGY_NOT_FOUND: "RAG_CHUNKING_STRATEGY_NOT_FOUND",
+    CHUNKING_EMPTY_CONTENT: "RAG_CHUNKING_EMPTY_CONTENT",
+    CHUNKING_SIZE_EXCEEDED: "RAG_CHUNKING_SIZE_EXCEEDED",
+    // Metadata extraction errors
+    METADATA_EXTRACTION_ERROR: "RAG_METADATA_EXTRACTION_ERROR",
+    METADATA_EXTRACTION_TIMEOUT: "RAG_METADATA_EXTRACTION_TIMEOUT",
+    METADATA_SCHEMA_INVALID: "RAG_METADATA_SCHEMA_INVALID",
+    METADATA_EXTRACTOR_NOT_FOUND: "RAG_METADATA_EXTRACTOR_NOT_FOUND",
+    // Embedding errors
+    EMBEDDING_ERROR: "RAG_EMBEDDING_ERROR",
+    EMBEDDING_DIMENSION_MISMATCH: "RAG_EMBEDDING_DIMENSION_MISMATCH",
+    EMBEDDING_RATE_LIMIT: "RAG_EMBEDDING_RATE_LIMIT",
+    EMBEDDING_PROVIDER_ERROR: "RAG_EMBEDDING_PROVIDER_ERROR",
+    // Vector store/query errors
+    VECTOR_QUERY_ERROR: "RAG_VECTOR_QUERY_ERROR",
+    VECTOR_QUERY_TIMEOUT: "RAG_VECTOR_QUERY_TIMEOUT",
+    VECTOR_STORE_UNAVAILABLE: "RAG_VECTOR_STORE_UNAVAILABLE",
+    VECTOR_STORE_CONNECTION_ERROR: "RAG_VECTOR_STORE_CONNECTION_ERROR",
+    VECTOR_INDEX_NOT_FOUND: "RAG_VECTOR_INDEX_NOT_FOUND",
+    // Reranking errors
+    RERANKER_ERROR: "RAG_RERANKER_ERROR",
+    RERANKER_NOT_FOUND: "RAG_RERANKER_NOT_FOUND",
+    RERANKER_API_ERROR: "RAG_RERANKER_API_ERROR",
+    // Graph RAG errors
+    GRAPH_RAG_ERROR: "RAG_GRAPH_ERROR",
+    GRAPH_TRAVERSAL_ERROR: "RAG_GRAPH_TRAVERSAL_ERROR",
+    GRAPH_NODE_NOT_FOUND: "RAG_GRAPH_NODE_NOT_FOUND",
+    // Pipeline errors
+    PIPELINE_ERROR: "RAG_PIPELINE_ERROR",
+    PIPELINE_STAGE_FAILED: "RAG_PIPELINE_STAGE_FAILED",
+    PIPELINE_PARTIAL_FAILURE: "RAG_PIPELINE_PARTIAL_FAILURE",
+    // Circuit breaker errors
+    CIRCUIT_BREAKER_OPEN: "RAG_CIRCUIT_BREAKER_OPEN",
+    CIRCUIT_BREAKER_HALF_OPEN_LIMIT: "RAG_CIRCUIT_BREAKER_HALF_OPEN_LIMIT",
+    // General errors
+    OPERATION_TIMEOUT: "RAG_OPERATION_TIMEOUT",
+    RETRY_EXHAUSTED: "RAG_RETRY_EXHAUSTED",
+    INVALID_CONFIGURATION: "RAG_INVALID_CONFIGURATION",
+};
+/**
+ * RAG error factory using the infrastructure pattern
+ */
+export const RAGErrorFactory = createErrorFactory("RAG", RAGErrorCodes);
+/**
+ * Base RAG error class extending NeuroLinkFeatureError
+ */
+export class RAGError extends NeuroLinkFeatureError {
+    constructor(message, code, options) {
+        super(message, code, "RAG", options);
+    }
+}
+/**
+ * Chunking-specific error
+ */
+export class ChunkingError extends RAGError {
+    strategy;
+    contentLength;
+    constructor(message, options) {
+        super(message, options?.code ?? RAGErrorCodes.CHUNKING_ERROR, {
+            retryable: options?.retryable ?? false,
+            details: {
+                ...options?.details,
+                strategy: options?.strategy,
+                contentLength: options?.contentLength,
+            },
+            cause: options?.cause,
+        });
+        this.strategy = options?.strategy;
+        this.contentLength = options?.contentLength;
+    }
+}
+/**
+ * Metadata extraction error
+ */
+export class MetadataExtractionError extends RAGError {
+    extractorType;
+    chunkId;
+    constructor(message, options) {
+        super(message, options?.code ?? RAGErrorCodes.METADATA_EXTRACTION_ERROR, {
+            retryable: options?.retryable ?? true, // LLM-based extraction is often retryable
+            details: {
+                ...options?.details,
+                extractorType: options?.extractorType,
+                chunkId: options?.chunkId,
+            },
+            cause: options?.cause,
+        });
+        this.extractorType = options?.extractorType;
+        this.chunkId = options?.chunkId;
+    }
+}
+/**
+ * Embedding error
+ */
+export class EmbeddingError extends RAGError {
+    provider;
+    batchSize;
+    constructor(message, options) {
+        super(message, options?.code ?? RAGErrorCodes.EMBEDDING_ERROR, {
+            retryable: options?.retryable ?? true, // Embedding operations are typically retryable
+            details: {
+                ...options?.details,
+                provider: options?.provider,
+                batchSize: options?.batchSize,
+            },
+            cause: options?.cause,
+        });
+        this.provider = options?.provider;
+        this.batchSize = options?.batchSize;
+    }
+}
+/**
+ * Vector query error
+ */
+export class VectorQueryError extends RAGError {
+    storeType;
+    queryLength;
+    indexName;
+    constructor(message, options) {
+        super(message, options?.code ?? RAGErrorCodes.VECTOR_QUERY_ERROR, {
+            retryable: options?.retryable ?? true,
+            details: {
+                ...options?.details,
+                storeType: options?.storeType,
+                queryLength: options?.queryLength,
+                indexName: options?.indexName,
+            },
+            cause: options?.cause,
+        });
+        this.storeType = options?.storeType;
+        this.queryLength = options?.queryLength;
+        this.indexName = options?.indexName;
+    }
+}
+/**
+ * Reranker error
+ */
+export class RerankerError extends RAGError {
+    rerankerType;
+    documentCount;
+    constructor(message, options) {
+        super(message, options?.code ?? RAGErrorCodes.RERANKER_ERROR, {
+            retryable: options?.retryable ?? true,
+            details: {
+                ...options?.details,
+                rerankerType: options?.rerankerType,
+                documentCount: options?.documentCount,
+            },
+            cause: options?.cause,
+        });
+        this.rerankerType = options?.rerankerType;
+        this.documentCount = options?.documentCount;
+    }
+}
+/**
+ * Graph RAG error
+ */
+export class GraphRAGError extends RAGError {
+    traversalStrategy;
+    nodeId;
+    constructor(message, options) {
+        super(message, options?.code ?? RAGErrorCodes.GRAPH_RAG_ERROR, {
+            retryable: options?.retryable ?? false,
+            details: {
+                ...options?.details,
+                traversalStrategy: options?.traversalStrategy,
+                nodeId: options?.nodeId,
+            },
+            cause: options?.cause,
+        });
+        this.traversalStrategy = options?.traversalStrategy;
+        this.nodeId = options?.nodeId;
+    }
+}
+/**
+ * Pipeline error with partial failure support
+ */
+export class PipelineError extends RAGError {
+    stageName;
+    successfulChunks;
+    failedChunks;
+    partialResults;
+    constructor(message, options) {
+        super(message, options?.code ?? RAGErrorCodes.PIPELINE_ERROR, {
+            retryable: options?.retryable ?? false,
+            details: {
+                ...options?.details,
+                stageName: options?.stageName,
+                successfulChunks: options?.successfulChunks,
+                failedChunks: options?.failedChunks,
+            },
+            cause: options?.cause,
+        });
+        this.stageName = options?.stageName;
+        this.successfulChunks = options?.successfulChunks;
+        this.failedChunks = options?.failedChunks;
+        this.partialResults = options?.partialResults;
+    }
+    /**
+     * Check if this is a partial failure (some chunks succeeded)
+     */
+    isPartialFailure() {
+        return (this.successfulChunks !== undefined &&
+            this.successfulChunks > 0 &&
+            this.failedChunks !== undefined &&
+            this.failedChunks > 0);
+    }
+    /**
+     * Get success rate as a percentage
+     */
+    getSuccessRate() {
+        if (this.successfulChunks === undefined ||
+            this.failedChunks === undefined) {
+            return 0;
+        }
+        const total = this.successfulChunks + this.failedChunks;
+        return total > 0 ? (this.successfulChunks / total) * 100 : 0;
+    }
+}
+/**
+ * Circuit breaker specific error for RAG operations
+ */
+export class RAGCircuitBreakerError extends RAGError {
+    circuitName;
+    nextRetryTime;
+    constructor(message, options) {
+        super(message, options?.code ?? RAGErrorCodes.CIRCUIT_BREAKER_OPEN, {
+            retryable: false, // Circuit breaker errors are not immediately retryable
+            details: {
+                ...options?.details,
+                circuitName: options?.circuitName,
+                nextRetryTime: options?.nextRetryTime?.toISOString(),
+            },
+        });
+        this.circuitName = options?.circuitName;
+        this.nextRetryTime = options?.nextRetryTime;
+    }
+}
+/**
+ * Type guard for RAG errors
+ */
+export function isRAGError(error) {
+    return error instanceof RAGError;
+}
+/**
+ * Type guard for retryable errors
+ */
+export function isRetryableRAGError(error) {
+    if (!isRAGError(error)) {
+        return false;
+    }
+    return error.retryable;
+}
+/**
+ * Type guard for partial failure errors
+ */
+export function isPartialFailure(error) {
+    return error instanceof PipelineError && error.isPartialFailure();
+}
+//# sourceMappingURL=RAGError.js.map

package/dist/lib/rag/errors/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * RAG Errors Index
+ *
+ * Exports all RAG error types and utilities.
+ */
+export { RAGErrorCodes, RAGErrorFactory, RAGError, ChunkingError, MetadataExtractionError, EmbeddingError, VectorQueryError, RerankerError, GraphRAGError, PipelineError, RAGCircuitBreakerError, isRAGError, isRetryableRAGError, isPartialFailure, type RAGErrorCode, } from "./RAGError.js";

package/dist/lib/rag/errors/index.js

@@ -0,0 +1,7 @@
+/**
+ * RAG Errors Index
+ *
+ * Exports all RAG error types and utilities.
+ */
+export { RAGErrorCodes, RAGErrorFactory, RAGError, ChunkingError, MetadataExtractionError, EmbeddingError, VectorQueryError, RerankerError, GraphRAGError, PipelineError, RAGCircuitBreakerError, isRAGError, isRetryableRAGError, isPartialFailure, } from "./RAGError.js";
+//# sourceMappingURL=index.js.map

package/dist/lib/rag/graphRag/graphRAG.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Graph RAG Implementation
+ *
+ * Knowledge graph-based retrieval augmented generation.
+ * Creates semantic relationships between document chunks and uses
+ * random walk with restart for context-aware retrieval.
+ */
+import type { GraphNode, GraphEdge, GraphChunk, GraphEmbedding, RankedNode, GraphRAGConfig, GraphQueryParams, GraphStats } from "../types.js";
+/**
+ * Graph-based Retrieval Augmented Generation
+ *
+ * Creates a knowledge graph from document chunks where nodes represent
+ * documents and edges represent semantic relationships based on
+ * embedding similarity.
+ */
+export declare class GraphRAG {
+    private nodes;
+    private edges;
+    private dimension;
+    private threshold;
+    constructor(config?: GraphRAGConfig);
+    /**
+     * Create a knowledge graph from document chunks and embeddings
+     *
+     * @param chunks - Array of document chunks
+     * @param embeddings - Corresponding embedding vectors
+     */
+    createGraph(chunks: GraphChunk[], embeddings: GraphEmbedding[]): void;
+    /**
+     * Query the graph using random walk with restart
+     *
+     * @param params - Query parameters including embedding vector
+     * @returns Ranked nodes by relevance
+     */
+    query(params: GraphQueryParams): RankedNode[];
+    /**
+     * Add a single node to the graph
+     *
+     * @param chunk - Document chunk
+     * @param embedding - Embedding vector
+     * @returns Node ID
+     */
+    addNode(chunk: GraphChunk, embedding: GraphEmbedding): string;
+    /**
+     * Remove a node and its edges from the graph
+     *
+     * @param id - Node ID to remove
+     * @returns True if node was removed
+     */
+    removeNode(id: string): boolean;
+    /**
+     * Get graph statistics
+     */
+    getStats(): GraphStats;
+    /**
+     * Get a node by ID
+     */
+    getNode(id: string): GraphNode | undefined;
+    /**
+     * Get all nodes
+     */
+    getAllNodes(): GraphNode[];
+    /**
+     * Get edges for a node
+     */
+    getEdges(nodeId: string): GraphEdge[];
+    /**
+     * Find connected components in the graph
+     */
+    findConnectedComponents(): string[][];
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    private cosineSimilarity;
+    /**
+     * Normalize probabilities to sum to 1
+     */
+    private normalizeProbs;
+    /**
+     * Weighted random choice
+     */
+    private weightedRandomChoice;
+    /**
+     * Update similarity threshold and rebuild edges
+     */
+    updateThreshold(threshold: number): void;
+    /**
+     * Serialize graph to JSON
+     */
+    toJSON(): {
+        nodes: GraphNode[];
+        edges: Array<{
+            source: string;
+            edges: GraphEdge[];
+        }>;
+        config: {
+            dimension: number;
+            threshold: number;
+        };
+    };
+    /**
+     * Load graph from JSON
+     */
+    static fromJSON(json: {
+        nodes: GraphNode[];
+        edges: Array<{
+            source: string;
+            edges: GraphEdge[];
+        }>;
+        config: {
+            dimension: number;
+            threshold: number;
+        };
+    }): GraphRAG;
+}