Quick answer: Define tools with the @tool decorator, pass them to create_react_agent or AgentExecutor, and cap the loop with max_iterations. Setup is about 20 lines.

Fair warning up front: agents are slower and cost more than a fixed chain. Every tool call is another round trip to the model. I only reach for one when the path genuinely depends on the input.

When should you use an agent instead of a chain?

Use an agent when the number of steps is unknown at build time. A support bot that might check an order, then refund it, then email the customer fits. A summarizer that always loads a doc and summarizes fits a chain, and running it as an agent just adds latency and failure points.

How do you define a tool in LangChain?

The decorator route is cleaner than the old dictionary style because the docstring becomes the description the model reads when deciding whether to call it.

from langchain_core.tools import tool

@tool
def get_order_status(order_id: str) -> str:
    """Look up the shipping status for an order ID."""
    return db.fetch(order_id)

The docstring is not decoration. Vague descriptions are the single biggest cause of an agent calling the wrong tool.

How do you wire the agent together?

LangGraph is the current recommended path; the older AgentExecutor still ships but the team pushes people toward graphs for anything with branching.

from langchain.agents import create_react_agent, AgentExecutor
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o", temperature=0)
agent = create_react_agent(llm, [get_order_status, search_docs], prompt)
executor = AgentExecutor(agent=agent, tools=[get_order_status, search_docs],
                         max_iterations=6, verbose=True)
print(executor.invoke({"input": "Is order A19 shipped?"}))

Set max_iterations. Without it a confused agent will keep calling tools until you hit a rate limit or your budget does.

Chain vs agent: which fits your case?

How do you debug a misbehaving agent?

Turn on verbose=True first. Nine times out of ten you see the model picking a tool that does not match the intent, and the fix is a sharper docstring or a tighter parameter type. LangSmith, the vendor’s tracing tool, has a free tier and shows every step; it is worth the extra setup once your agent has more than three tools.

What does it cost to run?

An agent with a couple of steps on GPT-4o runs roughly $0.03-$0.10 per conversation; the same task on a fixed chain is closer to a cent. If you are on gpt-4o-mini, multiply your expectations down by 10-15x. There is no LangChain fee — you pay your provider.

What are the limits people hit?

• Looping: the agent retries the same failing tool. Cap iterations and add a fallback message.
• Tool sprawl: past 10-15 tools, selection accuracy drops. Split into sub-agents.
• Silent errors: a tool returning an empty string looks like success. Return explicit error text.
• Version churn: package names moved between 0.1 and 0.3; pin your versions.

Who this suits: teams building assistants that need to act, not just answer. Who should wait: if your task is a fixed pipeline, an agent will be slower and harder to test. Build the chain first.

Quick Summary

• Agents let the model choose tools; chains run a fixed path.
• Define tools with @tool and a clear docstring the model can read.
• Always set max_iterations to stop runaway loops.
• Expect 3-10x the cost and latency of an equivalent chain.
• LangGraph is the recommended structure for branching agents in 2026.

Quick answer: Install LangChain with pip install langchain langchain-openai, set your API key, and you can have a working question-answering chain in about 30 minutes.

I keep the scope tight on purpose. Most tutorials try to cover agents, memory, and 12 integrations at once, and you end up copying code you don’t understand. Here you get one chain that works, then a few notes on where to go next.

What do you need before starting?

Python 3.10 or newer, and an API key from any provider LangChain supports. OpenAI works out of the box, but the same code runs on Anthropic, Google, or a local Ollama model with a three-line swap.

You do not need a GPU. The heavy lifting happens on the provider’s servers. Budget roughly $0.01-$0.05 per run on a mid-size document with GPT-4o-mini class models.

How do you install LangChain?

LangChain split into packages in late 2024, so install the core plus the integration you need. The old monolithic langchain package still works but wires up everything, which is slower to import.

pip install langchain langchain-openai langchain-community pypdf

Then export your key. Never hardcode it.

export OPENAI_API_KEY="sk-..."

How do you load and split a PDF?

Loaders live in langchain-community. Splitting matters more than people expect: chunks of 800-1000 characters with 100 characters of overlap tend to retrieve better than one giant blob.

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

docs = PyPDFLoader("report.pdf").load()
chunks = RecursiveCharacterTextSplitter(
    chunk_size=900, chunk_overlap=120
).split_documents(docs)

How do you store the chunks and retrieve answers?

Vector stores turn text into embeddings so you can search by meaning. Chroma is the least painful local option, and you can always move to a hosted store later.

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_chroma import Chroma
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate

store = Chroma.from_documents(chunks, OpenAIEmbeddings())
retriever = store.as_retriever(search_kwargs={"k": 4})

prompt = ChatPromptTemplate.from_template(
    "Answer using only this context:\n{context}\n\nQuestion: {question}")

chain = ({"context": retriever, "question": RunnablePassthrough()}
         | prompt | ChatOpenAI(model="gpt-4o-mini") | StrOutputParser())

print(chain.invoke("What was Q3 revenue?"))

The | operator is the part worth understanding. Each piece takes the previous output and passes it forward. Debugging is easier when you print the output of each step instead of the final answer only.

Is LangChain free?

The library is MIT licensed and costs nothing. You pay your model provider. Running GPT-4o-mini over a 40-page PDF costs a few cents per question; the same query on a frontier model can be 20-50x more.

What are the common mistakes?

• Chunks too large, so the retriever pulls irrelevant text and the model drifts.
• Forgetting overlap, which cuts sentences in half at boundaries.
• Not setting k, so you get the default handful of chunks whether or not they help.
• Ignoring langchain_text_splitters as a separate package and hitting import errors.

Who this suits: developers who want to prototype RAG or tool-calling apps without building the glue from scratch. Who should skip it: if you only need a chat completion call, the raw OpenAI SDK is less code and fewer version upgrades.

Quick Summary

• LangChain is a free open-source framework for connecting LLMs to data and tools.
• Install with pip install langchain langchain-openai plus a vector store package.
• Split documents into 800-1000 character chunks with overlap for better retrieval.
• You pay only your model provider, typically cents per query.
• Best for RAG and agent prototypes; overkill for a single chat call.