Chains

The name LangChain highlights that the framework is centered on chains — composable pipelines that connect modular components to perform multi-stage tasks. Chains let you assemble prompts, models, functions, retrievers, output parsers, memory, and even other chains into a single workflow that produces a final result for your application. Chains can be composed in different topologies:

Sequential: components run in a defined order, with each step receiving the previous step’s output (for example: prompt → LLM → output parser).
Parallel / concurrent: multiple components run at the same time (for example: multiple retrievers or API calls), and their outputs are aggregated and passed downstream.
Conditional / routing: logic chooses which sub-chain to run based on input or intermediate results.
Stateful / memory-enabled: chains incorporate memory components to maintain context across invocations (useful for chat or multi-turn workflows).

The image shows a stylized chain divided into three colored sections labeled "Prompts," "Models," and "Functions." The sections are connected, visually representing a process or workflow.

Practical patterns and when to use them:

One-off responses: Use a minimal sequential chain (prompt → LLM) when you only need a single formatted response.
Retrieval-augmented generation (RAG): Add a retriever step before the LLM to fetch relevant documents from a knowledge base, then synthesize the retrieved context with the model output.
Enforced output format: Insert an output parser after the model to validate, normalize, or transform responses into structured formats (JSON, CSV, etc.).
Stateful conversations: Add memory to persist prior conversation turns or results and feed them back into the prompt/context.
Parallel enrichment: Run multiple retrievers, APIs, or models in parallel and then aggregate outputs (rank, dedupe, or fuse) before the final step.
Composability: Build sub-chains and reuse them as single components inside larger pipelines.

Table: Common chain types, use cases, and conceptual examples

Chain Type	Use Case	Conceptual Example
Sequential	Single linear flow (prompt → model → parser)	`prompt -> LLM -> OutputParser`
Retrieval + LLM (RAG)	Augment model with external documents	`retriever -> combine -> LLM -> parser`
Parallel / Concurrent	Enrich results or call multiple APIs concurrently	`parallel([retrieverA, retrieverB]) -> aggregate -> LLM`
Router / Conditional	Route input to different sub-chains	`router(input) -> subchainA	subchainB`
Stateful (Memory)	Maintain context across turns	`memory + prompt -> LLM -> memory.update()`

Example snippets (conceptual pseudo-code)

Simple sequential chain (prompt → LLM → parser)

# Pseudo-code (conceptual)
prompt = PromptTemplate("Summarize the text: {text}")
llm_output = LLM.call(prompt.format(text=article))
structured = OutputParser.parse(llm_output)
return structured

Retrieval-augmented generation (RAG) with a retriever and combiner

# Pseudo-code (conceptual)
query = "What does the user ask about X?"
docs = Retriever.search(query, top_k=5)        # fetch relevant documents
context = Combiner.combine(docs)               # combine/truncate for context window
response = LLM.call(prompt_with_context(query, context))
return OutputParser.parse(response)

Parallel retrieval and aggregation

# Pseudo-code (conceptual)
results = parallel_run([RetrieverA.search(q), RetrieverB.search(q)])
merged = deduplicate_and_rank(results)
answer = LLM.call(prompt_with_context(q, merged[:10]))

Best practices

Keep chains modular: encapsulate repeatable logic in sub-chains and reuse them as building blocks.
Validate outputs: use output parsers or schema validators early when the downstream system expects structured data.
Control context size: when combining many documents or tool outputs, apply truncation or scoring to fit the model’s context window.
Monitor latency and cost: parallel steps can increase responsiveness but may also raise cost; balance concurrency with budget and SLAs.
Version and test sub-chains: since chains are composable, maintaining tests for each sub-chain prevents regression when reusing them.

Chains provide a modular way to build complex pipelines by combining prompts, models, retrieval, parsing, and functions into reusable units.

Chains are a foundational capability in LangChain. For implementation details and API-specific examples, see the official LangChain documentation: LangChain — Chains and related guides for retrieval, memory, and output parsers.

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

Watch Video