Add embeddings to chunks and entities in the graph with parallel processing

Add entities to the knowledge graph

Add a new level to the hierarchy

Add relationships to the knowledge graph

Add more text content to analyze

Get all warnings across all phases

Get detailed analysis with explanation

Analyze entity mentions (many entities = specific query)

Analyze query keywords (-1.0 = very specific, +1.0 = very broad)

Analyze query length (short = specific, long = broad)

Set the answer

Apply Reciprocal Rank Fusion (RRF)

Apply semantic normalization (more aggressive)

Batch search for multiple queries in parallel

High-performance batch search for multiple queries

Breadth-First Search (BFS) from a source entity BFS explores the graph level by level, guaranteeing shortest paths. Ideal for finding entities within

Build completion check prompt

Build gleaning continuation prompt

Build the extraction prompt following Microsoft GraphRAG methodology Creates a detailed prompt that instructs the LLM to extract both entities and re

Build initial entity extraction prompt

Build the concept graph from all indexed documents This finalizes the graph construction and creates the bidirectional index. Must be called after in

Build graph context for a query (top-K relevant entities/relationships)

Calculate aggregated metrics

Calculate combined score with dynamic weights

Calculate query complexity

Calculate the total confidence of the chain Uses product of step confidences, weighted by causal strengths

Calculate degree centrality for each concept Degree centrality = number of connections / (total nodes - 1) Normalized to [0, 1] range.

Calculate entity importance based on frequency and distribution

Calculate entity weights based on fact relevance Key insight: Entities from high-scoring facts get high weights, but downweighted by how many passage

Calculate IDF (Inverse Document Frequency) scores IDF = log(total_documents / document_frequency) Normalized to [0, 1] range using sigmoid-like trans

Calculate passage weights from dense retrieval scores

Calculate threshold based on percentile

Calculate response quality metrics

Optimized sequential sparse computation

Calculate source credibility

Calculate derived statistics (hit rate and average time)

Calculate threshold based on standard deviation

Calculate string similarity using edit distance

Calculate text similarity using multiple metrics

Calculate term frequency (TF) using normalized frequency TF = (count of term in document) / (total terms in document)

Calculate word overlap between two word lists

Execute a function call

Stream chat response with real-time token generation # Arguments `messages` - Array of chat messages `on_chunk` - Callback for each generated token c

Checks the logical flow and coherence of a response. Analyzes the response content for logical flow indicators such as connecting words and smooth tr

Check factual consistency

Checks the relevance between query and response. Analyzes semantic relevance by computing word overlap between the query and response using Jaccard s

Split text into semantic chunks

Paragraph-based chunking

Chunk text into overlapping windows

Chunk a document into overlapping windows

Convenience method: chunk hierarchically and enrich with auto-detected format

Chunk text into smaller pieces

Split text into semantically coherent chunks

Clear all services

Clear the knowledge graph (preserves documents and chunks)

Clear dirty status for a node

Cluster relationships using Leiden algorithm (when enabled) or SCC fallback

Check if collection exists

Combine entity and passage weights into reset probability distribution

Generate multiple text completions concurrently

Complete a prompt with parameters and caching support (synchronous version)

Async version of complete_with_params

Parallel similarity computation between all vectors with optimized chunking

Get the length of the section content in characters

Convert ExtractedEntity to core::Entity

Cosine similarity between two vectors

Count sentences in text

Create an API key

Create pure algorithmic configuration (no LLM)

Create pure algorithmic configuration (no LLM)

Create a summary prompt based on level and strategy

Create a table with specified vector dimension

Algorithmic pipeline defaults