> ## Documentation Index
> Fetch the complete documentation index at: https://arize-ax.mintlify.site/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# LangGraph

> Trace LangGraph agents with OpenInference and send spans to Arize AX for LLM observability.

[LangGraph](https://www.langchain.com/langgraph) is a stateful multi-actor agent framework built on top of LangChain. Arize AX captures every LangGraph run — graph node invocations, tool calls, LLM calls, and the message state passing through them — via the [`openinference-instrumentation-langchain`](https://github.com/Arize-ai/openinference/tree/main/python/instrumentation/openinference-instrumentation-langchain) package, the same instrumentor that covers LangChain.

<CardGroup>
  <Card horizontal icon="https://storage.googleapis.com/arize-phoenix-assets/assets/images/phoenix-docs-images/gc.ico" href="http://colab.research.google.com/github/Arize-ai/tutorials/blob/main/python/llm/tracing/langchain/langgraph-tracing.ipynb" title="LangGraph Tracing Tutorial (Google Colab)" />
</CardGroup>

## Prerequisites

* Python 3.10+
* An Arize AX account ([sign up](https://arize.com/sign-up/))
* An `OPENAI_API_KEY` from the [OpenAI Platform](https://platform.openai.com/api-keys)

## Launch Arize AX

1. Sign in to your [Arize AX account](https://app.arize.com/).
2. From **Space Settings**, copy your **Space ID** and **API Key**. You will set them as `ARIZE_SPACE_ID` and `ARIZE_API_KEY` below.

## Install

```bash theme={null}
pip install arize-otel \
  openinference-instrumentation-langchain \
  langgraph langchain-openai
```

## Configure credentials

```bash theme={null}
export ARIZE_SPACE_ID="<your-space-id>"
export ARIZE_API_KEY="<your-api-key>"
export ARIZE_PROJECT_NAME="langgraph-tracing-example"
export OPENAI_API_KEY="<your-openai-api-key>"
```

## Setup tracing

```python theme={null}
# instrumentation.py
import os

from arize.otel import register
from openinference.instrumentation.langchain import LangChainInstrumentor

tracer_provider = register(
    space_id=os.environ["ARIZE_SPACE_ID"],
    api_key=os.environ["ARIZE_API_KEY"],
    project_name=os.environ["ARIZE_PROJECT_NAME"],
)

LangChainInstrumentor().instrument(tracer_provider=tracer_provider)
print("Arize AX tracing initialized for LangGraph.")
```

## Run LangGraph

```python theme={null}
# example.py

# Importing instrumentation first ensures tracing is set up
# before `langgraph` is imported.
from instrumentation import tracer_provider

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


@tool
def get_weather(city: str) -> str:
    """Get the current weather for a city. Returns a short string."""
    if city.lower() in ("sf", "san francisco"):
        return "It's 60 degrees and foggy in San Francisco."
    return f"It's 75 degrees and sunny in {city}."


# ChatOpenAI reads OPENAI_API_KEY from the environment.
agent = create_react_agent(
    model=ChatOpenAI(model="gpt-5.5"),
    tools=[get_weather],
)

result = agent.invoke({
    "messages": [("user", "What's the weather in San Francisco?")],
})

print(result["messages"][-1].content)
```

### Expected output

```text wrap theme={null}
Arize AX tracing initialized for LangGraph.
The current weather in San Francisco is 60 degrees and foggy.
```

## Verify in Arize AX

1. Open your Arize AX space and select project **`langgraph-tracing-example`**.
2. You should see a new trace within \~30 seconds containing a `LangGraph` parent span wrapping the agent's reasoning loop — `agent` node spans (`ChatOpenAI` calls), the `tools` node span (`get_weather` invocation), and the final answer.
3. If no traces appear, see [Troubleshooting](#troubleshooting).

### Check from the skill, CLI, or SDK

Confirm spans are actually reaching your Arize AX project. Use whichever fits your workflow — the skill and CLI work for any framework; the SDK check is shown for each language.

<Tabs>
  <Tab title="Arize skill (agent)">
    Install the [Arize Skills](https://github.com/Arize-ai/arize-skills) plugin and let your coding agent check for you:

    ```bash theme={null}
    npx skills add Arize-ai/arize-skills
    ```

    Then prompt your agent:

    > Use the `arize-trace` skill to export and analyze recent traces from my project. Confirm spans are arriving, and summarize any errors or latency issues.
  </Tab>

  <Tab title="AX CLI">
    Export recent spans for your project — any rows mean traces are landing:

    ```bash theme={null}
    ax spans export "$ARIZE_PROJECT_NAME" --space "$ARIZE_SPACE_ID" \
      --limit 5 --stdout | jq 'length'
    ```

    A non-zero count confirms spans reached Arize AX. Run `ax auth login` first if you have not authenticated. See the [`ax spans` reference](/api-clients/cli/spans).
  </Tab>

  <Tab title="SDK">
    Query the project's spans and check that at least one came back.

    <CodeGroup>
      ```python Python theme={null}
      import os
      from arize import ArizeClient

      client = ArizeClient(api_key=os.environ["ARIZE_API_KEY"])
      resp = client.spans.list(
          project=os.environ["ARIZE_PROJECT_NAME"],
          space=os.environ["ARIZE_SPACE_ID"],
          limit=5,
      )
      count = len(resp.spans)
      print(
          f"{count} span(s) found" if count else "No spans yet — recheck setup"
      )
      ```

      ```typescript TypeScript theme={null}
      // Reads ARIZE_API_KEY from the environment.
      import { listSpans } from "@arizeai/ax-client";

      const { data: spans } = await listSpans({
        project: process.env.ARIZE_PROJECT_NAME!,
        space: process.env.ARIZE_SPACE_ID!,
        limit: 5,
      });
      const count = spans.length;
      console.log(
        count ? `${count} span(s) found` : "No spans yet — recheck setup",
      );
      ```

      ```go Go theme={null}
      client, err := arize.NewClient(
          arize.Config{APIKey: os.Getenv("ARIZE_API_KEY")},
      )
      if err != nil {
          log.Fatal(err)
      }
      resp, err := client.Spans.List(ctx, spans.ListRequest{
          Project: os.Getenv("ARIZE_PROJECT_NAME"),
          Space:   os.Getenv("ARIZE_SPACE_ID"),
          Limit:   5,
      })
      if err != nil {
          log.Fatal(err)
      }
      fmt.Printf("%d span(s) found\n", len(resp.Spans))
      ```
    </CodeGroup>

    SDK span references: [Python](/api-clients/python/version-8/client-resources/spans) · [TypeScript](/api-clients/typescript/version-1/client-resources/spans) · [Go](/api-clients/go/version-2/client-resources/spans).
  </Tab>
</Tabs>

## Troubleshooting

* **No traces in Arize AX.** Confirm `ARIZE_SPACE_ID` and `ARIZE_API_KEY` are set in the same shell that runs `example.py`. Enable OpenTelemetry debug logs with `export OTEL_LOG_LEVEL=debug` and re-run.
* **Graph ran but no spans appear.** `LangChainInstrumentor().instrument(...)` must run before any `langgraph` or `langchain` import. Make sure `instrumentation.py` is the first import in your entry point.
* **`401` from OpenAI.** Verify `OPENAI_API_KEY` is set and has access to `gpt-5.5`. Swap for a model your key can call.
* **Other LLM providers.** Install the matching `langchain-<provider>` package (e.g. `langchain-anthropic`) and pass that chat model to `create_react_agent`. The same `LangChainInstrumentor` covers every provider.

## Resources

<CardGroup>
  <Card icon="book-open" href="https://langchain-ai.github.io/langgraph/" title="LangGraph Documentation" horizontal />

  <Card icon="terminal" href="https://github.com/Arize-ai/openinference/tree/main/python/instrumentation/openinference-instrumentation-langchain" title="OpenInference LangChain Instrumentor (used for LangGraph)" horizontal />

  <Card icon="code" href="/ax/integrations/python-agent-frameworks/langchain/langchain-tracing" title="LangChain Tracing Guide" horizontal />
</CardGroup>