3 Summarizing text using LangChain

This chapter moves from concepts to practice by building summarization engines with LangChain’s Expression Language (LCEL). It frames summarization as a pragmatic first step for LLM applications and focuses on real-world scenarios: documents that exceed a model’s context window, summarization across multiple sources, and cases involving structured data. The chapter emphasizes how chains—ordered, composable steps—let you automate summarization reliably and lay the groundwork for more advanced systems later.

For single documents that don’t fit in the context window, the chapter adopts a map-reduce pattern. The text is tokenized and split into overlapping chunks, each chunk is summarized (map), and the resulting summaries are condensed into a final synthesis (reduce). LCEL makes this composition explicit and reusable: text splitting via a RunnableLambda, prompting with PromptTemplate, inference through an LLM, output parsing with StrOutputParser, and parallelization with RunnableParallel. Practical guidance includes choosing chunk sizes, managing overlaps, and accounting for token limits, latency, costs, and rate limiting.

For multiple documents, the same map-reduce idea can be applied across a list of LangChain Document objects created with loaders (e.g., for Wikipedia, Word, PDF, and text). The chapter also introduces the refine technique, which incrementally updates a running summary by combining it with each document in turn—useful when you want high fidelity to every source. A simple decision flow emerges: if your material fits in the context window, “stuff” it into one prompt; if not, use map-reduce for scale and throughput, and prefer refine when preserving the essence of each part is critical. Together, these patterns demonstrate how to orchestrate summarization across large, diverse inputs and prepare for structured-data scenarios explored later.

Summarizing a document bigger than the LLM’s context window: this involves splitting the document into smaller chunks, summarizing each chunk, and then summarizing the combined chunk summaries.

Summarizing across documents using the Map-Reduce technique seen earlier: in this method, each document chunk undergoes a map operation to generate a summary. These individual summaries are then further condensed into a single summary through the reduce operation.

Summarizing across documents using the Refine technique: with this approach, a final summary is constructed incrementally by iteratively summarizing the combination of the current final summary and one of the document chunks. This process continues until all document chunks have been processed, resulting in the completion of the final summary.

Summarization flowchart This flowchart guides you in selecting the right summarization approach based on whether you need to summarize multiple unrelated documents and whether the input text fits within the context window

• Summarization is a great starting point for building LLM applications due to its straightforwardness.
• The choice of technique depends on whether you're summarizing a single document or multiple documents and if the text fits within the context window.
• Typically, the first step in summarization involves loading each raw text source into a LangChain Document object.
• For many summarization tasks, a map-reduce approach is effective. This method summarizes each document or chunk individually in the "map" stage, then combines these summaries in the "reduce" stage to create a final summary.
• When summarizing multiple documents, load each document with the appropriate loader, summarize them individually, and progressively refine the summary by integrating each document’s summary until all are included.
• Map-reduce is suited for large text summaries where some content loss is acceptable to handle the processing load, while the refine technique ensures the essence of each part is fully retained in the final summary.

FAQ