Taking LangChain to Production

This module doesn’t teach new mechanics. Every single item below, you’ve already learned, somewhere in the previous thirty-two modules. Its job is different: pulling those scattered threads into one real, practical checklist — the kind you’d actually walk through before shipping a LangChain application to real users.

The checklist, with each item traced back to where you actually learned it

Timeouts and retries. Recall Module 4’s timeout parameter and Module 27’s .with_retry(). Every real model call in production should have both, deliberately configured, not left at silent defaults.

Fallbacks. Recall Module 27’s .with_fallbacks(). A genuinely resilient application has a real, tested backup path for when a primary provider fails.

Secrets management. Recall Module 3’s .env and .gitignore discipline. In production, this typically graduates to a real secrets manager provided by your hosting platform, but the underlying principle — never hardcoded, never committed — stays identical.

Recursion limits. Recall Module 15’s recursion_limit and Module 17’s GraphRecursionError. Every deployed agent needs a deliberate cap, and your application needs to genuinely handle hitting it gracefully, not crash.

Guardrails. Recall Module 28 — input validation, output validation, tool restrictions, and human approval for genuinely high-stakes actions, all implemented as real, code-level middleware, not just prompt instructions.

Persistent memory. Recall Module 19’s honest warning — InMemorySaver disappears on restart. Production needs a real, persistent checkpointer backed by an actual database.

Observability. Recall Module 29 — tracing should be on continuously, with meaningful metadata attached, before you need it, not enabled reactively after a real incident.

Cost awareness. Recall Module 18’s response-format cost concern and Module 19’s growing-history cost concern — real, measured token usage, tracked per feature and per user, not discovered for the first time on a surprise bill.

Testing. Recall Module 30 — a real, layered suite: fast, free, mocked tests running constantly, genuine integration tests run more deliberately before release.

Example: a genuinely production-configured agent, all pieces present

from langchain.chat_models import init_chat_model
from langchain.tools import tool
from langchain.agents import create_agent
from langchain.agents.middleware import PIIMiddleware, SummarizationMiddleware
from langgraph.checkpoint.memory import InMemorySaver  # swap for a real DB-backed checkpointer in production

@tool
def check_order_status(order_id: str) -> str:
    """Look up the current status of a customer order."""
    orders = {"1001": "Shipped"}
    return orders.get(order_id, f"No order found with ID {order_id}.")

primary_model = init_chat_model("openai:gpt-4o-mini").with_retry(stop_after_attempt=2)
backup_model = init_chat_model("google_genai:gemini-2.0-flash").with_retry(stop_after_attempt=2)
resilient_model = primary_model.with_fallbacks([backup_model])

agent = create_agent(
    model=resilient_model,
    tools=[check_order_status],
    middleware=[
        PIIMiddleware("email"),
        SummarizationMiddleware(model=primary_model, max_tokens_before_summary=2000),
    ],
    checkpointer=InMemorySaver(),
)

config = {
    "configurable": {"thread_id": "user-123"},
    "recursion_limit": 10,
    "metadata": {"feature": "order_support"},
}

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What's the status of order 1001?"}]},
    config=config,
)
print(result["messages"][-1].content)

Look at how many separate modules’ lessons are present in this single, real configuration: resilience from Module 27, safety middleware from Module 28, memory from Module 19, a genuine safety cap from Module 15, and tracing-ready metadata from Module 29 — no single piece is new, but seeing them all present together is the actual, practical point of this module.

What you should take away from this module

• Production readiness isn’t one new skill — it’s genuinely applying every relevant lesson from this entire course, deliberately, in one place, rather than leaving any of them as an afterthought.
• InMemorySaver and InMemoryVectorStore, used throughout this course for learning, both need real, persistent replacements before real deployment.
• A production configuration checklist is worth keeping as a real, literal reference — timeouts, retries, fallbacks, guardrails, memory, observability, cost, and testing — checked deliberately before every real release.

Where this goes next

The final module of this course brings everything together into complete, real applications — built file by file, the way a genuine project is actually structured, rather than as single, isolated examples.