LangGraph

LangGraph development for production agents

Stateful, checkpointed agent graphs with human approvals, multi-agent routing and full tracing.

LangGraph graph: START, supervisor, research, retrieval, action with human approval interrupt, respond, END
Drawn by LangGraph from the code below: supervisor routing, an MCP tool call, GraphRAG lookup and a human approval interrupt.

How we use LangGraph

LangGraph models an agent as an explicit graph of steps over shared state. That makes agents debuggable, resumable and testable, which is why we use it for most custom agent work. We design the graph, the state, the tools and the checkpoints, then wire in tracing and evaluation.

What we build with it

  • Customer support and operations agents that act in your systems
  • Research and analysis agents with planning and self-checks
  • Supervisor and swarm multi-agent teams
  • Agents embedded in your product behind your API
See it working

LangGraph, running on our machines

Real screenshots and the exact code behind them, from a run on our own machines.

langgraph_support_agent.pySupport agent with checkpointing and a human approval interrupt
"""Support agent from the vithupro.in hero: supervisor -> specialist agents -> human approval before any refund.
Runs offline (stub logic instead of LLM calls) so the graph, checkpointing and interrupt can be verified and drawn."""
from typing import Literal, TypedDict

from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import END, START, StateGraph
from langgraph.types import Command, interrupt


class State(TypedDict, total=False):
    request: str
    order: dict
    policy: str
    decision: str
    reply: str


def supervisor(state: State) -> Command[Literal["research", "retrieval"]]:
    # In production this is an LLM routing call with structured output.
    return Command(goto="research" if "order" not in state else "retrieval")


def research(state: State) -> dict:
    # Tool call over MCP: get_order(order_id) -> a narrow, typed, read-only tool.
    return {"order": {"id": "4821", "status": "delivered", "damaged": True, "amount": 2499}}


def retrieval(state: State) -> dict:
    # GraphRAG lookup over the policy knowledge graph, with citations.
    return {"policy": "Damaged on arrival: full refund within 7 days [policy.pdf p.3]"}


def action(state: State) -> dict:
    # Irreversible step: pause the graph and wait for a person.
    answer = interrupt({"proposed": f"refund_order({state['order']['id']})", "because": state["policy"]})
    return {"decision": answer}


def respond(state: State) -> dict:
    ok = state.get("decision") == "approve"
    return {"reply": "Refund approved and issued." if ok else "A teammate will review your request."}


builder = StateGraph(State)
builder.add_node("supervisor", supervisor)
builder.add_node("research", research)
builder.add_node("retrieval", retrieval)
builder.add_node("action", action)
builder.add_node("respond", respond)
builder.add_edge(START, "supervisor")
builder.add_edge("research", "supervisor")
builder.add_edge("retrieval", "action")
builder.add_edge("action", "respond")
builder.add_edge("respond", END)
graph = builder.compile(checkpointer=MemorySaver())  # Postgres saver in production

if __name__ == "__main__":
    cfg = {"configurable": {"thread_id": "ticket-4821"}}
    first = graph.invoke({"request": "Order #4821 arrived damaged. I want my money back."}, cfg)
    print("paused for approval:", first["__interrupt__"][0].value)
    final = graph.invoke(Command(resume="approve"), cfg)  # a human clicks Approve
    print("reply:", final["reply"])
    print(graph.get_graph().draw_mermaid())
Output of this run
paused for approval: {'proposed': 'refund_order(4821)', 'because': 'Damaged on arrival: full refund within 7 days [policy.pdf p.3]'}
reply: Refund approved and issued.

Patterns we rely on

Explicit state and conditional edges

Typed state and routing functions instead of a free-running loop, so every path is visible and testable.

Checkpointing

Postgres checkpointers persist each step, so a conversation or task resumes after a crash, and you can replay or branch from any step.

Human-in-the-loop interrupts

The graph pauses before sensitive actions and waits for approval or edits, then continues from the same state.

Multi-agent topologies

Supervisor, hierarchical and swarm patterns with subgraphs, so specialist agents stay small and focused.

Our production checklist

What we put in place before a LangGraph system goes live.

  • Typed state schema and tool contracts
  • Step and token limits per run
  • Checkpointer on Postgres with retention policy
  • Tracing in LangSmith or Langfuse
  • Scenario eval suite run before each release
  • Streaming responses to the UI

Questions

Do you deploy on LangGraph Platform?

We can. We also self-host LangGraph behind FastAPI on your cloud when you prefer to keep everything in your own accounts.

Can LangGraph use any model?

Yes. We regularly mix providers in one graph, for example a cheaper model for routing and a stronger one for reasoning steps.

Often used together with:

Need LangGraph engineers?

Tell us what it needs to do. We reply within one business day with questions, a rough plan and the next step.

Book a call
  • Free 30-minute architecture call
  • NDA before you share details
  • You own all code and IP
  • Reply within one business day