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

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?

If your main criterion is built-in query transformation modules for RAG retrieval, I would rank the major frameworks roughly like this:

n4n AI AIMultiple## 1. LlamaIndex — strongest out-of-the-box for RAG query transformations

For a RAG system where retrieval quality is the bottleneck, LlamaIndex is probably the best starting point. It has first-class concepts around query engines and retrieval transformations, including patterns such as:

• Sub-question decomposition — split a complex query into smaller retrieval tasks.
• Query routing — choose among multiple indexes/retrievers.
• HyDE-style retrieval — generate a hypothetical answer/document and retrieve against that.
• Multi-step / recursive retrieval — refine retrieval based on intermediate results.
• Query rewriting via LLM prompts.

This is aligned with LlamaIndex's design philosophy: it is built around augmenting LLMs with data rather than being a general orchestration framework.

A common LlamaIndex architecture:

User query
    ↓
Query transformer
    ↓
Rewrite / expand / decompose
    ↓
Retriever
    ↓
Reranker
    ↓
LLM answer synthesis

2. LangChain — best if query rewriting is one component of a larger workflow

LangChain has many ready-made retrieval utilities, including:

• MultiQueryRetriever
• MultiVectorRetriever
• ContextualCompressionRetriever
• query constructors
• self-query retrievers
• HyDE patterns
• custom LCEL chains for rewriting

Its advantage is composability: you can easily insert a rewriting step before any retriever, combine it with agents, tools, rerankers, evaluators, etc.

Example:

Question
  ↓
LLM rewrite chain
  ↓
MultiQueryRetriever
  ↓
Vector DB
  ↓
Reranker
  ↓
Answer

I would pick LangChain if your RAG pipeline is becoming an agent workflow rather than a pure retrieval system.

3. Haystack — good engineering structure, fewer built-in transformations

Haystack's strength is explicit pipelines:

Query
 ↓
Component A
 ↓
Retriever
 ↓
Ranker
 ↓
Generator

It is excellent when you want observable, testable production pipelines, but you will often compose query transformation behavior yourself using components rather than relying on a large catalog of RAG-specific transforms.

My recommendation by use case

• Enterprise knowledge base / document QA: → LlamaIndex
• Agentic RAG with tools and multiple steps: → LangChain + LangGraph
• Search platform with strict pipeline control: → Haystack
• Researching optimal query rewriting strategies: → DSPy

For most teams adding query rewriting to an existing RAG stack, I would start with LlamaIndex's query transformation capabilities or implement the pattern yourself with a lightweight LangChain chain. The biggest gains usually come from combining:

1. query rewriting,
2. multi-query expansion,
3. hybrid retrieval (BM25 + vector),
4. reranking.

Query rewriting alone often helps, but the largest retrieval improvements usually come from the full retrieval stack.

Haystack's strength is explicit pipelines:

Query
 ↓
Component A
 ↓
Retriever
 ↓
Ranker
 ↓
Generator

It is excellent when you want observable, testable production pipelines, but you will often compose query transformation behavior yourself using components rather than relying on a large catalog of RAG-specific transforms.

My recommendation by use case

When it comes to out-of-the-box, purpose-built query transformations for RAG, LlamaIndex has the clearest edge over LangChain and Haystack.

Because LlamaIndex is designed specifically around data structures and retrieval architectures rather than general-purpose agent chaining, it treats query transformations as first-class, modular components rather than a collection of disparate prompt recipes you have to wire together manually.

Why LlamaIndex Leads in Built-In Modules

LlamaIndex provides a dedicated Query Transformations Documentation & Cookbook layer. It explicitly supports both single-step (transforming once before hitting the index) and multi-step (sequential/iterative) transformations out-of-the-box:

• Sub-Question Query Engine: Automatically decomposes a complex, multi-part user query into granular sub-questions assigned to specific data sources or indices, running them in parallel or sequence.
• HyDE (Hypothetical Document Embeddings): Built-in support to have an LLM generate a hypothetical answer to the user's prompt, then use that generated answer's embedding to search the vector space (bridging the vocabulary gap).
• Conversational / Rewrite Modules: Native classes like HyDEQueryTransform and custom LLM-backed query rewrites that plug directly into your retriever definition via TransformQueryEngine without writing custom chains.
• Router / Selection: Native routing transformations that dynamically choose which sub-index or tool to query based on the incoming transformed prompt structure.

How the Other Frameworks Compare

• LangChain: Highly flexible, but requires more assembly. LangChain has fantastic guides and modular components (like MultiQueryRetriever or custom Runnable chains for query rewriting), but you usually have to stitch the prompt template, the LLM parser, and the retriever together yourself using LangChain Expression Language (LCEL). It gives you ultimate control, but fewer "single-line" abstractions for advanced multi-step query transformations compared to LlamaIndex.
• Haystack (by Deepset): Excellent for enterprise pipeline observability and auditability, Haystack handles query rewriting through custom Component nodes in a DAG (Directed Acyclic Graph) pipeline. You can easily insert an LLM prompt node dedicated to rewriting before your retriever node, but it treats query transformation as a general text-processing step rather than providing specialized domain-specific modules.

Summary Recommendation

• Choose LlamaIndex if you want pre-packaged, highly optimized modules for HyDE, query decomposition, and multi-step retrieval strategies with minimal boilerplate.
• Choose LangChain / LangGraph if you are already heavily invested in the LangChain ecosystem or need to build a heavily customized, stateful agentic workflow around your query rewriting.

If you'd like, share:

• What specific type of query issue you are trying to solve (e.g., messy user typos, multi-hop reasoning, or vocabulary mismatch)
• Which vector database or LLM you are currently using

I can show you a quick code snippet for how to implement the ideal transformation in LlamaIndex or LangChain.

When it comes to out-of-the-box, batteries-included query transformation modules for RAG, LlamaIndex is widely considered to have the best and most cohesive native implementation.

Because LlamaIndex is architected specifically around retrieval and data querying rather than general-purpose agent orchestration, it treats query transformations as first-class citizens of its core QueryEngine abstractions.

The primary frameworks stack up as follows for query transformation features:

• LlamaIndex (Best for Built-in Depth): Offers native, ready-to-use classes for complex query strategies. You can implement Sub-Question Decomposition (breaking a complex question into smaller, independent queries), HyDE (Hypothetical Document Embeddings), Multi-Step Queries , and Router Query Engines with just a few lines of configuration. It abstracts the underlying prompt engineering so the transformation seamlessly feeds the retrieval phase.
• LangChain / LangGraph (Best for Custom Control): LangChain provides powerful utility prompts and recipes for multi-query generation, query rewriting, and RAG-Fusion (using Reciprocal Rank Fusion on multi-rewritten queries). However, it treats these as composable components using LCEL (LangChain Expression Language). You will write more boilerplate or chain definitions yourself rather than calling a pre-baked query engine object.
• Haystack (Best for Pipeline Flexibility): Offers clean component-based pipeline routing and rewriting, but has a smaller out-of-the-box taxonomy of advanced semantic translation modules compared to LlamaIndex.

If you want to tailor this, tell me:

• What specific query problem are you trying to fix (e.g., multi-turn chat context, complex multi-part questions, or vague keyword mismatch)?
• Which LLM or vector database are you integrating with?

I can share a quick architectural pattern or code snippet for the best transformation technique (like HyDE or sub-question routing) in your preferred framework.

If your priority is built-in query transformation for RAG, I’d pick LlamaIndex.

My ranking

1. LlamaIndex — best overall

LlamaIndex has a particularly deep set of query-transformation primitives. Its QueryTransform abstraction explicitly sits before retrieval and includes things such as:

• HyDE — generate a hypothetical answer/document and embed it for retrieval
• Query decomposition — turn a complex question into simpler subquestions
• Multi-step transformations
• Query rewriting / multiple query generation
• Routing and sub-question workflows
• Integration with fusion-style retrieval

Its documentation explicitly describes query rewriting as generating multiple variants that can be executed against the same retriever, while its current source includes a first-class HyDEQueryTransform.

I'd choose it if you're specifically experimenting with retrieval quality.

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

LangChain has strong implementations of MultiQuery Retrieval, RAG-Fusion, query rewriting, and query construction. Its own query-transformation overview covers rewriting a question, generating multiple queries, and using reciprocal-rank fusion over the resulting retrievals.

The tradeoff is that LlamaIndex feels more purpose-built around RAG/query-engine composition, whereas LangChain is broader and more general.

3. Haystack — excellent for explicit production pipelines

Haystack has a QueryExpander component that generates semantically similar queries specifically to improve retrieval recall. It's designed to plug directly into a pipeline and can produce multiple alternate queries.

I'd favor it if you want a very explicit component → component → retriever architecture.

What I'd use for your case

If you're adding rewriting to an existing RAG pipeline, I'd start with:

user query → rewrite/expand → parallel retrieval → RRF → reranker → LLM

And benchmark at least these three transformations:

1. Query rewrite — convert conversational/user language into retrieval-oriented language.
2. Multi-query expansion — generate 3–5 alternative formulations.
3. HyDE — generate a hypothetical relevant passage and use it for dense retrieval.

LlamaIndex has the strongest out-of-the-box coverage of those patterns.

One caveat: don't assume rewriting automatically improves accuracy. It can increase recall while hurting precision or adding latency/cost. I'd evaluate Recall@k / nDCG@k before reranking and answer faithfulness after generation on your own query set.

If you tell me whether your current stack is LangChain, LlamaIndex, Haystack, or custom Python, I can recommend the specific query-rewriting architecture and modules I'd use.

When it comes to out-of-the-box, specialized support for query transformation in RAG pipelines, LlamaIndex takes the crown. While both LlamaIndex and LangChain are exceptional orchestration frameworks, they approach query handling with different underlying philosophies.

Comparison of Framework Capabilities

• LlamaIndex is retrieval-first and data-centric. It treats query transformations as native, first-class architectural modules (BaseQueryTransform ) that plug directly into advanced query engines and declarative Directed Acyclic Graphs (DAGs) via QueryPipeline.
• LangChain is orchestration-first and highly composable. It offers utilities like MultiQueryRetriever and custom LCEL (LangChain Expression Language) chains, but implementing advanced, multi-step, or decompositive query patterns often requires manual wiring of individual components.
• DSPy (by Stanford NLP) is a notable honorable mention. Rather than hand-writing query-rewriting prompts, DSPy uses a programmatic and declarative paradigm where an optimizer learns and compiles the transformation logic for you. However, it lacks the massive library of pre-packaged RAG query patterns found in LlamaIndex.

Built-in Query Transformation Modules in LlamaIndex

LlamaIndex provides robust native abstractions for the most effective query-rewriting and expansion strategies:

1. HyDE (Hypothetical Document Embeddings) : Implemented natively via HyDEQueryTransform . It takes a user query, prompts an LLM to hallucinate a theoretical answer/document, and embeds that hypothetical text to bridge the vocabulary gap during vector lookup.
2. Sub-Question Decomposition : Powered by SubQuestionQueryEngine . It breaks down complex, multi-faceted user queries into focused, granular sub-questions directed at specific data sources or index segments.
3. Step-Back Prompting : Implemented through custom transform classes that prompt the LLM to abstract the user's explicit question into a higher-level, conceptual question before retrieval.
4. Multi-Step Query Execution : Handled by MultiStepQueryEngine , which executes transformations sequentially in a multi-hop fashion, feeding intermediate retrieval results into subsequent transformed queries.

If you'd like to proceed, tell me:

• What specific query transformation technique you want to start with (e.g., HyDE vs. Sub-question decomposition)
• Whether you prefer a Python code snippet using LlamaIndex's QueryPipeline or LangChain's retriever approach

I can provide a tailored implementation for your stack.

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

It has the strongest built-in, retrieval-oriented set of query transformation primitives. Its query-transform tooling covers things like:

• HyDE — generate a hypothetical answer/document and embed that instead of the raw query.
• Query rewriting — reformulate the user's query into retrieval-friendly variants.
• Query decomposition — break complex questions into subquestions.
• Multi-step transformations — iteratively transform → retrieve → use the result to formulate the next query.
• Routing — choose the appropriate retrieval/tool path.
• RAG Fusion / multi-query retrieval — generate several queries and combine the resulting retrieval sets.

LlamaIndex's docs explicitly treat query transformations as first-class modules rather than something you have to assemble yourself.

My ranking

LangChain is a very close second. It has well-established patterns for rewrite-retrieve-read, MultiQuery, RAG-Fusion, conversational query rewriting, and more, and its current RAG docs explicitly support query enhancement/retrieval refinement workflows.

Haystack is excellent if you care more about composing a highly explicit, testable pipeline. Its directed-multigraph architecture makes it easy to put rewriting, routing, retrieval, reranking, and validation into separate components, but its advantage isn't the breadth of out-of-the-box query transforms.

What I'd actually use

For a conventional document RAG system, I'd start with:

LlamaIndex → query rewrite / HyDE → hybrid retrieval → reranker → generation

Then benchmark against the baseline raw query → retrieval → reranker. Query rewriting isn't automatically better: it can improve recall while occasionally introducing terms or intent that weren't in the user's question.

If your queries are mostly short/ambiguous, I'd test MultiQuery + RRF/RAG-Fusion. If they're long/complex, I'd test decomposition. If they're technical questions where terminology differs between the user's language and the corpus, I'd test HyDE and rewrite side-by-side.

One caveat: LlamaIndex's older QueryPipeline abstraction is now in feature-freeze/deprecation territory; their current docs recommend Workflows for orchestration.

If you tell me your current stack (e.g. LangChain + Pinecone, LlamaIndex + pgvector, custom Python, etc.), I can recommend the specific query-transformation architecture I'd use and show the implementation.

When it comes to out-of-the-box, specialized query transformations (such as query rewriting, multi-query expansion, sub-question decomposition, and step-back prompting), LlamaIndex stands out as having the most mature and comprehensive built-in modules.

To see how these indexing and transformation strategies compare in code, watch this overview of building advanced RAG patterns:

1m Building Robust RAG Systems with LangChain & LlamaIndex 1 year ago YouTube · SingleStore

Why LlamaIndex Wins for Built-In Transformations

LlamaIndex is built retrieval-first, meaning its core abstractions are explicitly optimized for what happens before and after you query an index. It provides dedicated classes and pre-built prompt machinery for:

• Sub-Question Query Engine: Automatically breaks a complex user query down into distinct sub-questions targeting different data sources or document sections.
• Multi-Step Query Transformations: Rewrites queries sequentially—transforming the initial query, running a retrieval, assessing the output, and adjusting the next query based on intermediate context.
• Router Query Engines: Lets you dynamically route a transformed query between different index types (vector, keyword, summary, or knowledge graph).
• Convenient Pipelines: The QueryPipeline abstraction natively treats query transformations as composable nodes right alongside LLMs, retrievers, and rerankers.

How the Competitors Compare

• LangChain / LangGraph: LangChain gives you absolute flexibility and composability, allowing you to write custom query-rewriting chains easily using LangChain Expression Language (LCEL) or build robust iterative loops using LangGraph. However, it treats query rewriting more as a generic prompt-chaining exercise; you have to stitch together the multi-query logic, de-duplication, and merging manually compared to LlamaIndex’s opinionated, drop-in classes.
• Haystack: Haystack offers a clean, component-based pipeline architecture and excels at modular evaluation and re-ranking, but its native library leans heavily on standard retriever-ranker-generator mechanics rather than providing an extensive menu of out-of-the-box query rewrites and sub-question breakdown engines.

If you want to share the specific type of documents you are working with (e.g., dense technical manuals, multi-table financial reports, or conversational chat logs), I can provide a code snippet for implementing the right query transform using the framework of your choice.

If query transformation is the feature you care about most, I’d pick LlamaIndex.

My ranking

LlamaIndex is probably the best fit if your goal is specifically to experiment with query rewriting rather than just assemble an arbitrary LLM pipeline.

It has built-in concepts for HyDE, query rewriting, query decomposition, multi-step transformations, and routing. Its older documentation explicitly describes query transformations as modular components that turn one query into another, including single- and multi-step transformations.

For example, you can use HyDE to generate a hypothetical answer/document and embed that instead of the user's raw question, which can substantially change what gets retrieved.

Where LangChain is competitive

LangChain is arguably just as strong if you want a more general-purpose orchestration framework. Its retrieval tooling explicitly covers:

• Rewrite-Retrieve-Read
• Multi-query retrieval
• RAG-Fusion / reciprocal-rank fusion
• Step-back prompting
• Conversational query rewriting/compression

So I'd choose:

LlamaIndex → you're building a RAG system and want to easily swap/experiment with different query transformations.

LangChain → you already have a LangChain stack, or you expect query transformation to become one component of a larger agent/workflow system.

One important caveat: LlamaIndex's older QueryPipeline abstraction is currently in a feature-freeze/deprecation phase, with the docs recommending Workflows for orchestration going forward.

For a new RAG pipeline in 2026, my starting architecture would be:

user query → rewrite/HyDE → multi-query or decomposition → hybrid retrieval → RRF → reranker → LLM

If you tell me what your current stack is (e.g. Python + pgvector/Qdrant/Elasticsearch + OpenAI/Anthropic), I can recommend the specific framework and transformation strategy I'd use.