> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/avnlp/vectordb/llms.txt
> Use this file to discover all available pages before exploring further.

# Haystack components

> Reusable component APIs for Haystack RAG pipelines

Reusable components for building custom Haystack RAG pipelines.

## AgenticRouter

Route and orchestrate RAG with agent-like behavior for tool selection and self-reflection.

### Constructor

```python theme={null}
AgenticRouter(
    model: str = "llama-3.3-70b-versatile",
    api_key: str | None = None,
    api_base_url: str = "https://api.groq.com/openai/v1"
)
```

<ParamField path="model" type="str" default="llama-3.3-70b-versatile">
  LLM model name for routing decisions
</ParamField>

<ParamField path="api_key" type="str" optional>
  API key for the LLM provider. Falls back to GROQ\_API\_KEY environment variable
</ParamField>

<ParamField path="api_base_url" type="str" default="https://api.groq.com/openai/v1">
  Base URL for OpenAI-compatible API endpoint
</ParamField>

### Methods

#### select\_tool

Select the best tool for a given query.

```python theme={null}
select_tool(query: str) -> str
```

<ParamField path="query" type="str" required>
  User query to route
</ParamField>

<ResponseField name="tool" type="str">
  Selected tool name: "retrieval", "web\_search", "calculation", or "reasoning"
</ResponseField>

#### evaluate\_answer\_quality

Evaluate generated answer quality with relevance, completeness, and grounding scores.

```python theme={null}
evaluate_answer_quality(
    query: str,
    answer: str,
    context: str = ""
) -> dict[str, Any]
```

<ParamField path="query" type="str" required>
  Original user query
</ParamField>

<ParamField path="answer" type="str" required>
  Generated answer to evaluate
</ParamField>

<ParamField path="context" type="str" default="">
  Retrieved context used to generate the answer (for grounding check)
</ParamField>

<ResponseField name="evaluation" type="dict[str, Any]">
  Dictionary containing:

  * relevance (0-100): Does it answer the query?
  * completeness (0-100): Is it sufficiently detailed?
  * grounding (0-100): Is it grounded in the context?
  * issues (list): List of identified problems (max 3)
  * suggestions (list): List of improvement suggestions (max 2)
</ResponseField>

#### self\_reflect\_loop

Run self-reflection loop to iteratively improve answer quality.

```python theme={null}
self_reflect_loop(
    query: str,
    answer: str,
    context: str = "",
    max_iterations: int = 2,
    quality_threshold: int = 75
) -> str
```

<ParamField path="query" type="str" required>
  Original user query
</ParamField>

<ParamField path="answer" type="str" required>
  Initial answer to refine
</ParamField>

<ParamField path="context" type="str" default="">
  Retrieved context for grounding
</ParamField>

<ParamField path="max_iterations" type="int" default="2">
  Maximum refinement iterations
</ParamField>

<ParamField path="quality_threshold" type="int" default="75">
  Target quality score (0-100) to stop refinement early
</ParamField>

<ResponseField name="refined_answer" type="str">
  Final refined answer after iterative improvement
</ResponseField>

***

## ContextCompressor

Compress and summarize retrieved context to reduce token usage and improve answer quality.

### Constructor

```python theme={null}
ContextCompressor(
    model: str = "llama-3.3-70b-versatile",
    api_key: str | None = None
)
```

<ParamField path="model" type="str" default="llama-3.3-70b-versatile">
  LLM model for compression (Groq API)
</ParamField>

<ParamField path="api_key" type="str" optional>
  Groq API key. Falls back to GROQ\_API\_KEY environment variable
</ParamField>

### Methods

#### compress

Compress context using specified compression technique.

```python theme={null}
compress(
    context: str,
    query: str,
    compression_type: str = "abstractive",
    **kwargs: Any
) -> str
```

<ParamField path="context" type="str" required>
  Retrieved context to compress
</ParamField>

<ParamField path="query" type="str" required>
  Original query for relevance filtering
</ParamField>

<ParamField path="compression_type" type="str" default="abstractive">
  Compression technique: "abstractive", "extractive", or "relevance\_filter"
</ParamField>

<ParamField path="**kwargs" type="Any" optional>
  Additional parameters:

  * max\_tokens (int): For abstractive compression (default: 2048)
  * num\_sentences (int): For extractive compression (default: 5)
  * relevance\_threshold (float): For relevance filtering (default: 0.5)
</ParamField>

<ResponseField name="compressed" type="str">
  Compressed context text
</ResponseField>

#### compress\_abstractive

Abstractive compression using LLM summarization.

```python theme={null}
compress_abstractive(
    context: str,
    query: str,
    max_tokens: int = 2048
) -> str
```

<ParamField path="context" type="str" required>
  Context to compress
</ParamField>

<ParamField path="query" type="str" required>
  Query for relevance
</ParamField>

<ParamField path="max_tokens" type="int" default="2048">
  Maximum tokens in compressed output
</ParamField>

<ResponseField name="summary" type="str">
  Compressed context summary
</ResponseField>

#### compress\_extractive

Extractive compression by selecting key sentences.

```python theme={null}
compress_extractive(
    context: str,
    query: str,
    num_sentences: int = 5
) -> str
```

<ParamField path="context" type="str" required>
  Context to compress
</ParamField>

<ParamField path="query" type="str" required>
  Query for relevance
</ParamField>

<ParamField path="num_sentences" type="int" default="5">
  Number of sentences to extract
</ParamField>

<ResponseField name="selected" type="str">
  Selected sentences joined together
</ResponseField>

#### filter\_by\_relevance

Filter context chunks by relevance threshold.

```python theme={null}
filter_by_relevance(
    context: str,
    query: str,
    relevance_threshold: float = 0.5
) -> str
```

<ParamField path="context" type="str" required>
  Context to filter
</ParamField>

<ParamField path="query" type="str" required>
  Query for relevance scoring
</ParamField>

<ParamField path="relevance_threshold" type="float" default="0.5">
  Minimum relevance score (0-1) to keep chunks
</ParamField>

<ResponseField name="filtered" type="str">
  Filtered context containing only relevant chunks
</ResponseField>

***

## QueryEnhancer

Enhance queries using multi-query generation and query expansion techniques.

### Constructor

```python theme={null}
QueryEnhancer(
    model: str = "llama-3.3-70b-versatile",
    api_key: str | None = None
)
```

<ParamField path="model" type="str" default="llama-3.3-70b-versatile">
  LLM model for query enhancement
</ParamField>

<ParamField path="api_key" type="str" optional>
  API key. Falls back to GROQ\_API\_KEY environment variable
</ParamField>

### Methods

#### generate\_multi\_queries

Generate multiple query variations for better retrieval coverage.

```python theme={null}
generate_multi_queries(
    query: str,
    num_queries: int = 3
) -> list[str]
```

<ParamField path="query" type="str" required>
  Original query
</ParamField>

<ParamField path="num_queries" type="int" default="3">
  Number of query variations to generate
</ParamField>

<ResponseField name="queries" type="list[str]">
  List of query variations including the original
</ResponseField>

***

## ResultMerger

Merge and deduplicate results from multiple retrieval sources.

### Methods

#### merge\_results

Merge document results using specified strategy.

```python theme={null}
merge_results(
    results_list: list[list[Document]],
    strategy: str = "rrf",
    top_k: int = 10
) -> list[Document]
```

<ParamField path="results_list" type="list[list[Document]]" required>
  List of result lists from different sources
</ParamField>

<ParamField path="strategy" type="str" default="rrf">
  Merging strategy: "rrf" (Reciprocal Rank Fusion) or "interleave"
</ParamField>

<ParamField path="top_k" type="int" default="10">
  Number of results to return after merging
</ParamField>

<ResponseField name="merged" type="list[Document]">
  Merged and deduplicated document list
</ResponseField>