LangChain, one building block at a time

The four message types

SystemMessage The rules

Instructions from your team: "You are a research assistant. Cite every claim."

HumanMessage The user's turn

"Is remote work better for productivity?"

AIMessage The model's turn

Either an answer, or a request to use a tool (Section 4).

ToolMessage A tool's result

What came back when your code ran the tool, such as a list of search results.

What it looks like in code

# Simplified. LangChain 1.x; check names against your version.
from langchain.chat_models import init_chat_model

model = init_chat_model("provider-a:large")   # real names look like "openai:…" or "anthropic:…"

reply = model.invoke("What is RAG in AI?")        # one full AIMessage
for chunk in model.stream("What is RAG in AI?"):  # the same reply, piece by piece
    print(chunk.text, end="")

class Report(BaseModel):                         # the shape we want back
    title: str
    paragraphs: list[str]
    citations: list[str]

writer = model.with_structured_output(Report)
report = writer.invoke(messages)                 # a Report object, not free text

Each call costs tokens, and providers price them differently. One interface makes it cheap to try a smaller model on a step and measure the difference.

The research assistant's write prompt

# Simplified.
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a research assistant. Use only the notes. Cite each claim as [n]."),
    ("human",  "Question: {question}\nNotes:\n{notes}"),
])
messages = prompt.invoke({"question": q, "notes": notes})   # blanks filled, no AI involved yet

System: Write a short report with citations.

Example question: How do index funds work?
Example report: An index fund copies a market
index, such as the Nifty 50 [1]. …
Now answer: {question}

Defining a tool

# Simplified.
from langchain.tools import tool

@tool
def web_search(query: str) -> str:
    """Search the web for credible, recent sources.
    Use a specific query of 3 to 8 words. Returns titles and URLs."""
    ...

model_with_tools = model.bind_tools([web_search])
reply = model_with_tools.invoke("Is remote work better for productivity?")
reply.tool_calls   # [{"name": "web_search", "args": {"query": "remote work productivity research"}, "id": "call_01"}]

@tool turns a normal function into a tool. The function name becomes the tool's name, the type hints become its inputs, and the text in quotes, called a docstring, becomes the description the model reads.

Writing good tool descriptions

name: search
description: Searches.

name: web_search
description: Search the web for credible,
recent sources. Use a specific query of
3 to 8 words. Returns titles and URLs.

When a tool fails

With agents, ready-made middleware (Section 8) can catch tool errors, retry and enforce limits. Exact class names vary by version.

Tools from MCP servers

You don't have to write every tool yourself. Many services publish their tools as an MCP server: search engines, Google Drive, Slack, GitHub, databases. An adapter package turns those tools into ordinary LangChain tools, so the agent uses them like any other.

# Simplified. The adapter lives in the langchain-mcp-adapters package.
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "search": {"transport": "streamable_http", "url": "https://mcp.search.example/mcp"},
    "library": {"transport": "stdio", "command": "python", "args": ["library_server.py"]},
})
tools = await client.get_tools()          # every tool the servers offer, as LangChain tools
agent = create_agent(model, tools=tools)

What it looks like in code

# Simplified. Loaders and stores come from different packages, depending on the source.
docs      = PyPDFLoader("library/hybrid-work-trial.pdf").load()
chunks    = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150).split_documents(docs)
store     = InMemoryVectorStore.from_documents(chunks, embeddings)
retriever = store.as_retriever(search_kwargs={"k": 4})

passages  = retriever.invoke("Does hybrid work affect resignations?")   # the 4 closest chunks

Try it: tune the retriever

The question is "Does hybrid work affect resignations?", asked of a small company library. The right passage is in the hybrid-work trial report. Change the settings and watch what reaches the model.

Making retrieval better

What it looks like in code

# Simplified.
write_report = prompt | model | parser                        # one after another

extract = RunnableParallel(summary=summarise, quotes=find_quotes)  # both at the same time

safe_model = model_a.with_fallbacks([model_b])                # if A fails, try B
safe_chain = write_report.with_fallbacks([fix_and_retry])     # the demo's "bad output format" fix

Running two steps in parallel cuts latency: two 2-second steps take about 2 seconds instead of 4.

What it looks like in code

# Simplified. In development, memory is saved in RAM; in production, in a database such as Postgres.
agent = create_agent(model, tools=[web_search], checkpointer=InMemorySaver())

config = {"configurable": {"thread_id": "user-42-chat-7"}}
agent.invoke({"messages": [{"role": "user", "content": "What is RAG in AI?"}]}, config)
agent.invoke({"messages": [{"role": "user", "content": "Shorter, please."}]}, config)  # remembers the first question

Deciding what it remembers

Long-term memory isn't saved in the checkpointer. In LangGraph it lives in a separate store, organised by user, and your code decides what goes in. Make these decisions before engineers build it.

Privacy laws, such as India's DPDP Act, expect a clear purpose, consent and deletion on request. A memory feature that users can't see or erase is hard to defend.

Middleware, explained simply

Middleware works like checkpoints at an airport. Passengers (messages and tool calls) move through the same route every time, and at each checkpoint a rule can inspect them, change them or stop them. You add a rule without rebuilding the airport.

The research assistant as an agent

# Simplified. Middleware names and options vary by version; check the docs.
from langchain.agents import create_agent

agent = create_agent(
    model="provider-a:large",
    tools=[web_search, fetch_page],
    system_prompt="You are a research assistant. Cite every claim as [n].",
    response_format=Report,                       # structured final answer (Section 2)
    middleware=[
        ModelCallLimitMiddleware(run_limit=12),   # stop runaway loops (module 1's cap: about 12 model calls)
        SummarizationMiddleware(...),             # shrink long histories
        HumanInTheLoopMiddleware(...),            # approve chosen tool calls
    ],
)
result = agent.invoke({"messages": [{"role": "user", "content": question}]})

create_agent replaced an older LangGraph helper, create_react_agent. If your flow needs fixed steps, branches or custom checks, such as module 2's grade-and-rewrite loop, engineers build a custom graph in LangGraph instead (Module 4).

Alternatives your engineers may mention

This space changes quickly. Treat these as examples, not a ranking, and check each project's current docs.

Questions to ask your engineering team