Skip to main content
Gentrace integrates with LangGraph by leveraging OpenTelemetry (OTEL) tracing to automatically capture and monitor your LangGraph agent executions, providing full observability into complex agent workflows and tool usage.

​
Prerequisites

  • Python 3.8 or higher
  • Gentrace API key
  • OpenAI API key (or other LLM provider credentials)

​
Installation

pip install gentrace-py langchain langchain-openai langgraph

​
Configuration

To enable Gentrace tracing with LangGraph, you need to set specific environment variables before importing any LangChain or LangGraph modules:
index.py
import os

# Set OpenTelemetry environment variables BEFORE importing LangChain/LangGraph
os.environ['LANGSMITH_OTEL_ENABLED'] = 'true'
os.environ['LANGSMITH_TRACING'] = 'true'

# Now import the libraries
import gentrace
from gentrace import interaction
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

# Initialize Gentrace
gentrace.init(api_key=os.getenv("GENTRACE_API_KEY"))
The OpenTelemetry environment variables must be set before importing LangChain or LangGraph modules. Setting them after imports will not enable tracing.

​
Usage Example

Here’s a complete example showing how to trace a LangGraph agent with Gentrace:
index.py
import os

# Set OTEL environment variables first
os.environ['LANGSMITH_OTEL_ENABLED'] = 'true'
os.environ['LANGSMITH_TRACING'] = 'true'

import gentrace
from gentrace import interaction
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool

# Initialize Gentrace
gentrace.init(api_key=os.getenv("GENTRACE_API_KEY"))

# Define a tool for the agent
@tool
def add(a: int, b: int) -> int:
    """Add two numbers together."""
    return a + b

# Create the agent wrapped in a Gentrace interaction
@interaction(name="math-agent-interaction")
def run_math_agent():
    # Create a ReAct agent with the add tool
    math_agent = create_react_agent(
        'openai:gpt-4o',
        tools=[add],
        name='math_agent'
    )

    # Invoke the agent
    result = math_agent.invoke({
        'messages': [{
            'role': 'user',
            'content': "What's 123 + 456?"
        }]
    })

    return result

# Run the traced agent
if __name__ == "__main__":
    result = run_math_agent()
    print(result)

​
Environment Variables

Set these environment variables in your .env file:
.env
# Gentrace configuration
GENTRACE_API_KEY=your-gentrace-api-key

# OpenTelemetry configuration (required for LangGraph tracing)
LANGSMITH_OTEL_ENABLED=true
LANGSMITH_TRACING=true

# LLM provider credentials
OPENAI_API_KEY=your-openai-api-key

​
How It Works

Gentrace captures LangGraph traces by:
  1. Intercepting LangSmith traces: The OTEL environment variables redirect LangSmith’s built-in tracing to OpenTelemetry
  2. Capturing via OpenTelemetry: Gentrace’s OTEL integration automatically collects these traces
  3. Organizing with interactions: The @interaction decorator groups related agent executions
This approach provides zero-code-change tracing for existing LangGraph applications while maintaining full compatibility with LangGraph’s features.

​
Advanced Usage

​
Custom Agent Configurations

You can trace more complex agent setups with custom configurations:
advanced_agent.py
import os

# Set OTEL environment variables first
os.environ['LANGSMITH_OTEL_ENABLED'] = 'true'
os.environ['LANGSMITH_TRACING'] = 'true'

import gentrace
from gentrace import interaction
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
from operator import add

# Initialize Gentrace
gentrace.init(api_key=os.getenv("GENTRACE_API_KEY"))

class AgentState(TypedDict):
    messages: Annotated[list, add]
    next_action: str

def process_node(state):
    # Process the messages
    state["messages"].append("Processing completed")
    state["next_action"] = "analyze"
    return state

def analyze_node(state):
    # Analyze the processed data
    state["messages"].append("Analysis completed")
    return state

@interaction(name="custom-workflow-agent")
def run_custom_agent():
    # Build custom graph
    workflow = StateGraph(AgentState)

    # Add nodes and edges
    workflow.add_node("process", process_node)
    workflow.add_node("analyze", analyze_node)
    workflow.add_edge("process", "analyze")
    workflow.add_edge("analyze", END)

    # Set entry point
    workflow.set_entry_point("process")

    # Compile and run
    app = workflow.compile()
    result = app.invoke({"messages": [], "next_action": "start"})

    return result

if __name__ == "__main__":
    result = run_custom_agent()
    print("Final state:", result)

​
Multiple Agent Coordination

Track complex multi-agent systems:
multi_agent.py
import os

# Set OTEL environment variables first
os.environ['LANGSMITH_OTEL_ENABLED'] = 'true'
os.environ['LANGSMITH_TRACING'] = 'true'

import gentrace
from gentrace import interaction
from langgraph.prebuilt import create_react_agent
from langchain_core.tools import tool

# Initialize Gentrace
gentrace.init(api_key=os.getenv("GENTRACE_API_KEY"))

# Define tools for the agents
@tool
def search_tool(query: str) -> str:
    """Search for information about a topic."""
    # Simulate search results
    return f"Search results for '{query}': Lorem ipsum dolor sit amet, consectetur adipiscing elit."

@tool
def write_tool(content: str) -> str:
    """Write formatted content based on input."""
    # Simulate writing process
    return f"Article: {content}\n\nFormatted and enhanced with additional context."

@interaction(name="multi-agent-system")
def coordinate_agents():
    # Create specialized agents
    research_agent = create_react_agent(
        'openai:gpt-4o',
        tools=[search_tool],
        name='researcher'
    )
    writer_agent = create_react_agent(
        'openai:gpt-4o',
        tools=[write_tool],
        name='writer'
    )

    # Research phase
    research_results = research_agent.invoke({
        'messages': [{
            'role': 'user',
            'content': 'Research the latest developments in artificial intelligence'
        }]
    })

    # Extract the content from research results
    research_content = research_results['messages'][-1].content

    # Writing phase using research
    final_output = writer_agent.invoke({
        'messages': [{
            'role': 'user',
            'content': f'Write an article based on this research: {research_content}'
        }]
    })

    return final_output

if __name__ == "__main__":
    result = coordinate_agents()
    print("Final output:", result['messages'][-1].content)
⌘I