View Notebook on Github

​
LangGraph Basic Chatbot with AgentOps

This example shows you how to build a basic chatbot using LangGraph’s StateGraph with comprehensive tracking via AgentOps.

​
What We’re Building

A stateful chatbot using LangGraph fundamentals:
  • 🗃️ StateGraph: Core LangGraph structure for managing conversation state
  • 💬 Chat Model: LLM integration for generating responses
  • 🔄 State Management: Automatic message history tracking with add_messages
  • 🎯 Graph Flow: START → chatbot node → END pattern
With AgentOps, you’ll get complete visibility into graph execution, state transitions, and LLM interactions.

​
Step-by-Step Implementation

​
Step 1: Install Dependencies

Install LangGraph with your preferred chat model and AgentOps for tracking: 
pip install langgraph langchain agentops python-dotenv
What AgentOps adds:
  • 📊 Graph execution tracking with node transitions and timing
  • 💰 LLM cost monitoring with token usage breakdown
  • 🔄 State change visualization showing message flow
  • 📈 Performance metrics for each graph execution
  • 🐛 Execution replay for debugging graph flows

​
Step 2: Create Your Project Structure

Create a simple Python project for your chatbot: 
# Create project directory
mkdir langgraph_chatbot
cd langgraph_chatbot

# Create main chatbot file
touch chatbot.py
touch .env
This creates the basic structure: 
langgraph_chatbot/
├── chatbot.py           # Main chatbot implementation
└── .env                 # API keys

​
Step 3: Set Up Environment Variables

Create your .env file with the necessary API keys: 
# .env
OPENAI_API_KEY=your_openai_api_key_here
AGENTOPS_API_KEY=your_agentops_api_key_here
Get your API keys: Note: You can use any LangChain-compatible model (Anthropic, Google, etc.) by adjusting the imports and model initialization.

​
Step 4: Build Your Basic Chatbot

Edit chatbot.py to create your LangGraph chatbot: 
# chatbot.py
import os
from typing import Annotated
from typing_extensions import TypedDict

from langchain.chat_models import init_chat_model
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
import agentops
from dotenv import load_dotenv

# Load environment variables and initialize AgentOps
load_dotenv()
agentops.init(auto_start_session=False)

# Define the State schema
class State(TypedDict):
    # Messages have the type "list". The `add_messages` function
    # in the annotation defines how this state key should be updated
    # (in this case, it appends messages to the list, rather than overwriting them)
    messages: Annotated[list, add_messages]

​
Step 5: Initialize the Chat Model and Create the Chatbot Node

Add the model and node function: 
# Initialize the chat model (you can change to any provider)
llm = init_chat_model("openai:gpt-4o-mini")

# Create the chatbot node function
def chatbot(state: State):
    """Main chatbot function that processes messages and returns responses."""
    return {"messages": [llm.invoke(state["messages"])]}

​
Step 6: Build and Compile the StateGraph

Construct your LangGraph workflow: 
# Create the StateGraph
graph_builder = StateGraph(State)

# Add the chatbot node
# The first argument is the unique node name
# The second argument is the function that will be called
graph_builder.add_node("chatbot", chatbot)

# Add entry point (where to start)
graph_builder.add_edge(START, "chatbot")

# Add exit point (where to end)
graph_builder.add_edge("chatbot", END)

# Compile the graph
graph = graph_builder.compile()

​
Step 7: Add the Streaming Chat Function

Create the interactive chat interface with AgentOps tracking: 
def stream_graph_updates(user_input: str):
    """Stream graph updates for the given user input."""
    for event in graph.stream({"messages": [{"role": "user", "content": user_input}]}):
        for value in event.values():
            print("Assistant:", value["messages"][-1].content)

def run_chatbot():
    """Main function to run the chatbot with AgentOps tracking."""
    # Start AgentOps session
    session = agentops.start_session(tags=["langgraph", "chatbot"])
    
    try:
        print("🤖 LangGraph Chatbot Started!")
        print("Type 'quit', 'exit', or 'q' to stop.\n")
        
        while True:
            try:
                user_input = input("User: ")
                if user_input.lower() in ["quit", "exit", "q"]:
                    print("Goodbye!")
                    break
                stream_graph_updates(user_input)
                print()  # Add blank line for readability
            except KeyboardInterrupt:
                print("\nGoodbye!")
                break
            except Exception as e:
                print(f"Error: {e}")
                break
        
        # End session successfully
        agentops.end_session("Success")
        
    except Exception as e:
        print(f"Error occurred: {e}")
        agentops.end_session("Failed", end_state_reason=str(e))
        raise

# Main execution
if __name__ == "__main__":
    run_chatbot()

​
Step 8: Run Your Chatbot

Execute your chatbot: 
cd langgraph_chatbot
python chatbot.py
What happens:
  1. AgentOps session starts automatically
  2. Interactive chat loop begins
  3. Each user message flows through: START → chatbot node → END
  4. LLM generates responses based on conversation history
  5. AgentOps captures all state transitions and LLM interactions
  6. Session ends when you type ‘quit’
Example conversation: 
🤖 LangGraph Chatbot Started!
Type 'quit', 'exit', or 'q' to stop.

User: Hello! What can you help me with?
Assistant: Hello! I'm a helpful AI assistant. I can help you with a wide variety of tasks...

User: Tell me a joke
Assistant: Why don't scientists trust atoms? Because they make up everything!

User: quit
Goodbye!

​
View Results in AgentOps Dashboard

After running your chatbot, visit your AgentOps Dashboard to see:
  1. Graph Structure: Visual representation of your StateGraph (START → chatbot → END)
  2. State Transitions: How messages flow through the graph
  3. LLM Interactions: Every conversation turn with prompts and responses
  4. Execution Timing: How long each node takes to process
  5. Session Analytics: Conversation length, token usage, and costs
  6. Message History: Complete conversation flow with state management

​
Key Files Created

Project structure you built:
  • chatbot.py - Complete LangGraph chatbot with AgentOps integration
  • .env - API keys for OpenAI and AgentOps
AgentOps Integration Points:
  • agentops.init() - Enables automatic LangGraph instrumentation
  • agentops.start_session() - Begins tracking each chat session
  • agentops.end_session() - Completes the session with status

​
Next Steps

  • Add tools to your chatbot (web search, calculators, etc.)
  • Implement more complex graph structures with conditional edges
  • Add memory persistence across sessions
  • Create multi-agent workflows with LangGraph
  • Use AgentOps analytics to optimize conversation flows