{"id":133990,"date":"2026-09-10T02:02:43","date_gmt":"2026-09-10T02:02:43","guid":{"rendered":"https:\/\/www.hostinger.com\/ph\/tutorials\/langgraph-tutorial\/"},"modified":"2026-09-10T02:02:43","modified_gmt":"2026-09-10T02:02:43","slug":"langgraph-tutorial","status":"publish","type":"post","link":"\/ph\/tutorials\/langgraph-tutorial\/","title":{"rendered":"LangGraph tutorial: How to build an AI agent in Python"},"content":{"rendered":"

To build an AI agent in Python with LangGraph, define its shared state and model node, connect them in a graph, then add tools, memory, streaming, and human approval.<\/p>

You’ll build the LangGraph agent in eight stages:<\/p>

    \n
  1. Set up the project and install LangGraph.<\/li>\n\n\n\n
  2. Define the shared state your nodes use.<\/li>\n\n\n\n
  3. Create the model node that calls the AI.<\/li>\n\n\n\n
  4. Connect and run your first graph.<\/li>\n\n\n\n
  5. Add tools and decide when the agent should use them.<\/li>\n\n\n\n
  6. Add memory across separate agent calls.<\/li>\n\n\n\n
  7. Stream the agent’s responses as they’re generated.<\/li>\n\n\n\n
  8. Pause tool calls for human approval.<\/li>\n<\/ol>

    After developing your LangGraph agent locally, you’ll deploy it to a Linux virtual private server (VPS) so it keeps running even after you shut down your computer.<\/p>

    <\/p>

    What is LangGraph?<\/h2>

    LangGraph is a Python framework from LangChain for building stateful <\/strong>AI agents<\/a> as multi-step graphs of nodes and edges<\/strong>. Stateful means the workflow keeps and updates information as it runs instead of treating every action as isolated.<\/p>

    It gives you direct control over what your agent does next. You can create workflows with branching, loops, tool use, memory, streaming, and human approval instead of forcing every request through the same fixed sequence.<\/p>

    In a LangGraph workflow, nodes perform tasks, edges control which step runs next, and shared state carries information between those steps. The graph can return to an earlier node, letting your agent repeat an action until it reaches a stopping condition.<\/p>

    For example, you can build a research assistant that moves between reasoning and information retrieval until it has enough evidence to answer.<\/p>

    This looping behavior is common in agentic AI<\/a>, where an agent chooses its next action based on the information it has gathered – the same pattern behind most AI agent examples<\/a> that need branching, repeated actions, or human review. <\/p>

    Use LangGraph when your agent needs to loop, branch, call tools, or pause for approval. If a single prompt and response solves your problem, call the model API directly.<\/p>

    What’s the difference between LangGraph and LangChain?<\/h3>

    The difference between LangGraph and LangChain is the level of control you have over your agent’s workflow<\/strong>.<\/p>

    LangChain provides higher-level APIs and integrations for common agent patterns, while LangGraph gives you direct control over state, routing, loops, and execution flow.<\/p>

    Area<\/strong><\/td>LangChain<\/strong><\/td>LangGraph<\/strong><\/td><\/tr>
    Abstraction level<\/td>Higher-level agent APIs and integrations<\/td>Lower-level control over workflow execution<\/td><\/tr>
    State management<\/td>Provides built-in patterns for common agent state<\/td>Lets you define and update graph state directly<\/td><\/tr><\/tbody><\/table><\/figure>

    Use LangChain when its built-in agent patterns already fit your app. Use LangGraph when you need custom routing, persistent state across turns, repeated workflow steps, or human review.<\/p>

    You don’t need LangChain’s higher-level agent abstractions to use LangGraph. LangGraph works with LangChain components when you want ready-made model and tool integrations, but it doesn’t require them.<\/p>

    The two aren’t competitors – LangChain’s own agent abstraction runs on LangGraph underneath, so you’re choosing how much of the workflow to write yourself.<\/p>

    How to build a LangGraph agent in Python<\/h2>

    To build a LangGraph agent in Python, define its state, create nodes that perform tasks, connect them with edges, add tools and conditional routing, and compile the graph into a runnable app<\/strong>.<\/p>

    By the end, you’ll have one working LangGraph agent that remembers conversations, decides when to call tools, streams responses, and pauses selected actions for your approval.<\/p>

    1. Set up the project and install LangGraph<\/h3>

    To set up a LangGraph project, create the project folder, activate a Python virtual environment, and install LangGraph with pip<\/strong>.<\/p>

    You’ll need Python 3.10 or later, an API key for an AI model, and the required Python packages. We’ll use DeepSeek, but you can use another provider such as OpenAI or Anthropic by installing its corresponding LangChain package.<\/p>

    Open your terminal, create a folder named langgraph-agent<\/strong>, and move into it:<\/p>

    mkdir langgraph-agent\ncd langgraph-agent<\/pre>
    Next, create a Python virtual environment<\/a> so this project’s packages don’t affect your other Python projects. On macOS or Linux, run:<\/p>
    python3 -m venv .venv\nsource .venv\/bin\/activate\npython -m pip install --upgrade pip<\/pre>
    Your terminal should show (.venv)<\/strong> at the beginning of the prompt after activation.<\/p>
    Install LangGraph, the DeepSeek integration, and the other dependencies used in the project:<\/p>
    pip install langgraph==1.2.11 langchain-deepseek==1.1.0 langchain-core==1.6.1 python-dotenv==1.2.3<\/pre>
    Pinning these versions keeps the project’s direct dependencies consistent while you follow along.<\/p>
    Create the project files:<\/p>
    touch main.py .env .gitignore requirements.txt<\/pre>
    Your langgraph-agent<\/strong> folder should now look like this:<\/p>
    langgraph-agent\/\n   .venv\/\n   main.py\n   .env\n   .gitignore\n   requirements.txt<\/pre>
    Keep the terminal open, then open langgraph-agent<\/strong> in your code editor. In VS Code, select File → Open Folder<\/strong>, then choose langgraph-agent<\/strong>.<\/p>
    \"VS