@juspay/neurolink 9.1.1 → 9.3.0

package/dist/lib/rag/graphRag/graphRAG.js

@@ -0,0 +1,385 @@
+/**
+ * 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 { randomUUID } from "crypto";
+import { logger } from "../../utils/logger.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 class GraphRAG {
+    nodes = new Map();
+    edges = new Map();
+    dimension;
+    threshold;
+    constructor(config) {
+        this.dimension = config?.dimension ?? 1536;
+        this.threshold = config?.threshold ?? 0.7;
+    }
+    /**
+     * Create a knowledge graph from document chunks and embeddings
+     *
+     * @param chunks - Array of document chunks
+     * @param embeddings - Corresponding embedding vectors
+     */
+    createGraph(chunks, embeddings) {
+        if (chunks.length !== embeddings.length) {
+            throw new Error("Chunks and embeddings arrays must have the same length");
+        }
+        // Clear existing graph
+        this.nodes.clear();
+        this.edges.clear();
+        // Create nodes
+        const nodeIds = [];
+        for (let i = 0; i < chunks.length; i++) {
+            const id = randomUUID();
+            nodeIds.push(id);
+            this.nodes.set(id, {
+                id,
+                content: chunks[i].text,
+                metadata: chunks[i].metadata || {},
+                embedding: embeddings[i].vector,
+            });
+        }
+        // Create edges based on semantic similarity
+        for (let i = 0; i < nodeIds.length; i++) {
+            const edges = [];
+            const nodeA = this.nodes.get(nodeIds[i]);
+            for (let j = 0; j < nodeIds.length; j++) {
+                if (i === j) {
+                    continue;
+                }
+                const nodeB = this.nodes.get(nodeIds[j]);
+                const similarity = this.cosineSimilarity(nodeA.embedding, nodeB.embedding);
+                if (similarity >= this.threshold) {
+                    edges.push({
+                        source: nodeIds[i],
+                        target: nodeIds[j],
+                        weight: similarity,
+                        type: "semantic",
+                    });
+                }
+            }
+            // Sort edges by weight descending
+            edges.sort((a, b) => b.weight - a.weight);
+            this.edges.set(nodeIds[i], edges);
+        }
+        logger.info("[GraphRAG] Graph created", {
+            nodes: this.nodes.size,
+            totalEdges: Array.from(this.edges.values()).reduce((sum, e) => sum + e.length, 0),
+            threshold: this.threshold,
+        });
+    }
+    /**
+     * Query the graph using random walk with restart
+     *
+     * @param params - Query parameters including embedding vector
+     * @returns Ranked nodes by relevance
+     */
+    query(params) {
+        const { query, topK = 10, randomWalkSteps = 100, restartProb = 0.15, } = params;
+        if (this.nodes.size === 0) {
+            return [];
+        }
+        // Calculate initial similarities to query
+        const similarities = new Map();
+        for (const [id, node] of this.nodes) {
+            if (node.embedding) {
+                similarities.set(id, this.cosineSimilarity(query, node.embedding));
+            }
+        }
+        // Find starting nodes (most similar to query)
+        const sortedNodes = Array.from(similarities.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, Math.min(5, this.nodes.size));
+        if (sortedNodes.length === 0) {
+            return [];
+        }
+        // Random walk with restart
+        const visitCounts = new Map();
+        const startNodeIds = sortedNodes.map(([id]) => id);
+        const startProbs = this.normalizeProbs(sortedNodes.map(([, sim]) => sim));
+        for (let step = 0; step < randomWalkSteps; step++) {
+            // Choose starting node based on query similarity
+            const startIdx = this.weightedRandomChoice(startProbs);
+            let currentNode = startNodeIds[startIdx];
+            // Walk with restart probability
+            if (Math.random() >= restartProb) {
+                const edges = this.edges.get(currentNode) || [];
+                if (edges.length > 0) {
+                    // Choose next node based on edge weights
+                    const edgeWeights = edges.map((e) => e.weight);
+                    const normalizedWeights = this.normalizeProbs(edgeWeights);
+                    const nextIdx = this.weightedRandomChoice(normalizedWeights);
+                    currentNode = edges[nextIdx].target;
+                }
+            }
+            // Update visit count
+            visitCounts.set(currentNode, (visitCounts.get(currentNode) || 0) + 1);
+        }
+        // Combine visit frequency with query similarity for final ranking
+        const scores = new Map();
+        const maxVisits = Math.max(...visitCounts.values());
+        for (const [id] of this.nodes) {
+            const visitScore = (visitCounts.get(id) || 0) / maxVisits;
+            const similarityScore = similarities.get(id) || 0;
+            // Weighted combination
+            scores.set(id, 0.6 * similarityScore + 0.4 * visitScore);
+        }
+        // Sort and return top K
+        const rankedNodes = Array.from(scores.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, topK)
+            .map(([id, score]) => {
+            const node = this.nodes.get(id);
+            return {
+                id,
+                content: node.content,
+                metadata: node.metadata,
+                score,
+            };
+        });
+        logger.debug("[GraphRAG] Query completed", {
+            topK,
+            resultsCount: rankedNodes.length,
+            topScore: rankedNodes[0]?.score,
+        });
+        return rankedNodes;
+    }
+    /**
+     * Add a single node to the graph
+     *
+     * @param chunk - Document chunk
+     * @param embedding - Embedding vector
+     * @returns Node ID
+     */
+    addNode(chunk, embedding) {
+        const id = randomUUID();
+        this.nodes.set(id, {
+            id,
+            content: chunk.text,
+            metadata: chunk.metadata || {},
+            embedding: embedding.vector,
+        });
+        // Create edges to existing nodes
+        const edges = [];
+        for (const [existingId, existingNode] of this.nodes) {
+            if (existingId === id) {
+                continue;
+            }
+            const similarity = this.cosineSimilarity(embedding.vector, existingNode.embedding);
+            if (similarity >= this.threshold) {
+                edges.push({
+                    source: id,
+                    target: existingId,
+                    weight: similarity,
+                    type: "semantic",
+                });
+                // Add reverse edge
+                const existingEdges = this.edges.get(existingId) || [];
+                existingEdges.push({
+                    source: existingId,
+                    target: id,
+                    weight: similarity,
+                    type: "semantic",
+                });
+                this.edges.set(existingId, existingEdges);
+            }
+        }
+        this.edges.set(id, edges);
+        return id;
+    }
+    /**
+     * Remove a node and its edges from the graph
+     *
+     * @param id - Node ID to remove
+     * @returns True if node was removed
+     */
+    removeNode(id) {
+        if (!this.nodes.has(id)) {
+            return false;
+        }
+        // Remove node
+        this.nodes.delete(id);
+        this.edges.delete(id);
+        // Remove edges pointing to this node
+        for (const [nodeId, edges] of this.edges) {
+            this.edges.set(nodeId, edges.filter((e) => e.target !== id));
+        }
+        return true;
+    }
+    /**
+     * Get graph statistics
+     */
+    getStats() {
+        const edgeCount = Array.from(this.edges.values()).reduce((sum, e) => sum + e.length, 0);
+        return {
+            nodeCount: this.nodes.size,
+            edgeCount,
+            avgDegree: this.nodes.size > 0 ? edgeCount / this.nodes.size : 0,
+            threshold: this.threshold,
+        };
+    }
+    /**
+     * Get a node by ID
+     */
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    /**
+     * Get all nodes
+     */
+    getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    /**
+     * Get edges for a node
+     */
+    getEdges(nodeId) {
+        return this.edges.get(nodeId) || [];
+    }
+    /**
+     * Find connected components in the graph
+     */
+    findConnectedComponents() {
+        const visited = new Set();
+        const components = [];
+        for (const nodeId of this.nodes.keys()) {
+            if (visited.has(nodeId)) {
+                continue;
+            }
+            const component = [];
+            const queue = [nodeId];
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (visited.has(current)) {
+                    continue;
+                }
+                visited.add(current);
+                component.push(current);
+                const edges = this.edges.get(current) || [];
+                for (const edge of edges) {
+                    if (!visited.has(edge.target)) {
+                        queue.push(edge.target);
+                    }
+                }
+            }
+            components.push(component);
+        }
+        return components;
+    }
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length) {
+            throw new Error("Vectors must have the same dimension");
+        }
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    /**
+     * Normalize probabilities to sum to 1
+     */
+    normalizeProbs(probs) {
+        const sum = probs.reduce((a, b) => a + b, 0);
+        return sum === 0
+            ? probs.map(() => 1 / probs.length)
+            : probs.map((p) => p / sum);
+    }
+    /**
+     * Weighted random choice
+     */
+    weightedRandomChoice(weights) {
+        const random = Math.random();
+        let cumulative = 0;
+        for (let i = 0; i < weights.length; i++) {
+            cumulative += weights[i];
+            if (random <= cumulative) {
+                return i;
+            }
+        }
+        return weights.length - 1;
+    }
+    /**
+     * Update similarity threshold and rebuild edges
+     */
+    updateThreshold(threshold) {
+        this.threshold = threshold;
+        // Rebuild edges with new threshold
+        this.edges.clear();
+        const nodeIds = Array.from(this.nodes.keys());
+        for (let i = 0; i < nodeIds.length; i++) {
+            const edges = [];
+            const nodeA = this.nodes.get(nodeIds[i]);
+            for (let j = 0; j < nodeIds.length; j++) {
+                if (i === j) {
+                    continue;
+                }
+                const nodeB = this.nodes.get(nodeIds[j]);
+                if (!nodeA.embedding || !nodeB.embedding) {
+                    continue;
+                }
+                const similarity = this.cosineSimilarity(nodeA.embedding, nodeB.embedding);
+                if (similarity >= threshold) {
+                    edges.push({
+                        source: nodeIds[i],
+                        target: nodeIds[j],
+                        weight: similarity,
+                        type: "semantic",
+                    });
+                }
+            }
+            edges.sort((a, b) => b.weight - a.weight);
+            this.edges.set(nodeIds[i], edges);
+        }
+    }
+    /**
+     * Serialize graph to JSON
+     */
+    toJSON() {
+        return {
+            nodes: Array.from(this.nodes.values()),
+            edges: Array.from(this.edges.entries()).map(([source, edges]) => ({
+                source,
+                edges,
+            })),
+            config: {
+                dimension: this.dimension,
+                threshold: this.threshold,
+            },
+        };
+    }
+    /**
+     * Load graph from JSON
+     */
+    static fromJSON(json) {
+        const graph = new GraphRAG({
+            dimension: json.config.dimension,
+            threshold: json.config.threshold,
+        });
+        for (const node of json.nodes) {
+            graph.nodes.set(node.id, node);
+        }
+        for (const { source, edges } of json.edges) {
+            graph.edges.set(source, edges);
+        }
+        return graph;
+    }
+}
+//# sourceMappingURL=graphRAG.js.map

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

@@ -0,0 +1,4 @@
+/**
+ * Graph RAG Module Exports
+ */
+export { GraphRAG } from "./graphRAG.js";

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

@@ -0,0 +1,5 @@
+/**
+ * Graph RAG Module Exports
+ */
+export { GraphRAG } from "./graphRAG.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,103 @@
+/**
+ * RAG Document Processing Module
+ *
+ * Provides comprehensive RAG (Retrieval-Augmented Generation) capabilities:
+ * - Document loading (text, markdown, HTML, JSON, CSV, PDF, web)
+ * - MDocument class for fluent document processing
+ * - 10 chunking strategies (character, recursive, sentence, token, markdown, html, json, latex, semantic, semantic-markdown)
+ * - LLM-powered metadata extraction (title, summary, keywords, Q&A)
+ * - Vector query tools with metadata filtering and reranking
+ * - Hybrid search (BM25 + vector fusion)
+ * - Graph RAG for knowledge graph-based retrieval
+ * - RAG pipeline orchestration
+ * - Context assembly and formatting
+ * - ChunkerFactory and ChunkerRegistry patterns for extensibility
+ * - Error handling and resilience (CircuitBreaker, RetryHandler)
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   MDocument,
+ *   loadDocument,
+ *   RAGPipeline,
+ *   ChunkerRegistry,
+ *   ChunkerFactory,
+ *   CircuitBreaker
+ * } from '@juspay/neurolink';
+ *
+ * // Load and process a document
+ * const doc = await loadDocument('/path/to/document.md');
+ * await doc.chunk({ strategy: 'markdown', config: { maxSize: 1000 } });
+ * await doc.embed('openai', 'text-embedding-3-small');
+ *
+ * // Or use the full RAG pipeline
+ * const pipeline = new RAGPipeline({
+ *   embeddingModel: { provider: 'openai', modelName: 'text-embedding-3-small' },
+ *   generationModel: { provider: 'openai', modelName: 'gpt-4o-mini' }
+ * });
+ * await pipeline.ingest(['/path/to/docs/*.md']);
+ * const response = await pipeline.query('What are the key features?');
+ *
+ * // Use factory pattern for chunker creation
+ * const chunker = await ChunkerFactory.createChunker('semantic', { maxSize: 500 });
+ * const chunks = await chunker.chunk(text);
+ * ```
+ */
+export { ChunkerFactory, chunkerFactory, createChunker, getAvailableStrategies as getFactoryStrategies, getDefaultConfig as getFactoryDefaultConfig, } from "./ChunkerFactory.js";
+export { ChunkerRegistry as ChunkerRegistryV2, chunkerRegistry, getAvailableChunkers, getChunker, getChunkerMetadata, } from "./ChunkerRegistry.js";
+export * from "./chunkers/index.js";
+export { CharacterChunker, ChunkerRegistry, chunkText, HTMLChunker, JSONChunker, LaTeXChunker, MarkdownChunker, RecursiveChunker, SemanticChunker, SentenceChunker, TokenChunker, } from "./chunking/index.js";
+export { CSVLoader, type CSVLoaderOptions, type DocumentLoader, HTMLLoader, JSONLoader, type LoaderOptions, loadDocument, loadDocuments, MarkdownLoader, MDocument, PDFLoader, type PDFLoaderOptions, TextLoader, WebLoader, type WebLoaderOptions, } from "./document/index.js";
+export * from "./errors/index.js";
+export { GraphRAG } from "./graphRag/index.js";
+export { createMetadataExtractor, extractMetadata, getAvailableExtractors, getAvailableExtractorTypes, getExtractor, getExtractorDefaultConfig, getExtractorMetadata, getRegisteredExtractorMetadata, LLMMetadataExtractor, type MetadataExtractor, type MetadataExtractorConfig, MetadataExtractorFactory, type MetadataExtractorMetadata, MetadataExtractorRegistry, type MetadataExtractorType, metadataExtractorFactory, metadataExtractorRegistry, } from "./metadata/index.js";
+export { assembleContext, type CitationFormat, type ContextAssemblyOptions, type ContextWindow, createContextWindow, createRAGPipeline, type EmbeddingModelConfig, extractKeySentences, formatContextWithCitations, type GenerationModelConfig, type IngestOptions, orderByDocumentStructure, type PipelineStats, type QueryOptions, RAGPipeline, type RAGPipelineConfig, type RAGResponse, summarizeContext, } from "./pipeline/index.js";
+export { prepareRAGTool, type RAGPreparedTool } from "./ragIntegration.js";
+export { batchRerank, CohereRelevanceScorer, CrossEncoderReranker, createReranker, getAvailableRerankers, getAvailableRerankerTypes, getRegisteredRerankerMetadata, getReranker, getRerankerDefaultConfig, getRerankerMetadata, type Reranker, type RerankerConfig, RerankerFactory, type RerankerMetadata, RerankerRegistry, type RerankerType, rerank, rerankerFactory, rerankerRegistry, simpleRerank, } from "./reranker/index.js";
+export * from "./resilience/index.js";
+export { type BM25Index, createHybridSearch, createVectorQueryTool, type HybridSearchOptions, InMemoryBM25Index, InMemoryVectorStore, linearCombination, reciprocalRankFusion, type VectorStore, } from "./retrieval/index.js";
+export * from "./types.js";
+import type { Chunk, ChunkingStrategy, ExtractParams } from "./types.js";
+/**
+ * Process a document through the full RAG pipeline
+ *
+ * @param text - Document text to process
+ * @param options - Processing options
+ * @returns Processed chunks with optional metadata
+ */
+export declare function processDocument(text: string, options?: {
+    /** Chunking strategy (default: recursive) */
+    strategy?: ChunkingStrategy;
+    /** Maximum chunk size */
+    maxSize?: number;
+    /** Chunk overlap */
+    overlap?: number;
+    /** Metadata extraction options */
+    extract?: ExtractParams;
+    /** Provider for metadata extraction */
+    provider?: string;
+    /** Model for metadata extraction */
+    model?: string;
+    /** Custom metadata to add */
+    metadata?: Record<string, unknown>;
+}): Promise<Chunk[]>;
+/**
+ * Get recommended chunking strategy based on content type
+ *
+ * @param contentType - MIME type or file extension
+ * @returns Recommended chunking strategy
+ */
+export declare function getRecommendedStrategy(contentType: string): ChunkingStrategy;
+/**
+ * Get available chunking strategies
+ *
+ * @returns Array of available strategy names
+ */
+export declare function getAvailableStrategies(): ChunkingStrategy[];
+/**
+ * Get default configuration for a chunking strategy
+ *
+ * @param strategy - Chunking strategy name
+ * @returns Default configuration object
+ */
+export declare function getDefaultChunkerConfig(strategy: ChunkingStrategy): Record<string, unknown>;

package/dist/lib/rag/index.js

@@ -0,0 +1,142 @@
+/**
+ * RAG Document Processing Module
+ *
+ * Provides comprehensive RAG (Retrieval-Augmented Generation) capabilities:
+ * - Document loading (text, markdown, HTML, JSON, CSV, PDF, web)
+ * - MDocument class for fluent document processing
+ * - 10 chunking strategies (character, recursive, sentence, token, markdown, html, json, latex, semantic, semantic-markdown)
+ * - LLM-powered metadata extraction (title, summary, keywords, Q&A)
+ * - Vector query tools with metadata filtering and reranking
+ * - Hybrid search (BM25 + vector fusion)
+ * - Graph RAG for knowledge graph-based retrieval
+ * - RAG pipeline orchestration
+ * - Context assembly and formatting
+ * - ChunkerFactory and ChunkerRegistry patterns for extensibility
+ * - Error handling and resilience (CircuitBreaker, RetryHandler)
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   MDocument,
+ *   loadDocument,
+ *   RAGPipeline,
+ *   ChunkerRegistry,
+ *   ChunkerFactory,
+ *   CircuitBreaker
+ * } from '@juspay/neurolink';
+ *
+ * // Load and process a document
+ * const doc = await loadDocument('/path/to/document.md');
+ * await doc.chunk({ strategy: 'markdown', config: { maxSize: 1000 } });
+ * await doc.embed('openai', 'text-embedding-3-small');
+ *
+ * // Or use the full RAG pipeline
+ * const pipeline = new RAGPipeline({
+ *   embeddingModel: { provider: 'openai', modelName: 'text-embedding-3-small' },
+ *   generationModel: { provider: 'openai', modelName: 'gpt-4o-mini' }
+ * });
+ * await pipeline.ingest(['/path/to/docs/*.md']);
+ * const response = await pipeline.query('What are the key features?');
+ *
+ * // Use factory pattern for chunker creation
+ * const chunker = await ChunkerFactory.createChunker('semantic', { maxSize: 500 });
+ * const chunks = await chunker.chunk(text);
+ * ```
+ */
+export { ChunkerFactory, chunkerFactory, createChunker, getAvailableStrategies as getFactoryStrategies, getDefaultConfig as getFactoryDefaultConfig, } from "./ChunkerFactory.js";
+// ChunkerFactory and ChunkerRegistry patterns (from main worktree)
+export { ChunkerRegistry as ChunkerRegistryV2, chunkerRegistry, getAvailableChunkers, getChunker, getChunkerMetadata, } from "./ChunkerRegistry.js";
+// Base chunker and chunker implementations (from main worktree)
+export * from "./chunkers/index.js";
+// Chunking
+export { CharacterChunker, ChunkerRegistry, chunkText, HTMLChunker, JSONChunker, LaTeXChunker, MarkdownChunker, RecursiveChunker, SemanticChunker, SentenceChunker, TokenChunker, } from "./chunking/index.js";
+// Document Processing
+export { CSVLoader, HTMLLoader, JSONLoader, loadDocument, loadDocuments, MarkdownLoader, MDocument, PDFLoader, TextLoader, WebLoader, } from "./document/index.js";
+// Error handling
+export * from "./errors/index.js";
+// Graph RAG
+export { GraphRAG } from "./graphRag/index.js";
+// Metadata Extraction
+export { createMetadataExtractor, extractMetadata, getAvailableExtractors, getAvailableExtractorTypes, getExtractor, getExtractorDefaultConfig, getExtractorMetadata, getRegisteredExtractorMetadata, LLMMetadataExtractor, 
+// Factory pattern
+MetadataExtractorFactory, 
+// Registry pattern
+MetadataExtractorRegistry, metadataExtractorFactory, metadataExtractorRegistry, } from "./metadata/index.js";
+// Pipeline
+export { assembleContext, createContextWindow, createRAGPipeline, extractKeySentences, formatContextWithCitations, orderByDocumentStructure, RAGPipeline, summarizeContext, } from "./pipeline/index.js";
+// RAG Integration (for generate/stream)
+export { prepareRAGTool } from "./ragIntegration.js";
+// Reranker
+export { batchRerank, CohereRelevanceScorer, CrossEncoderReranker, createReranker, getAvailableRerankers, getAvailableRerankerTypes, getRegisteredRerankerMetadata, getReranker, getRerankerDefaultConfig, getRerankerMetadata, 
+// Factory pattern
+RerankerFactory, 
+// Registry pattern
+RerankerRegistry, rerank, rerankerFactory, rerankerRegistry, simpleRerank, } from "./reranker/index.js";
+// Resilience patterns
+export * from "./resilience/index.js";
+// Retrieval
+export { createHybridSearch, createVectorQueryTool, InMemoryBM25Index, InMemoryVectorStore, linearCombination, reciprocalRankFusion, } from "./retrieval/index.js";
+// Types
+export * from "./types.js";
+// Convenience functions
+import { ChunkerRegistry } from "./chunking/index.js";
+import { LLMMetadataExtractor } from "./metadata/index.js";
+/**
+ * Process a document through the full RAG pipeline
+ *
+ * @param text - Document text to process
+ * @param options - Processing options
+ * @returns Processed chunks with optional metadata
+ */
+export async function processDocument(text, options) {
+    const { strategy = "recursive", maxSize = 1000, overlap = 200, extract, provider, model, metadata = {}, } = options || {};
+    // Chunk the document
+    const chunker = ChunkerRegistry.get(strategy);
+    const chunks = await chunker.chunk(text, { maxSize, overlap, metadata });
+    // Extract metadata if requested
+    if (extract) {
+        const extractor = new LLMMetadataExtractor({ provider, modelName: model });
+        const results = await extractor.extract(chunks, extract);
+        // Merge metadata into chunks
+        for (let i = 0; i < chunks.length && i < results.length; i++) {
+            const result = results[i];
+            if (result.title) {
+                chunks[i].metadata.title = result.title;
+            }
+            if (result.summary) {
+                chunks[i].metadata.summary = result.summary;
+            }
+            if (result.keywords) {
+                chunks[i].metadata.keywords = result.keywords;
+            }
+        }
+    }
+    return chunks;
+}
+/**
+ * Get recommended chunking strategy based on content type
+ *
+ * @param contentType - MIME type or file extension
+ * @returns Recommended chunking strategy
+ */
+export function getRecommendedStrategy(contentType) {
+    return ChunkerRegistry.getRecommendedStrategy(contentType);
+}
+/**
+ * Get available chunking strategies
+ *
+ * @returns Array of available strategy names
+ */
+export function getAvailableStrategies() {
+    return ChunkerRegistry.getAvailableStrategies();
+}
+/**
+ * Get default configuration for a chunking strategy
+ *
+ * @param strategy - Chunking strategy name
+ * @returns Default configuration object
+ */
+export function getDefaultChunkerConfig(strategy) {
+    return ChunkerRegistry.getDefaultConfig(strategy);
+}
+//# sourceMappingURL=index.js.map