I want to add query re-writing to my RAG pipeline to improve retrieval. What framework has the best built-in query transformation modules?

When it comes to out-of-the-box, structurally native support for query transformations, LlamaIndex is widely considered to have the best and most cohesive built-in modules for this specific task.

While LangChain and Haystack can certainly achieve query rewriting, they treat it more as a loose chain of components or a prompt-engineering exercise you construct yourself. LlamaIndex treats query transformation as a first-class citizen of the retrieval architecture.

Why LlamaIndex Wins for Query Transformation

LlamaIndex provides dedicated classes and abstractions designed explicitly to manipulate a user query before it hits your vector store or index. Its core query transformation patterns include:

• Multi-Step Query: Breaks a complex, multi-faceted question into sequential sub-questions (e.g., "Compare X and Y" becomes step 1: "What is X?", step 2: "What is Y?").
• RAG-Fusion / Query Rewriting: Rewrites a single user query into multiple semantic variations to maximize vector search recall.
• Sub-Question Query Engine: Specifically built for data-heavy and heterogeneous RAG, breaking a broad question down and dispatching distinct sub-queries to entirely different data sources or indices.
• HyDE (Hypothetical Document Embeddings): Generates a hypothetical answer using an LLM first, and then embeds that synthetic document to search for real passages with similar semantic vectors.

Implementing these in LlamaIndex usually takes just a few lines of configuration because the query engines natively accept a query_transform argument or wrap around your base retriever seamlessly.

How the Major Frameworks Compare

1. LlamaIndex (Best for Dedicated Modules)
   • Pros: Built specifically around the ingestion-retrieval-synthesis lifecycle. Classes like HyDEQueryTransform or multi-step query engines are ready to drop into a pipeline instantly.
   • Cons: Opinionated abstraction layers; if you want to heavily customize the underlying graph or loop logic outside their paradigms, it can feel restrictive.
2. LangChain / LangGraph (Best for Custom Composability)
   • Pros: Ultimate flexibility. You can write a prompt that rewrites a query, pipe it into an LLM, pass it to a retriever, and loop it using LangGraph.
   • Cons: Less "built-in magic." You have to wire up the components, manage state explicitly, and build the rewriting pipeline from standard runnable primitives (| syntax) rather than invoking a pre-baked query transformation module.
3. Haystack by deepset (Best for Enterprise Audit/Pipelines)
   • Pros: Clean, component-based graph architecture where you can cleanly insert a custom PromptBuilder or LLM node dedicated to query expansion right before your retriever.
   • Cons: More verbose for rapid prototyping compared to LlamaIndex's high-level query engine wrappers.

Recommendation

If your primary bottleneck is low retrieval relevance caused by messy, vague, or complex user phrasing, use LlamaIndex . You can explore their native implementations directly in the LlamaIndex Query Transformations Documentation.

To help narrow down the best pattern for your data, could you tell me:

• What kind of queries are failing right now? (e.g., overly complex multi-part questions, vague short phrases, or conversational follow-ups?)
• What vector database or search backend are you currently using?

If your main criterion is built-in query transformation for RAG, I’d pick LlamaIndex overall, with LangChain a very close second.

Why LlamaIndex

LlamaIndex has a particularly RAG-centric set of query transformations, including patterns such as:

• HyDE — generate a hypothetical answer/document and retrieve against it.
• Query fusion / multi-query retrieval — generate multiple queries and combine their results.
• Query rewriting/decomposition — transform a complex question into more retrieval-friendly queries.
• Query routing and related retrieval transformations.

That makes it especially convenient if you want to experiment with several retrieval strategies without assembling everything yourself.

LangChain

LangChain is arguably the better choice if your pipeline already lives in LangChain. Its retrieval ecosystem includes things like MultiQueryRetriever, which uses an LLM to generate alternative queries, plus broader composable retriever abstractions.

My recommendation

If you're starting a new RAG system specifically to investigate query rewriting, I'd use LlamaIndex.

If you're already using LangChain, don't switch frameworks just for this—its retriever abstractions are sufficiently flexible to implement essentially the same strategies.

A good progression is:

original query → rewrite/multi-query → retrieve → rerank → generate

And I'd benchmark at least single-query vs. multi-query vs. HyDE, because query rewriting can improve recall while simultaneously introducing irrelevant retrievals.

If your main criterion is built-in query rewriting / query transformation for RAG, I would generally rank the frameworks like this:

1. LlamaIndex — strongest RAG-native query transformation toolkit
2. LangChain — widest set of ready-made transformations
3. Haystack — clean pipeline architecture, but more assembly required

Auto Learning Agents Talki Academy## 1. LlamaIndex: best if retrieval quality is the goal

LlamaIndex was designed around the retrieval problem, so its query engine abstractions include many RAG-specific transformations:

• Query decomposition — split complex questions into sub-questions
• Query routing — decide which index/tool should answer
• Sub-question query engine — retrieve from multiple sources and synthesize
• HyDE-style approaches — generate hypothetical documents/answers for better semantic retrieval
• Multi-step retrieval workflows
• Metadata-aware query planning

It is usually the first framework I would evaluate if your current problem is: "Users ask messy natural-language questions, and my retriever misses relevant chunks."

Example pattern:

User query
   ↓
Query transform
   ↓
Expanded/decomposed queries
   ↓
Retriever
   ↓
Reranker
   ↓
LLM answer

2. LangChain: best if you want lots of interchangeable components

LangChain has a very mature set of retrieval utilities, including:

• MultiQueryRetriever — generate multiple search queries from one question
• RePhraseQueryRetriever
• MultiVectorRetriever
• Contextual compression retrievers
• Self-query retrievers — translate natural language into metadata filters
• Hypothetical document embedding (HyDE) patterns
• Step-back prompting patterns

The advantage is composability: you can chain transformations together easily with retrievers, rerankers, agents, and evaluators. The downside is that RAG is one part of a much larger framework, so some retrieval-specific workflows require more wiring.

A common LangChain pipeline:

Question
 ↓
MultiQueryRetriever
 ↓
Vector search
 ↓
ContextualCompressionRetriever
 ↓
Reranker
 ↓
Generation

3. Haystack: best for production pipelines

Haystack's strength is explicit pipeline composition:

Query
 ↓
Custom transformer component
 ↓
Retriever
 ↓
Ranker
 ↓
Generator

It has strong retriever/ranker components, but query rewriting is typically something you implement as a pipeline component rather than selecting from a large catalog of built-in query transformations.

My recommendation by use case

For a production RAG system today, I would probably start with LlamaIndex for retrieval experiments and add a dedicated evaluation loop (e.g., measure recall@k before/after rewriting). Query rewriting can improve retrieval, but it can also add latency and sometimes introduce query drift, so it is worth testing against your actual query distribution rather than assuming more transformations are always better.

A strong baseline to compare would be:

1. Original query → vector search
2. Multi-query expansion → union retrieval
3. Query decomposition → parallel retrieval
4. HyDE → embedding retrieval
5. Add reranking after each

Then compare retrieval recall and answer faithfulness.

3. Haystack: best for production pipelines

Haystack's strength is explicit pipeline composition:

Query
 ↓
Custom transformer component
 ↓
Retriever
 ↓
Ranker
 ↓
Generator

It has strong retriever/ranker components, but query rewriting is typically something you implement as a pipeline component rather than selecting from a large catalog of built-in query transformations.

My recommendation by use case

For a production RAG system today, I would probably start with LlamaIndex for retrieval experiments and add a dedicated evaluation loop (e.g., measure recall@k before/after rewriting). Query rewriting can improve retrieval, but it can also add latency and sometimes introduce query drift, so it is worth testing against your actual query distribution rather than assuming more transformations are always better.

A strong baseline to compare would be:

When it comes to built-in query transformation and rewriting modules, LlamaIndex stands out as having the most cohesive, native, and purpose-built abstractions for RAG.

Framework Comparison for Query Transformation

• LlamaIndex (Winner for Built-in Abstractions):
  LlamaIndex treats query transformations as first-class citizens via its QueryTransform interface and advanced retriever classes. It provides clean, out-of-the-box components for major rewriting paradigms:
  • HyDE (Hypothetical Document Embeddings): Generates a fake answer/document via an LLM and uses that embedding for retrieval (HyDEQueryTransform).
  • Multi-Step & Sub-Question Queries: Breaks down complex, multi-part user questions into distinct sub-queries automatically (SubQuestionQueryEngine).
  • Custom Query Bundles: Easily transforms original text into multi-target strings for hybrid embedding strategies.
  • Why it wins: You don't have to manually wire up chains of prompts just to get a transformed query bundle; the abstraction handles the orchestration between the LLM rewriter and the downstream index natively.
• LangChain / LangGraph (Best for Custom Flexibility):
  LangChain has fantastic conceptual guides and cookbook implementations for patterns like Rewrite-Retrieve-Read, Step-Back Prompting , and RAG-Fusion.
  • The Catch: Rather than rigid, dedicated single-line "query transformation modules," LangChain relies on you composing LCEL (LangChain Expression Language) chains—prompting an LLM to rewrite the query, then passing that output into a retriever. It offers infinite flexibility, but it requires more boilerplate code to assemble than LlamaIndex's plug-and-play components.
• Haystack (Best for Pipeline Visibility):
  Haystack handles query rewriting as distinct components/nodes that you explicitly place inside a visualizable pipeline graph.
  • The Catch: While great for enterprise auditability and step-by-step logging, you typically have to write custom component classes or template nodes to perform advanced LLM-based query expansion/rewriting, giving you control at the cost of pre-packaged convenience.

Recommendation

If you want to minimize boilerplate and use battle-tested, native modules that handle query rewriting out-of-the-box, go with LlamaIndex Documentation . If your pipeline already heavily leverages LangChain Documentation for complex agentic control flows or custom LCEL pipelines, writing a custom rewrite step using their prompt templates is straightforward, though slightly more manual.

If you'd like, let me know:

• Which specific rewriting technique you want to use (e.g., HyDE, Multi-query generation, or Step-back prompting)
• Whether you are using a vector store or a hybrid search setup

I can share a clean code snippet for the framework of your choice.

When it comes to out-of-the-box, dedicated abstractions for query transformation, LlamaIndex and DSPy stand out as the strongest frameworks, though they approach the problem from entirely different angles.

1. LlamaIndex: The Best for Plug-and-Play Modules

If you want standard, pre-packaged query transformation patterns that you can drop into a pipeline with a few lines of code, LlamaIndex has the most mature native support.

• Built-in Paradigms: It natively supports single-step and multi-step transformations, including HyDE (Hypothetical Document Embeddings), Multi-Query / Query Rewriting , and Sub-Question Decomposition (breaking a complex query into sequential or parallel sub-target queries).
• How it works: Transformations operate as first-class citizens (QueryTransform objects) that sit cleanly between your user input and your index router.
• Best for: Developers who want standard advanced retrieval tricks working in minutes without writing custom orchestration logic. Check out the LlamaIndex Query Transformations Documentation to see implementation patterns.

2. DSPy: The Best for Programmatic & Optimized Rewriting

If you view query rewriting not just as a static prompt, but as a component that needs to be optimized/trained against your dataset, DSPy is unmatched.

• Built-in Paradigms: Instead of rigid hardcoded classes, DSPy treats query transformation as programmable modules (e.g., dspy.ChainOfThought or custom predictors) that you compose into a RAG signature.
• How it works: You write a module that takes a messy user query and outputs a search-optimized query. Then, using DSPy’s teleprompters (optimizers), you compile and automatically tune the prompts/weights of the rewriter based on retrieval metrics (like HitRate or MRR).
• Best for: Production systems where a static LLM prompt for query rewriting isn't cutting it and you want to optimize the exact rewriting behavior against ground-truth evaluation data. Learn more via the official DSPy Documentation.

3. LangChain / LangGraph: Best for Custom Orchestration

• Built-in Paradigms: LangChain provides functional building blocks (like MultiQueryRetriever or prompt templates for query construction), but it doesn't give you an opinionated "black-box" query transformation engine.
• Best for: Engineers who prefer total control over custom state graphs (via LangGraph) to route, rewrite, loop, or conditionally fall back on alternative queries.

To help narrow down the ideal choice, let me know:

• Are you looking for a pre-built utility you can use today, or an optimizable framework to tune retrieval accuracy?
• What retriever/vector database are you pairing with your pipeline?

If query transformation itself is the deciding factor, I’d pick LlamaIndex.

My ranking

1. LlamaIndex — best overall for query transformations

• First-class QueryTransform abstraction.
• Built-in HyDE, query decomposition, multi-step transformations, and query fusion/multi-query retrieval.
• Its QueryFusionRetriever can generate multiple queries and fuse their results using reciprocal-rank, relative-score, distance-based, or simple fusion.
• Particularly good if you want to experiment with different retrieval strategies without writing each orchestration layer yourself.

2. LangChain — best if you're already in the LangChain ecosystem

• Supports the major patterns: rewriting, expansion/multi-query, compression, step-back prompting, and HyDE.
• Very flexible, but query transformation tends to be more compositional rather than feeling like one dedicated query-transformation subsystem.

3. Haystack — best for explicit pipeline composition

• Has a dedicated QueryExpander component that generates semantically different queries for improving recall.
• Nice choice if you want transformations to be explicit, inspectable pipeline components.

4. DSPy — best if you want to optimize the rewriting logic

• I'd consider it when the interesting problem is learning/optimizing the rewrite prompts or retrieval strategy rather than getting the largest set of prebuilt transformation primitives.

What I'd use for your RAG pipeline

If your goal is specifically "take a user's query and produce better retrieval queries", I'd start with:

User query
   ↓
Query rewrite / normalization
   ↓
Generate 2–5 alternative queries
   ↓
(Optional) HyDE query
   ↓
Parallel retrieval
   ↓
RRF / score fusion
   ↓
Reranker
   ↓
LLM

LlamaIndex is unusually well suited to this because its abstractions cover both the transformation and the subsequent fusion. Its docs explicitly describe query rewriting as generating multiple queries for ensemble/fusion retrieval, while HyDE transforms the query into hypothetical-document embeddings.

One caveat: don't assume more rewriting = better retrieval. I'd benchmark raw query vs. rewrite vs. multi-query vs. HyDE + fusion on your own evaluation set. Query generation adds latency and can introduce semantic drift.

If you tell me whether your retriever is vector-only, hybrid BM25+vector, or something like Elasticsearch/OpenSearch, I can recommend the specific transformation strategy I'd implement.

If your main criterion is “which RAG framework gives me the richest built-in query-transformation toolbox?”, I’d pick LlamaIndex, with LangChain a close second.

My ranking

Why LlamaIndex: its query-transformation abstractions are particularly RAG-centric. It has built-in patterns for HyDE, query decomposition, multi-step transformations, and workflows where transformed queries are repeatedly executed against an index.

LangChain has an equally strong collection of retrieval strategies: rewrite-retrieve-read, step-back prompting, conversational query rewriting, multi-query retrieval, and RAG-Fusion/RRF. Its advantage is that these are very composable with arbitrary retrievers and chains.

What I'd use for your case

If you're specifically trying to improve retrieval recall, I'd start with:

User query
   ↓
Query rewrite / expansion
   ↓
 ┌───────────────┬───────────────┬───────────────┐
 │ Original      │ Rewritten     │ HyDE /        │
 │ query         │ query         │ expanded query│
 └───────────────┴───────────────┴───────────────┘
                  ↓
             Parallel retrieval
                  ↓
             Reranker / RRF
                  ↓
              Top contexts
                  ↓
                 LLM

For a single-query rewrite, use a standalone-query transformation. For harder questions, I'd test multi-query + reciprocal-rank fusion; for questions whose vocabulary differs substantially from your documents, HyDE is especially worth benchmarking. LangChain explicitly documents these approaches, while LlamaIndex provides corresponding query-transformation modules.

Bottom line:

• Choose LlamaIndex if query transformation is going to be a major part of your RAG architecture.
• Choose LangChain if you want a highly composable framework and expect to mix retrieval with lots of other LLM application logic.
• Choose Haystack if you're building a more explicit, component-oriented search pipeline; its directed-multigraph pipeline model is particularly flexible for branching/parallel retrieval flows.

If you tell me your current stack (e.g. LangChain + Pinecone, LlamaIndex + pgvector, Elasticsearch, etc.), I can recommend the specific rewrite strategy and show the implementation.

When it comes to frameworks with the best out-of-the-box query transformation (often called query translation) modules, LlamaIndex and LangChain (extended by LangGraph ) are the two heavyweights, but they approach the problem with different design philosophies.

An assessment of how they compare for built-in query transformations reveals distinct advantages for each.

1. LlamaIndex: Best for Purpose-Built, Turnkey Abstractions

LlamaIndex was architected from day one specifically around data ingestion, structuring, and retrieval. Because of this focus, its built-in abstractions for query transformations are cleaner, more cohesive, and easier to drop into a pipeline with minimal boilerplate.

• Built-in Modules Available:
  • Query Rewriting: Automatically cleans up or rephrases conversational or ambiguous queries into standalone search queries.
  • Sub-Question Query Engine: Automatically breaks down a complex, multi-part user question into distinct sub-questions routed to different data sources or indices.
  • HyDE (Hypothetical Document Embeddings): Generates a hypothetical answer via an LLM and embeds that pseudo-document for vector search.
  • Step-Back Prompting: Abstraction to abstract the core principles behind a specific query before searching.
• The Verdict on LlamaIndex: If you want a modular component that you can configure with a single class definition (e.g., TransformQueryEngine or rolling out sub-question routing out-of-the-box), LlamaIndex requires significantly less custom plumbing.

2. LangChain & LangGraph: Best for Granular Control and Multi-Step Loops

LangChain offers a massive suite of query-translation recipes (such as MultiQueryRetriever , HyDE wrappers, and conversational query re-writers). However, rather than relying on a single static "transform module," the community standard has shifted toward using LangGraph to build dynamic, iterative query loops.

• Built-in Modules Available:
  • MultiQueryRetriever: Automatically fans out a single query into 3–5 different semantic variations, executes them concurrently, and de-duplicates/fuses the retrieved chunks.
  • Query Construction/Reranking Ecosystem: Unmatched integration with vector store metadata filters (translating natural language directly into SQL or vector store filter syntax).
• The Verdict on LangChain/LangGraph: If your query transformation needs to be adaptive —such as a Self-RAG loop where you retrieve documents, grade their relevance using an LLM, and conditionally rewrite the query for a second-pass retrieval only if the first pass failed—LangGraph gives you the ultimate state-machine control to wire that logic cleanly.

Summary Comparison Table

• Go with LlamaIndex if you want a clean, high-level, opinionated implementation of standard transforms (like HyDE, sub-question breakdown, or simple rewrites) up and running in under an hour.
• Go with LangChain/LangGraph if you are planning to build an agentic, multi-step retrieval loop where query rewriting depends dynamically on evaluation feedback from an initial search.

To help narrow down the ideal choice, tell me:

• Are you planning a simple single-pass transformation (like HyDE or Multi-Query), or an iterative/agentic loop?
• What vector database and LLM provider are you currently using?

If query transformation itself is your main criterion, I’d pick LlamaIndex today.

It has a particularly strong set of built-in query-transform primitives: HyDE, query decomposition, step decomposition, and custom query transforms, all integrated into its query-engine/retrieval abstractions. Its BaseQueryTransform API is explicitly designed to transform a query before it reaches the index.

My ranking

LlamaIndex is especially attractive if you're experimenting with several retrieval strategies. For example, its built-in HyDEQueryTransform generates a hypothetical answer and uses that as an embedding string, while its decomposition transforms can break complex questions into smaller retrieval problems.

LangChain is a very close second. Its query-transformation tooling explicitly covers Rewrite-Retrieve-Read, step-back prompting, conversational query rewriting, multi-query retrieval, and RAG-Fusion.

So I'd choose:

• LlamaIndex → if retrieval quality/query transformation is the core problem.
• LangChain → if RAG is part of a larger agent/tool orchestration system.
• Haystack → if you value explicit, inspectable pipeline composition over having lots of transforms prepackaged.

One important caveat: there isn't a universally best rewrite strategy. Plain rewriting helps ambiguous/user-language queries; multi-query helps vocabulary/coverage; decomposition helps multi-hop questions; and HyDE can help when questions and document language are semantically mismatched.

For a new RAG pipeline, I'd start with LlamaIndex + query rewriting → multi-query/fusion → reranking, and benchmark each stage independently rather than assuming more transformations automatically improve recall.

If you tell me your current stack (e.g. LangChain + Pinecone, LlamaIndex + Qdrant, etc.), I can recommend the specific query-rewriting architecture and show the implementation.

When it comes to out-of-the-box, purpose-built query transformation modules for RAG, LlamaIndex has the clearest edge over competitors like LangChain or Haystack.

LlamaIndex treats query transformations as first-class, modular abstractions rather than just conceptual recipes or raw prompt chains.

Why LlamaIndex Wins on Query Transformations

LlamaIndex provides dedicated classes and abstractions specifically designed to convert a user query into a form optimized for retrieval before it ever touches your index. Their system supports both single-step transformations (run once prior to retrieval) and multi-step sequential/iterative transformations.

Supported built-in transformation patterns include:

• • Query Rewriting: Automatically rephrasing or expanding the original query into multiple variants to maximize vector/keyword hit rates.
• • Sub-Question Decomposition: Breaking complex, multi-faceted questions down into distinct sub-queries targeted at specific data subsets or tools.
• • Routing: Keeping the original query intact while programmatically routing it to the most relevant index or document subset.
• • Step-Back / HyDE (Hypothetical Document Embeddings): Generating hypothetical answers or broader contextual queries natively inside the query pipeline workflow.

You can check out the official design patterns in the LlamaIndex Query Transformations Documentation and the LlamaIndex Query Transform Cookbook.

How Other Frameworks Compare

• LangChain / LangGraph: LangChain has plenty of conceptual guides and components for strategies like Rewrite-Retrieve-Read or Step-Back Prompting (detailed on the LangChain Query Transformations Blog ). However, implementing them requires manually stringing together LLM calls using LCEL (LangChain Expression Language). It is more flexible and low-level, meaning you have to build the plumbing yourself rather than calling a pre-packaged transformation module.
• Haystack: Haystack focuses heavily on pipeline auditability, clean graph execution, and monitoring. While you can build custom components for query expansion or rewriting, it lacks the dense, plug-and-play taxonomy of advanced RAG query transforms that LlamaIndex ships natively.

Would you like an example of how to implement a multi-step query decomposition or HyDE pipeline using LlamaIndex, or are you leaning toward a custom implementation in another stack?