LangChain — LLM Application Framework

Before you start: basic familiarity with calling an LLM API directly (a single request/response, a system prompt) is assumed — see the OpenAI API or LLM Engineering courses first if those are new. No prior framework experience is required.

LangChain is the most widely used framework for building applications powered by Large Language Models (LLMs). It provides abstractions for chains, agents, memory, and retrieval that make production AI systems practical to build.

Why This Exists (The Hook)

A single raw API call to an LLM is easy. The moment a real application needs to retry on failure, stream partial output, remember earlier turns of a conversation, let the model call a search tool, and swap from OpenAI to Anthropic without rewriting everything — that's a lot of infrastructure code to hand-roll and maintain yourself, for every single project. LangChain exists because that infrastructure is the same shape across almost every LLM application, so it's built once as a reusable framework instead of every team writing their own retry/streaming/memory glue code from scratch.

Analogy — Calling an LLM API directly is like wiring a single lightbulb yourself — straightforward, but you're handling the wiring, the switch, and the fuse box every time. LangChain is like a house's electrical system: standardized components (chains, retrievers, memory) that snap together through common interfaces, so swapping one lightbulb (one LLM provider) for another doesn't mean rewiring the whole house.

Try it (2 minutes) — Reason through the tradeoff without installing anything: for a script that makes exactly one LLM call with no retries, no memory, and no tool use, would LangChain's abstractions save you meaningful code, or just add a dependency you don't need? Now imagine the same script needs to add conversation memory and swap providers next month — at what point does the raw-API version start accumulating its own ad-hoc version of what LangChain already provides?

What is LangChain?

LangChain is an open-source framework that helps you:

Core Concepts

LLMs / Chat Models — The AI model itself. LangChain supports OpenAI, Anthropic, Google, Mistral, Ollama (local), and 50+ others through a unified interface.

Prompts — PromptTemplates with variables. Reusable, testable prompt structures.

Chains — Sequences of operations. Input → LLM → Output → Next LLM → Final Output.

Retrievers — Fetch relevant documents from a knowledge base for RAG.

Agents — LLMs that autonomously decide which tools to use and in what order.

Memory — Persist conversation history across turns.

Tools — Functions the agent can call (search, calculator, API calls).

LangChain vs. Raw API

# Without LangChain
import openai
response = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": f"Answer: {question}"}]
)
# Need to handle: retries, streaming, output parsing, memory, tools...

# With LangChain
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4")
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("user", "{question}")
])
chain = prompt | llm  # LCEL pipe syntax
response = chain.invoke({"question": "What is Kubernetes?"})
# Handles: retries, streaming, type safety, tracing, testing

When to Use LangChain

✅ Building RAG systems (document Q&A)

✅ Multi-step AI workflows

✅ AI agents with tool use

✅ Chatbots with memory

✅ When switching between LLM providers

⚠️ Consider alternatives (raw API) when: