• If Nodes are the “actions” or “workers”,
• Then Edges are the “roads” or “connections” that link those actions together.

1. Fixed / Static Edges (add_edge)
   • Always go from one node to another specific node.
   • Used for predictable, linear flows.
2. Conditional / Dynamic Edges (add_conditional_edges)
   • Decide the next node at runtime (usually based on LLM output or logic).
   • Most powerful and commonly used in agents.

• Execution Flow is Explicit: The graph’s behavior is determined by the connections (edges), not by the sequence in which you wrote the code. This makes your workflow logic clear and predictable.
• Flexibility in Design: You can add nodes in any order you like. The actual execution path is defined separately through edges. This allows you to easily reorganize, reuse, or modify flows.
• Supports Complex Architectures: Edges enable powerful patterns like:
  • Branching (conditional routing)
  • Loops (agent cycles)
  • Parallel execution
  • Merging paths
  • Skipping or repeating steps
• Easier Debugging & Visualization: When something goes wrong, you can look at the edges to instantly understand how data flows through your graph — instead of hunting through code order.

1. Start
   The graph always begins at the special START node.
2. Node Execution
   The current node receives the latest state, runs its logic, and returns updates.
3. State Update
   LangGraph merges the node’s return value into the current state (using reducers where needed).
4. Edge Evaluation
   LangGraph looks at all outgoing edges from the current node to decide what to do next:
   • Fixed edge → Go to the specified node
   • Conditional edge → Run the router function to decide the next node
5. Repeat
   Steps 2–4 continue until the graph reaches the special END node (or an interrupt occurs).
6. Finish
   When END is reached, execution stops and the final state is returned.

• Linear workflows
• Straightforward step-by-step processes
• When the next step is always the same

graph.add_edge(START, "agent")
graph.add_edge("agent", "tools")
graph.add_edge("tools", "summarize")
graph.add_edge("summarize", END)

• Tool calling decisions
• Branching logic
• Different workflows based on user input or LLM output

def route_after_agent(state):
    if state["messages"][-1].tool_calls:
        return "tools"
    return "END"

graph.add_conditional_edges(
    "agent",                    # Source node
    route_after_agent,          # Router function
    {
        "tools": "tools",       # Mapping: return value → target node
        "END": END
    }
)

• ReAct-style agents
• Retry mechanisms
• Multi-step reasoning loops

# Example: Agent keeps running until it decides to finish
graph.add_conditional_edges(
    "agent",
    route_after_agent,
    {
        "tools": "tools",
        "continue": "agent",   # ← Loop back to agent
        "END": END
    }
)

graph.add_edge("tools", "agent")   # Tool result goes back to agent

• Running multiple searches at once
• Concurrent tool calls
• Multi-source data gathering

# Fan-out from START
graph.add_edge(START, "web_search")
graph.add_edge(START, "vector_search")

# Fan-in to aggregator
graph.add_edge("web_search", "aggregate")
graph.add_edge("vector_search", "aggregate")

• START: The entry point of every graph. You always connect from START.
• END: The exit point. When the graph reaches END, execution stops.

• We cannot add a node named START or END.
• Every graph must eventually reach END (unless using interrupts).

• Enables dynamic workflows instead of rigid linear flows
• Allows the graph to respond differently based on LLM output, state, or custom rules
• Essential for building agents that can decide whether to call tools, continue reasoning, or finish

1. Takes the current state as input
2. Returns the name of the next node (as a string) or a list of nodes (for parallel execution)

def route_tools(state: MessagesState) -> str:
    """Simple routing based on tool calls."""
    last_message = state["messages"][-1]
    
    if last_message.tool_calls:
        return "tools"          # Go to Tool Node
    else:
        return "END"            # Finish execution

def route_after_agent(state: MessagesState):
    """Let the LLM decide the next step via tool calling."""
    last_message = state["messages"][-1]
    
    # If LLM requested tool calls
    if last_message.tool_calls:
        return "tools"
    
    # Otherwise, end the conversation
    return "END"


# Attach the router to a conditional edge
graph.add_conditional_edges(
    "agent", 
    route_after_agent,
    {
        "tools": "tools",
        "END": END
    }
)

def complex_router(state: MessagesState):
    last_message = state["messages"][-1]
    confidence = getattr(last_message, "confidence", 0.0)
    
    if "error" in state:
        return "fix_error"
    elif confidence < 0.7:
        return "retry"
    elif last_message.tool_calls:
        return "tools"
    else:
        return "summarize"

• Combines state update + next destination in one return
• Reduces the need for many conditional edges
• Great for dynamic routing, multi-agent handoffs, and edgeless graphs
• More intuitive when the decision and update belong together

from langgraph.types import Command
from langgraph.graph import StateGraph, START, END
from typing import Literal

def router_node(state):
    """Decide next step and update state in one go."""
    user_input = state["messages"][-1].content.lower()
    
    if "joke" in user_input:
        return Command(
            update={"intent": "joke"},           # Update state
            goto="joke_node"                     # Route to next node
        )
    elif "research" in user_input:
        return Command(
            update={"intent": "research"},
            goto="research_node"
        )
    else:
        return Command(
            update={"intent": "unknown"},
            goto=END
        )


# Add the node (no conditional edge needed!)
graph.add_node("router", router_node)
graph.add_node("joke_node", joke_generator)
graph.add_node("research_node", researcher)

graph.add_edge(START, "router")

• When the routing decision and state update are tightly coupled
• In multi-agent systems or complex branching logic
• When you want cleaner, more maintainable code

graph.add_edge(source: str, target: str)

from langgraph.graph import StateGraph, START, END

graph = StateGraph(MessagesState)

graph.add_node("agent", agent_node)
graph.add_node("tools", tool_node)
graph.add_node("summarize", summarize_node)

# Fixed edges
graph.add_edge(START, "agent")
graph.add_edge("agent", "tools")
graph.add_edge("tools", "summarize")
graph.add_edge("summarize", END)

• Linear workflows
• Predictable step-by-step processes
• Connecting to START and END
• Simple pipelines

• Simple and readable
• No runtime decision needed
• Cannot branch or loop by itself

graph.add_conditional_edges(
    source: str,                    # Starting node
    path: Callable,                 # Router function
    path_map: dict | None = None,   # Mapping: return value → target node
    then: str | None = None         # Optional: run this node after all paths
)

• Use add_edge() for simple, predictable connections.
• Use add_conditional_edges() whenever the next step depends on logic or LLM output.
• You can mix both types in the same graph.
• Keep your router functions fast and pure (avoid heavy computation).

from langgraph.types import Send

def route_to_parallel_branches(state):
    return [
        Send("web_search", state),
        Send("vector_search", state),
        Send("news_search", state)
    ]

graph.add_conditional_edges(START, route_to_parallel_branches)

• Keep router functions simple and fast
• Always handle all possible return values
• Use clear, descriptive branch names
• Consider using the Command object for cleaner code in complex cases
• Test each branch independently

• Allow agents to iterate and improve their answers
• Support retry logic on failure
• Enable multi-turn reasoning
• Make it possible to keep calling tools until the task is complete
• Create persistent, stateful workflows

• Always add a maximum iteration limit to prevent infinite loops
• Use checkpointer (persistence) so the graph can resume after interruptions
• Keep loop logic clear and readable
• Monitor state size — especially message history (use summarization if needed)

• It tells LangGraph: “This workflow is complete. Stop here.”
• No further nodes will execute after END.
• The compiled graph will return the current state as the final output.

Linear / Sequential Pattern

ReAct Loop Pattern (Most Popular for Agents)

research_team = create_research_subgraph().compile()
graph.add_node("research_team", research_team)   # Subgraph as node

graph.add_edge("planner", "research_team")
graph.add_edge("research_team", "final_answer")

def route_with_retry(state):
    if state.get("error") or confidence_low(state):
        return "fix_node"      # or back to "agent"
    return END

graph.add_conditional_edges("validator", route_with_retry)
graph.add_edge("fix_node", "agent")   # Retry

1. Forgetting to Add Edges

graph.add_node("agent", agent_node)
graph.add_node("tools", tool_node)
# Forgot to connect them!

2. Incorrect Router Return Values

def bad_router(state):
    if condition:
        return "tool_node"        # Wrong name!
    return END

if max_iterations_reached(state) or task_complete(state):
    return END

def router(state):
    if tool_calls:
        return "tools"
    # What if neither condition is true?

return "tools" if ... else "END"

graph.add_edge("start", "agent")   # Wrong!

from langgraph.graph import START, END
graph.add_edge(START, "agent")
graph.add_edge("final", END)