AgentLoop: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=xxx   # The application name.
export ARMS_REGION_ID=xxx   # The region ID of your Alibaba Cloud account.
export ARMS_LICENSE_KEY=xxx   # Your Alibaba Cloud license key.

# Method 2: Set environment variables for a single process
ARMS_APP_NAME=xxx ARMS_REGION_ID=xxx ARMS_LICENSE_KEY=xxx aliyun-instrument xxx.py

# Add environment variables
ENV ARMS_APP_NAME={AppName}
ENV ARMS_REGION_ID={regionId}
ENV ARMS_LICENSE_KEY={licenseKey}
## Original environment

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. In the ARMS console, go to the LLM Application Insights > App List page and click the name of your target AI application to view detailed monitoring data.

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