LangChain

LangChain is a framework for building applications powered by large language models. It gives you two things: standard interfaces over many providers (so swapping OpenAI for Anthropic is a one-line change) and composition primitives to wire models, prompts, retrievers, and tools into pipelines.

LangChain's value isn't the model — it's the glue: a common abstraction for models, prompts, parsers, and retrievers, plus a way to chain them and observe what happened.

The codebase is split into focused packages:

• langchain-core — the base abstractions (Runnables, messages, prompts, output parsers). Lightweight, few dependencies.
• langchain — higher-level chains, agents, and retrieval strategies.
• integration packages — langchain-openai, langchain-anthropic, etc., one per provider.
• langchain-community — community-maintained integrations.

The core object is a chat model — it takes a list of messages and returns an AIMessage. Messages carry a role: SystemMessage, HumanMessage, AIMessage.

Prompt templates turn variables into messages so prompts are reusable and testable:

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a {role}."),
    ("human", "{question}"),
])
prompt_value = prompt.invoke({"role": "tutor", "question": "What is RAG?"})
messages = prompt_value.to_messages()  # PromptValue -> list of messages

LCEL (LangChain Expression Language) is how you compose components. Every component — prompt, model, parser, retriever — implements the Runnable interface, so they share the same methods and snap together with the pipe operator |.

from langchain_core.output_parsers import StrOutputParser

chain = prompt | model | StrOutputParser()
chain.invoke({"role": "tutor", "question": "What is RAG?"})

The Runnable interface gives every chain the same execution methods for free:

• invoke() — run once on a single input.
• batch() — run on many inputs concurrently.
• stream() — yield output tokens as they're generated.
• async variants — ainvoke, abatch, astream.

Models return free-form text; output parsers turn that into something your code can use, as the last step of a chain.

• StrOutputParser — pull the plain string out of an AIMessage.
• JSON / Pydantic parsers — coerce the response into a typed object and validate it.

The more robust modern approach binds a schema directly to the model:

structured = model.with_structured_output(MySchema)
structured.invoke("Extract the fields from: ...")

RAG (Retrieval-Augmented Generation) grounds an LLM in your own data: fetch relevant documents, put them in the prompt, then answer. The ingestion pipeline:

1. Document loaders read sources (PDFs, web pages, databases) into Document objects.
2. Text splitters chunk long documents so each piece fits the embedding and context limits.
3. Embeddings convert each chunk into a vector capturing its meaning.
4. Vector store indexes the vectors for similarity search (Chroma, FAISS, pgvector, Pinecone).

At query time a retriever embeds the question, finds the nearest chunks, and the chain stuffs them into the prompt as context.

LLM calls are stateless — the model only knows what's in the current request. To hold a conversation you must pass prior turns back in yourself.

• Keep a message history per session and prepend it to each new prompt, often via a MessagesPlaceholder in the template.
• RunnableWithMessageHistory wraps a chain to load and save history automatically, keyed by a session id.
• For long chats, trim or summarize old turns so you stay within the context window and control token cost.

A tool is a function the model can choose to call — a calculator, a search API, a database query. An agent is an LLM in a loop: it decides which tool to call, sees the result, and repeats until it can answer.

from langchain_core.tools import tool

@tool
def get_weather(city: str) -> str:
    """Return the weather for a city."""
    return lookup(city)

model_with_tools = model.bind_tools([get_weather])

The flow: bind_tools exposes the schemas to the model; the model replies with tool calls; your code runs the tools and feeds results back as ToolMessages; the loop continues.

LangGraph is LangChain's library for stateful, multi-step agent workflows modeled as a graph: nodes do work, edges decide what runs next, and a shared state object flows through. Unlike a straight LCEL chain, a graph supports cycles, branching, persistence, and human-in-the-loop pauses.

Rule of thumb: a linear pipeline → LCEL chain; a looping, branching, stateful agent → LangGraph. It's the recommended path for production agents over the older AgentExecutor.

Around the framework:

• LangSmith — tracing, debugging, and evaluation; see every step, token, and latency of a run.
• Streaming & callbacks — stream tokens or intermediate events to a UI; hook callbacks for logging and metrics.