LangChain

What LangChain Does:

LangChain is an open-source framework that provides building blocks and abstractions for creating LLM applications. It handles the boilerplate of connecting LLMs to data sources, tools, and memory so you can focus on application logic.

Think of LangChain as the Express.js of AI applications - it gives you a structured way to build things, with middleware (chains), route handlers (tools), and session management (memory).

Real-World Analogy - Zomato Order System:

Building an LLM app without LangChain is like running a restaurant without a POS system - you manually take orders, relay to kitchen, track payments. LangChain is like installing a Zomato POS:

• Chains = Order Flow: Customer orders -> Kitchen prepares -> Quality check -> Serve (sequenced steps)
• Tools = Kitchen Equipment: Oven, mixer, fridge - each does a specific job when needed
• Memory = Customer History: "Your usual paneer tikka, sir?" - remembering past interactions

LangChain Ecosystem (2025):

• langchain-core: Base abstractions (Runnables, messages, prompts)
• langchain: Chains, agents, and retrieval strategies
• langchain-community: 600+ third-party integrations
• LangGraph: Stateful agent workflows (separate package)
• LangSmith: Tracing, debugging, evaluation (separate SaaS)
• LangServe: Deploy chains as REST APIs

Honest Assessment:

LangChain is both the most used and the most criticized LLM framework. It is great for prototyping and has the largest ecosystem. But its abstractions can be confusing, debugging can be hard, and for production you often need to go lower-level. Know its strengths and limitations.

What are Chains?

A Chain is a sequence of steps where the output of one step feeds into the next. The simplest chain: Prompt Template -> LLM -> Output Parser. More complex chains can include retrieval, tool calls, branching, and parallel execution.

LCEL (LangChain Expression Language):

LCEL is the modern way to compose chains in LangChain. It uses the pipe operator (|) to connect Runnables:

chain = prompt | llm | output_parser

Every component in LCEL implements the Runnable interface with methods: invoke(), stream(), batch(), ainvoke() (async). This gives you streaming, batching, and async for free.

Common Chain Patterns:

• Simple Chain: prompt | llm | parser - For straightforward LLM calls
• Retrieval Chain: retriever | format_docs | prompt | llm - RAG pattern
• Sequential Chain: chain1 | chain2 - Output of first feeds into second
• Parallel Chain: RunnableParallel runs multiple chains simultaneously and combines results
• Branching Chain: RunnableBranch routes input to different chains based on conditions

Legacy vs Modern:

What are Tools?

A Tool in LangChain is a function that an LLM can decide to call. It has a name, description (tells the LLM when to use it), and a function (the actual code to execute). The LLM reads tool descriptions and decides which tool to use based on the user question.

Built-in Tools:

• Search: Tavily, Google Search, Wikipedia, DuckDuckGo
• Code: Python REPL, shell execution
• APIs: HTTP requests, OpenAPI spec execution
• Math: Calculator, Wolfram Alpha
• Retrieval: Any retriever can be wrapped as a tool

Creating Custom Tools:

There are two main ways to create custom tools:

• @tool decorator: Simplest approach. Decorate any Python function. The docstring becomes the tool description. Type hints define the schema.
• StructuredTool: More control. Define name, description, and args_schema (Pydantic model) explicitly. Better for complex inputs.

Best practice: Write detailed descriptions that tell the LLM WHEN to use the tool, not just WHAT it does. "Use this tool to get current stock prices for Indian NSE/BSE listed companies" is better than "Gets stock prices."

Agents - LLMs That Choose Tools:

An Agent is an LLM that decides which tools to call and in what order. LangChain supports several agent types, but the recommended one for 2025+ is create_react_agent (or LangGraph for complex cases).

The agent loop: User input -> LLM decides action -> Tool executes -> LLM sees result -> Decides next action or responds.

The Memory Problem:

LLMs are stateless - each API call is independent. Without memory, every message is treated as a brand new conversation. Memory solves this by storing and injecting conversation history into each new LLM call.

Memory Types in LangChain:

• ConversationBufferMemory: Stores complete conversation history. Simple but context window fills up fast. Good for short conversations (5-10 turns).
• ConversationSummaryMemory: Uses an LLM to summarize older messages. Keeps context small. Costs extra LLM calls for summarization.
• ConversationBufferWindowMemory: Keeps only last k messages. Simple sliding window. Loses older context but predictable token usage.
• ConversationTokenBufferMemory: Keeps messages up to a max token count. More precise than window-based.

Modern Approach - RunnableWithMessageHistory:

The modern LangChain way to handle memory uses RunnableWithMessageHistory wrapper instead of legacy Memory classes. It wraps any chain and automatically loads/saves message history using a configurable backend (in-memory, Redis, PostgreSQL, etc.).

Key advantage: The session_id parameter lets you maintain separate conversation threads for different users - essential for multi-user production apps.

Memory Best Practices:

• Use Redis or PostgreSQL for production memory storage (not in-memory)
• Set a token limit to prevent context overflow
• For RAG chatbots, store only Q&A pairs in memory, not the full retrieved context
• Consider using conversation summary for long sessions

Criticism 1: Abstraction Overload

LangChain wraps everything in abstractions. Sometimes you just want to call the OpenAI API directly, but LangChain adds layers of Runnables, Chains, and wrappers. For simple use cases, these abstractions add complexity without value.

Criticism 2: Debugging Difficulty

When something goes wrong inside a chain, error messages can be cryptic. The deep abstraction layers make it hard to trace where exactly a failure occurred. LangSmith helps, but it is a paid service.

Criticism 3: Rapid Breaking Changes

LangChain evolves very fast. Code from 6 months ago often does not work with the latest version. Legacy patterns (LLMChain, ConversationChain) are deprecated frequently.

When LangChain Shines:

• Prototyping: Fastest way to build a RAG demo or agent prototype
• Integration variety: 600+ integrations for every vector DB, LLM, and tool
• Learning: Great for understanding LLM application patterns
• Standard patterns: When your use case fits a common pattern (RAG, chatbot, agent)

When to Skip LangChain:

• Simple apps: Direct API calls with the openai/anthropic SDK are simpler
• Production RAG: Consider Haystack for type safety and reliability
• Complex agents: LangGraph (separate from LangChain) or custom solutions
• Performance critical: The abstraction layers add latency

Q: What is LCEL and why did LangChain introduce it?

Q: How does memory work in LangChain and what are the different types?

Q: What are the main criticisms of LangChain and when would you avoid using it?