Setting Up Your LangGraph Development Environment

A First Look at LangGraph's Structure

Before we write any code, let's visualize what a LangGraph agent looks like. At its core, LangGraph allows you to define agentic workflows as state graphs. A graph consists of nodes (functions that perform work) and edges (which direct the flow of data from one node to another). The data itself is held in a state object that is passed around the graph.

This graph-based structure is highly analogous to defining a state machine or a DAG (Directed Acyclic Graph) to orchestrate complex jobs, a pattern you're likely familiar with from general software engineering. It gives you explicit control over the agent's execution path.

For a dynamic introduction to these concepts, the following video provides an excellent overview.

Step 1: Project Setup and Dependency Management

Now, let's get our hands dirty. We'll set up a new project directory and install the necessary Python packages. We'll follow modern Python practices by using a virtual environment and a fast package manager called uv.

The video you just started will now guide you through the practical setup. We'll be following its steps closely.

To summarize the commands you'll be running in your project directory:

1. Initialize the project:

   uv init
   

   This creates a pyproject.toml file to manage your project's metadata and dependencies, and a virtual environment in a .venv folder.

2. Install dependencies:

   uv add python-dotenv langgraph "langchain-anthropic" ipykernel
   

   Let's quickly break down what these packages are for:

   • python-dotenv: Loads environment variables from a .env file. We'll use this for our API key.
   • langgraph: The core LangGraph framework.
   • langchain-anthropic: The specific LangChain integration for Anthropic's Claude models. If you prefer OpenAI, you would install langchain-openai instead.
   • ipykernel: Allows you to run code in Jupyter notebooks, which is great for iterative development and experimentation.

Step 2: API Key Configuration

Our agent needs an LLM to function as its "brain," and accessing an LLM requires an API key. We will use Anthropic's Claude 3.5 Sonnet model for this example, but the process is similar for any provider (like OpenAI).

To keep our secret keys out of our source code—a crucial security practice—we'll store the key in a .env file.

After this step, your project directory should look something like this:

langgraph-project/
├── .venv/
├── .env
├── main.py
└── pyproject.toml

And your .env file should contain one line:
ANTHROPIC_API_KEY='sk-ant-...'

Step 3: Verifying the Setup with a Minimal Agent

With our environment ready, let's write a minimal "hello world" agent to confirm everything is connected properly. This agent will take a user's message, send it to the LLM, and print the response.

This final part of the tutorial will guide you through writing the code. We will go through it step-by-step.

Here is the complete code for your main.py file. You can use this to check your work.

import os
from typing import Annotated

from dotenv import load_dotenv
from langchain_anthropic import ChatAnthropic
from typing_extensions import TypedDict

from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages

# Load environment variables from .env file
load_dotenv()

# Define the structure of our agent's state
# For this simple example, it's just a list of messages
class State(TypedDict):
    messages: Annotated[list, add_messages]

# Define the node that will be the core of our chatbot
def chatbot(state: State):
    """
    This function is a node in our graph. It takes the current state
    (which includes the conversation history), calls the LLM with that
    history, and returns the LLM's response.
    """
    return {"messages": [llm.invoke(state["messages"])]}

# Initialize the LLM. We are using Claude 3.5 Sonnet.
# The API key is read automatically from the ANTHROPIC_API_KEY environment variable.
llm = ChatAnthropic(model="claude-3.5-sonnet-20240620")

# Create the graph builder
graph_builder = StateGraph(State)

# Add our chatbot node
graph_builder.add_node("chatbot", chatbot)

# Define the graph's edges
graph_builder.add_edge(START, "chatbot") # The graph starts at the chatbot node
graph_builder.add_edge("chatbot", END)   # The graph ends after the chatbot node

# Compile the graph into a runnable object
graph = graph_builder.compile()

# Run the agent in a loop
while True:
    user_input = input("User: ")
    if user_input.lower() in ["quit", "exit", "q"]:
        print("Goodbye!")
        break
    
    # We invoke the graph with the current user message
    # The `add_messages` function in our state automatically handles
    # appending this new message to the history.
    response = graph.invoke({"messages": [("user", user_input)]})
    
    # The response contains the final state. We extract the last message.
    ai_message = response["messages"][-1]
    print(f"AI: {ai_message.content}")

When you run this script (python main.py), it should prompt you for input. If you type a message like "Hello world", the script will call the Claude API and print its response, confirming your entire setup is working!

Conclusion

Congratulations! You have successfully set up a complete development environment for LangGraph. You've created a new project, managed dependencies with uv, handled API keys securely, and built and run a minimal agent to verify the entire pipeline.

Key Takeaways:

• LangGraph organizes agent workflows into state graphs with nodes (functions) and edges (transitions).
• A professional Python setup involves using a virtual environment and a modern package manager like uv.
• API keys must be stored securely in a .env file, separate from your source code.
• A minimal graph consists of an entry point (START), at least one node, and an exit point (END).

You now have a solid foundation to build upon. In our next lesson, we will expand on the code we wrote today. We'll deconstruct the ReAct (Reasoning and Acting) pattern and implement a more sophisticated agent loop using LangGraph's state graph, preparing us to add tools and more complex logic.