Skip to main content
Reusable components for building custom LangChain RAG applications.

​
AgenticRouter

Route queries to search, reflect, or generate actions using LLM reasoning for agentic RAG patterns.

​
Constructor

AgenticRouter(llm: ChatGroq)
​
llm
ChatGroq
required
ChatGroq LLM instance for routing decisions. Should be configured with low temperature (0.0-0.3) for consistent routing

​
Methods

​
route

Route a query to the appropriate action based on current pipeline state. 
route(
    query: str,
    has_documents: bool = False,
    current_answer: str | None = None,
    iteration: int = 1,
    max_iterations: int = 3
) -> dict[str, Any]
​
query
str
required
The user’s original query text
​
has_documents
bool
default:"False"
Indicates whether documents have already been retrieved in previous iterations
​
current_answer
str
The answer generated so far, if any. Used to assess whether reflection or generation is appropriate
​
iteration
int
default:"1"
Current iteration number (1-indexed). Used to track progress and enforce iteration limits
​
max_iterations
int
default:"3"
Maximum number of routing iterations allowed. Prevents infinite loops
​
action
str
One of ‘search’, ‘reflect’, or ‘generate’
​
reasoning
str
Human-readable explanation of the routing decision

​
ContextCompressor

Compress retrieved context using reranking or LLM-based extraction to reduce token usage.

​
Constructor

ContextCompressor(
    mode: str = "reranking",
    llm: ChatGroq | None = None,
    reranker: HuggingFaceCrossEncoder | None = None
)
​
mode
str
default:"reranking"
Compression mode: “reranking” or “llm_extraction”
​
llm
ChatGroq
ChatGroq instance for LLM extraction mode. Required when mode is “llm_extraction”
​
reranker
HuggingFaceCrossEncoder
HuggingFaceCrossEncoder instance for reranking mode. Required when mode is “reranking”

​
Methods

​
compress

Compress documents using the configured compression strategy. 
compress(
    query: str,
    documents: list[Document],
    top_k: int = 5
) -> list[Document]
​
query
str
required
The user’s query text. Used to determine relevance
​
documents
list[Document]
required
List of LangChain Document objects to compress
​
top_k
int
default:"5"
Number of documents to return (only used in reranking mode)
​
compressed
list[Document]
Compressed list of documents. Structure depends on mode:
  • reranking: List of top_k Document objects, sorted by relevance
  • llm_extraction: List containing single synthesized Document

​
compress_reranking

Compress documents using cross-encoder reranking. 
compress_reranking(
    query: str,
    documents: list[Document],
    top_k: int = 5
) -> list[Document]
​
query
str
required
Query text for relevance scoring
​
documents
list[Document]
required
Documents to rerank
​
top_k
int
default:"5"
Number of top documents to return
​
reranked
list[Document]
Top-k documents sorted by relevance score (highest first)

​
compress_llm_extraction

Compress documents using LLM-based passage extraction. 
compress_llm_extraction(
    query: str,
    documents: list[Document]
) -> list[Document]
​
query
str
required
Query text to guide extraction
​
documents
list[Document]
required
Documents to extract from
​
extracted
list[Document]
List containing a single Document with extracted passages. Metadata includes ‘source’: ‘compressed’ and ‘original_doc_count’

​
QueryEnhancer

Enhance queries using multi-query generation, HyDE (Hypothetical Document Embeddings), and step-back techniques.

​
Constructor

QueryEnhancer(llm: ChatGroq)
​
llm
ChatGroq
required
ChatGroq LLM instance for query enhancement

​
Methods

​
generate_multi_queries

Generate multiple query variations for better retrieval coverage. 
generate_multi_queries(
    query: str,
    num_queries: int = 3
) -> list[str]
​
query
str
required
Original query
​
num_queries
int
default:"3"
Number of query variations to generate
​
queries
list[str]
List of query variations including the original query

​
generate_hyde_document

Generate a hypothetical document that would answer the query. 
generate_hyde_document(query: str) -> str
​
query
str
required
Query to generate hypothetical document for
​
document
str
Hypothetical document text that can be embedded and used for retrieval

​
generate_step_back_query

Generate a step-back query that asks a more general question. 
generate_step_back_query(query: str) -> str
​
query
str
required
Specific query to generalize
​
step_back
str
More general query useful for retrieving background context

​
MMRHelper

Maximal Marginal Relevance utilities for diversity-optimized retrieval.

​
Methods

​
mmr_rerank

Rerank documents using MMR algorithm to balance relevance and diversity. 
MMRHelper.mmr_rerank(
    documents: list[Document],
    embeddings: list[list[float]],
    query_embedding: list[float],
    k: int = 10,
    lambda_param: float = 0.5
) -> list[Document]
​
documents
list[Document]
required
Documents to rerank
​
embeddings
list[list[float]]
required
Document embeddings corresponding to documents list
​
query_embedding
list[float]
required
Query embedding vector
​
k
int
default:"10"
Number of documents to return
​
lambda_param
float
default:"0.5"
Balance parameter between relevance (1.0) and diversity (0.0). Default 0.5 balances both
​
reranked
list[Document]
Reranked documents optimized for relevance and diversity

​
Usage Examples

​
Agentic routing

from langchain_groq import ChatGroq
from vectordb.langchain.components import AgenticRouter

llm = ChatGroq(model="llama-3.3-70b-versatile", temperature=0)
router = AgenticRouter(llm)

# Initial routing - should suggest 'search'
decision = router.route(
    "What is quantum computing?",
    has_documents=False
)
print(decision)
# {'action': 'search', 'reasoning': 'No documents retrieved yet'}

# After retrieval - may suggest 'reflect' or 'generate'
decision = router.route(
    "What is quantum computing?",
    has_documents=True,
    current_answer="Quantum computing uses qubits...",
    iteration=2
)

​
Context compression with reranking

from langchain_community.cross_encoders import HuggingFaceCrossEncoder
from vectordb.langchain.components import ContextCompressor

reranker = HuggingFaceCrossEncoder(model_name="BAAI/bge-reranker-base")
compressor = ContextCompressor(mode="reranking", reranker=reranker)

# Compress 10 documents down to top 3
compressed = compressor.compress(
    query="What is AI?",
    documents=retrieved_documents,
    top_k=3
)

​
Context compression with LLM extraction

from langchain_groq import ChatGroq
from vectordb.langchain.components import ContextCompressor

llm = ChatGroq(model="llama-3.3-70b-versatile")
compressor = ContextCompressor(mode="llm_extraction", llm=llm)

# Extract relevant passages from documents
compressed = compressor.compress(
    query="Explain neural networks",
    documents=retrieved_documents
)

​
Query enhancement

from langchain_groq import ChatGroq
from vectordb.langchain.components import QueryEnhancer

llm = ChatGroq(model="llama-3.3-70b-versatile")
enhancer = QueryEnhancer(llm)

# Generate multiple query variations
queries = enhancer.generate_multi_queries(
    "What are the applications of AI?",
    num_queries=3
)

# Generate hypothetical document
hyde_doc = enhancer.generate_hyde_document(
    "How does machine learning work?"
)

# Generate step-back query
step_back = enhancer.generate_step_back_query(
    "What is the training process for GPT-4?"
)
# Returns: "What are the general principles of training large language models?"

Build docs developers (and LLMs) love

Get started for freeTalk to us