Overview of Chains

In this lesson we cover how to implement and choose between common chain patterns in LangChain for working with multiple documents and retrieval-augmented generation (RAG) workflows. We focus on two built-in chain constructs:

The “stuff” chain
The “retrieval” chain

These building blocks are central when you need to combine multiple documents, summarize content, or answer questions over large collections.

In this article, “stuff” refers to the approach that formats and injects multiple documents directly into a single prompt, while “retrieval” refers to the pattern that first fetches relevant chunks from a retriever (e.g., a vector store) before combining them for the LLM.

What is a chain in LangChain?

A chain in LangChain is a pipeline that orchestrates one or more steps (prompts, LLM calls, retrievers, combiners) to produce a final output. Chains make it easier to standardize how you prepare context, call an LLM, and post-process results for tasks like summarization, extraction, and QA.

1) Stuff chain (combine by concatenation)

The StuffDocumentsChain (often called the “stuff” combiner) concatenates a list of documents, formats them into a single prompt, and sends that prompt to the LLM in a single call. When to use:

The combined size of all documents fits within the LLM’s context window.
You prefer a straightforward, deterministic single-pass approach (e.g., summarization, extraction).

Advantages:

Simple and fast: one LLM call with all context.
Deterministic: model sees all provided content at once, which can help for faithful summarization or extraction.

Limitations:

Not viable if the total tokens exceed the model’s context window.
Inefficient if many documents are irrelevant to the query.

Example usage:

from langchain.chains.combine_documents.stuff import StuffDocumentsChain

# llm: an instantiated LLM
# prompt: your PromptTemplate or prompt string
stuff_chain = StuffDocumentsChain(llm=llm, prompt=prompt)

# documents: a list of langchain.schema.Document objects
result = stuff_chain.run(documents)
print(result)

Tips:

Pre-filter documents if you cannot guarantee they will always fit.
Use concise prompts and templates to reduce token usage.

2) Retrieval chain (RAG-style)

When your document collection is too large for a single prompt, use a retrieval-style chain. This pattern fetches relevant chunks from a retriever (vector DBs like FAISS, Chroma, Milvus, Pinecone, etc.), then combines the retrieved chunks into a prompt using a combiner (e.g., “stuff”, “map_reduce”, “refine”) before calling the LLM. This is the common Retrieval-Augmented Generation (RAG) flow: retrieve → combine → generate. When to use:

Your corpus is large or contains long documents.
You need better precision by narrowing context to the most relevant chunks.

Advantages:

Scales to very large document collections.
Focuses the LLM on relevant context, improving answer quality and reducing cost.
Allows indexing, caching, and faster repeated queries.

Limitations:

Requires an index and retriever infrastructure.
Adds retrieval latency and tuning complexity (chunk size, embedding model, similarity metrics).

Typical pattern with LangChain’s RetrievalQA helper:

from langchain.chains import RetrievalQA

# llm: your LLM instance
# retriever: retriever from a vector store (e.g., faiss_retriever)
retrieval_qa = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",   # or "map_reduce", "refine" depending on your combine strategy
    retriever=retriever
)

answer = retrieval_qa.run("What is the summary of topic X?")
print(answer)

Additional notes:

The chain_type selects the combiner strategy used after retrieval.
For extremely long collections, map_reduce first summarizes chunks (map) then combines summaries (reduce).
refine iteratively improves an initial answer using additional context.

Compare chains: quick reference

Chain Type	Best for	Key advantages	Example usage
`stuff`	Small collections or when all context fits in the model	Simple, single LLM call, deterministic	`StuffDocumentsChain(llm=llm, prompt=prompt)`
`retrieval` (RAG)	Large collections, many documents, or long docs	Scales, focuses on relevant chunks, more efficient	`RetrievalQA.from_chain_type(llm=llm, retriever=retriever)`
`map_reduce` (combiner)	Very large inputs where summarization per chunk helps	Summarizes chunks first, reduces prompt size	Use as `chain_type="map_reduce"` in RetrievalQA
`refine` (combiner)	When iterative improvement yields better quality	Improves answers stepwise with more context	Use as `chain_type="refine"` in RetrievalQA

Choosing the right combine strategy

Selecting a combiner depends on:

Context window size of your LLM (e.g., 8k, 32k tokens).
Document size and number of documents.
Desired latency vs. quality trade-offs.

Guidelines:

If total tokens << context window: prefer stuff for simplicity.
If documents are many or long: use a retrieval chain with map_reduce or refine.
If you need higher accuracy and can afford extra calls, prefer refine.
If you need the fastest throughput and context fits: stuff is usually best.

Choosing the right combiner (e.g., stuff, map_reduce, refine) affects quality and cost: stuff is fast and simple, map_reduce reduces token usage by summarizing pieces first, and refine iteratively improves an answer and can yield higher-quality responses.

Example end-to-end flow (retrieval + stuff)

Index documents into a vector store (FAISS, Chroma, etc.) with embeddings.
Create a retriever from the vector store.
Instantiate a RetrievalQA chain using chain_type="stuff" (or a different combiner).
Run queries to retrieve relevant chunks and generate answers.

Minimal skeleton:

# 1. Indexing (pseudo)
# embeddings = embed_model.embed_documents(doc_texts)
# 2. Create retriever
retriever = vector_store.as_retriever(search_k=10)

# 3. Create RetrievalQA chain
from langchain.chains import RetrievalQA
retrieval_qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever)

# 4. Run a query
answer = retrieval_qa.run("Explain the main points about X.")
print(answer)

Practical tips for production

Monitor token usage and costs when using stuff on many documents.
Tune chunk size and overlap at indexing time to balance retrieval relevance and context length.
Cache frequent retrieval results or answers to reduce repeated costs.
Test different combiner strategies on a validation set to pick the best trade-off of cost and quality.

Summary

Stuff chain: concatenates documents into a single prompt and works well when everything fits in the LLM context window.
Retrieval chain: retrieves relevant chunks from a vector store and then combines them (often via stuff, map_reduce, or refine) before calling the LLM; it scales to large document collections.
Choose between them based on corpus size, LLM context limits, latency, and quality needs.

Links and references

LangChain documentation
FAISS: https://github.com/facebookresearch/faiss
Chroma: https://www.trychroma.com/
Overview on RAG patterns: https://arxiv.org/abs/2005.11401

Introduction

Overview of LangChain

Key Components of LangChain

Interacting with LLMs

Tips, Tricks, and Resources

Introduction to LCEL

Adding Memory to LLM Apps

Performing Retrieval

Implementing Chains

Using Tools

Building Agents

Conclusion

Building Blocks of LLM Apps

Overview of Chains

What is a chain in LangChain?

1) Stuff chain (combine by concatenation)

2) Retrieval chain (RAG-style)

Compare chains: quick reference

Choosing the right combine strategy

Example end-to-end flow (retrieval + stuff)

Practical tips for production

Summary

Links and references

Watch Video

​What is a chain in LangChain?

​1) Stuff chain (combine by concatenation)

​2) Retrieval chain (RAG-style)

​Compare chains: quick reference

​Choosing the right combine strategy

​Example end-to-end flow (retrieval + stuff)

​Practical tips for production

​Summary

​Links and references

Watch Video

What is a chain in LangChain?

1) Stuff chain (combine by concatenation)

2) Retrieval chain (RAG-style)

Compare chains: quick reference

Choosing the right combine strategy

Example end-to-end flow (retrieval + stuff)

Practical tips for production

Summary

Links and references