Integrate LangChain and LangGraph applications

Framework overview

LangChain is a framework for developing applications powered by large language models (LLMs). It provides capabilities such as model invocation, prompt management, tool integration, retrieval-augmented generation (RAG), and agent construction to help developers quickly build complex LLM applications.

LangGraph is an agent orchestration framework within the LangChain ecosystem. It uses a graph structure to build LLM applications that support multi-step reasoning and multi-agent collaboration, enabling features like cyclic control flow, state management, and tool calls.

After integration, the following capabilities are automatically monitored:

• Execution traces for LangChain chains and agents

• LLM calls (model name, token usage, and input/output content)

• Tool calls (tool name, parameters, and return results)

• Traces related to retrievers and retrieval-augmented generation (RAG)

• Execution and state transitions of LangGraph nodes

Integration methods

pip3 install aliyun-bootstrap

# Method 1: Add environment variables for all processes in the current shell.
export ARMS_APP_NAME=<your-app-name>        # Specifies a custom name for your application.
export ARMS_WORKSPACE=<your-workspace-name> # Specifies the workspace to which data is reported.
export ARMS_REGION_ID=<your-region-id>      # Specifies the Region ID of your workspace.
export ARMS_LICENSE_KEY=<your-license-key>  # Specifies the license key for authentication.

# Method 2: Add environment variables for a specific process.
ARMS_APP_NAME=<your-app-name> ARMS_WORKSPACE=<your-workspace-name> ARMS_REGION_ID=<your-region-id> ARMS_LICENSE_KEY=<your-license-key> aliyun-instrument <your-app-file>.py

# Add environment variables
ENV ARMS_APP_NAME={your-app-name}
ENV ARMS_REGION_ID={your-region-id}
ENV ARMS_LICENSE_KEY={your-license-key}
ENV ARMS_WORKSPACE={your-workspace-name}

## Add your original Dockerfile commands here

aliyun-instrument python app.py

Sample code

import os
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
from langchain_core.tools import tool
@tool
def get_weather(city: str) -> str:
    """Get weather information for a specified city"""
    weather_data = {"Beijing": "Sunny 25°C", "Shanghai": "Cloudy 22°C", "Hangzhou": "Light rain 20°C"}
    return weather_data.get(city, f"{city}: No weather data available")
@tool
def search_product(keyword: str) -> str:
    """Search product information by keyword"""
    products = {
        "ECS": "Elastic Compute Service, providing secure and reliable cloud servers",
        "RDS": "Relational Database Service, supports MySQL/PostgreSQL/SQL Server",
        "OSS": "Object Storage Service, massive, secure, and highly reliable cloud storage",
    }
    return products.get(keyword, f"No product found for '{keyword}'")
llm = ChatOpenAI(
    model="qwen-plus",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key=os.environ.get("DASHSCOPE_API_KEY"),
    streaming=True,
    stream_usage=True,  # When enabled, streamed responses include token usage
)
agent = create_react_agent(llm, tools=[get_weather, search_product])
result = agent.invoke({"messages": [{"role": "user", "content": "What's the weather like in Beijing today? Also look up what ECS is as a product"}]})
for msg in result["messages"]:
    if msg.content:
        print(msg.content)
                    

View monitoring details

1. Log on to the ARMS console. Select the target workspace. In the left-side navigation pane, choose All features > AI application observability.

2. On the AI App List page, you can see the integrated applications. Click an App Name to view detailed monitoring data.

After successful integration, you can view the complete trace on the application monitoring details page. This includes the hierarchical relationships and node latencies for span types such as AGENT, CHAIN, LLM, and TOOL. The trace overview shows key metrics, including Trace ID, Total Duration, Application Count, Interface Count, and Total Tokens. Select an LLM node to view detailed model call information in the right-side panel, including input messages and the model's tool_call output messages.

References

Collect token usage in streaming scenarios

To collect token usage information from ChatOpenAI streaming calls, enable the stream_usage parameter:

llm = ChatOpenAI(
    model="qwen-plus",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key=os.environ.get("DASHSCOPE_API_KEY"),
    streaming=True,
    stream_usage=True,  # When enabled, streamed responses include token usage.
)

Pass session_id and user_id

When calling agent.invoke, you can pass session_id and user_id in the config object's metadata to enable session- and user-based analysis:

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Hello"}]},
    config={
        "metadata": {
            "session_id": "sess_abc123",
            "user_id": "user_456",
        },
    },
)

• session_id: A session identifier used to correlate multi-turn calls within the same session.

• user_id: A user identifier used for per-user aggregation and filtering.

Troubleshoot common issues

Common issues for the Python agent