Arize Phoenix

By Arize AI

Open-source LLM and agent observability — OpenTelemetry tracing and evals you can self-host

Website ↗ Repository ↗ Docs ↗

arize-phoenix-v19.4.02026-07-22PythonElastic-2.0

#tracing #eval #observability #opentelemetry

10.7k Open source Free tier Paid

Doc version 1.0 · Updated June 28, 2026

Related concepts

Harness Engineering Doc version 1.0 · Updated June 28, 2026 Wrapping an LLM in scaffolding — a control loop, tools, a sandbox, guardrails, and evaluation — so it behaves reliably in production.

Related tools

Overview

Phoenix is Arize’s open-source observability tool for LLM and agent apps, built on OpenTelemetry.
It traces each run as nested spans (model calls, tool calls, retrievals), and adds datasets and evaluations on top — all self-hostable with no account.

flowchart LR
  app[agent] -->|OTel spans| px[(Phoenix)]
  px --> ui[traces + evals]

The Code samples tab shows instrumenting an app and running a local Phoenix server — pick from the selector to compare.

When to use it

Choose Phoenix when you want open, OpenTelemetry-native tracing and evals you can run locally or self-host — a close peer to Langfuse on the open-source side.

Example

Python · trace

When to use

Reach for Phoenix when you want OpenTelemetry-native tracing you can run yourself, with a UI to inspect each step.

How it flows

register(auto_instrument=True) patches supported libraries so their LLM and tool calls are exported to Phoenix as spans.

Structure

flowchart LR
  app[agent] -->|OTel spans| px[(Phoenix)]
  px --> ui[traces + evals]

from phoenix.otel import register

# Send OpenTelemetry traces to a Phoenix instance (local or self-hosted).
register(project_name="my-agent", auto_instrument=True)

# Any instrumented call (OpenAI, LiteLLM, LangChain, ...) now lands as a span.
from litellm import completion
completion(model="gpt-4o", messages=[{"role": "user", "content": "hi"}])

When to use

Self-host Phoenix for a private, no-account tracing backend during development.

How it flows

The server collects spans your app exports and renders traces, plus datasets and evals, in the UI.

Structure

flowchart LR
  serve[phoenix serve] --> ui[localhost:6006]

# Run a local Phoenix server — the UI is at http://localhost:6006.
pip install arize-phoenix
phoenix serve

# ...or with Docker:
docker run -p 6006:6006 arizephoenix/phoenix

Example

Arize Phoenix — trace an LLM call (self-hosted)

A real, runnable mini-project. Download it and run with Docker.

View samples/arize-phoenix_1 on GitHub ↗

June 28, 2026

Arize Phoenix — trace an LLM call (self-hosted)

A tiny Phoenix demo: the bundled docker-compose runs a Phoenix server, and the app registers OpenTelemetry tracing, makes one LiteLLM call (auto-instrumented), then queries Phoenix for the spans — proving the round trip, not just that the call didn't error.

Configure

cd samples/arize-phoenix_1
cp .env.sample .env
# edit .env: set ANTHROPIC_API_KEY (for the call being traced)

Phoenix itself needs no key; you only provide the model key. .env is gitignored — only .env.sample is committed.

Run with Docker Compose

cd samples/arize-phoenix_1
docker compose up --build

The app waits for Phoenix, makes the traced call, and prints the spans it read back. Browse them in the UI at http://localhost:6006. Tear down when done:

docker compose down -v

Run with Docker Compose (in a devcontainer with DooD)

In a dev container that talks to the host Docker daemon (Docker-outside-of-Docker), the attached docker compose up may print nothing for the app even though it ran — the live attached stream drops output over the VM boundary. Run detached and read it back from the logs:

cd samples/arize-phoenix_1
docker compose up --build -d
docker compose logs -f app
docker compose down -v

Notes

The traced call goes through LiteLLM, so MODEL (in docker-compose.yml) can be any provider — change it and set the matching key.
To trace into Phoenix Cloud instead, point PHOENIX_COLLECTOR_ENDPOINT at it and skip the bundled server.

Example run

The model's wording varies by run (LLMs are non-deterministic); what's shown is the trace round-trip. Below is one run with anthropic/claude-opus-4-8.

model says: Arize Phoenix is an open-source observability and evaluation platform
for tracing, monitoring, and debugging LLM and AI applications.

reading spans back from Phoenix ...
  traced 1 span(s): ['completion']
  UI: http://localhost:6006

Files

.env.sample

# Copy this file to `.env` and add your Anthropic key.
#   cp .env.sample .env
#
# Phoenix itself needs no key; this is the model key for the call being traced.
ANTHROPIC_API_KEY=

app.py

"""Arize Phoenix: trace an LLM call into a self-hosted Phoenix, then read it back.

The bundled docker-compose runs a Phoenix server. This app registers
OpenTelemetry tracing pointed at it, makes one LiteLLM call (auto-instrumented),
then queries Phoenix for the spans — proving the round trip, not just that the
call didn't error.

Run (with the bundled Phoenix):
    docker compose up --build
"""

import os
import sys
import time
import urllib.error
import urllib.request

from dotenv import load_dotenv
from phoenix.client import Client
from phoenix.otel import register

load_dotenv()

ENDPOINT = os.environ.get("PHOENIX_COLLECTOR_ENDPOINT", "http://localhost:6006")
PROJECT = "aas-demo"
MODEL = os.environ.get("MODEL", "anthropic/claude-opus-4-8")


def wait_until_ready(seconds: int = 120) -> None:
    for _ in range(seconds):
        try:
            with urllib.request.urlopen(ENDPOINT, timeout=5) as r:
                if r.status < 500:
                    return
        except (urllib.error.URLError, OSError):
            pass
        time.sleep(1)
    raise SystemExit(f"Phoenix not ready at {ENDPOINT}")


def main() -> None:
    question = " ".join(sys.argv[1:]) or "Summarize Arize Phoenix in one sentence."

    print(f"waiting for Phoenix at {ENDPOINT} ...")
    wait_until_ready()

    # Send OpenTelemetry spans to Phoenix; auto_instrument patches LiteLLM.
    tracer_provider = register(
        project_name=PROJECT,
        endpoint=f"{ENDPOINT}/v1/traces",
        auto_instrument=True,
    )

    from litellm import completion

    resp = completion(model=MODEL, messages=[{"role": "user", "content": question}])
    print("model says:", resp.choices[0].message.content)

    tracer_provider.force_flush()  # push buffered spans before we query

    print("\nreading spans back from Phoenix ...")
    client = Client(base_url=ENDPOINT)
    for _ in range(20):
        try:
            df = client.spans.get_spans_dataframe(project_name=PROJECT)
        except Exception:
            df = None
        if df is not None and len(df):
            names = sorted(df["name"].tolist()) if "name" in df.columns else []
            print(f"  traced {len(df)} span(s): {names}")
            print(f"  UI: {ENDPOINT}")
            return
        time.sleep(2)
    print(f"spans not queryable yet (ingestion is async) — check the UI at {ENDPOINT}")


if __name__ == "__main__":
    main()

docker-compose.yml

# A self-hosted Phoenix + an app that traces one LLM call into it.
#   docker compose up --build
services:
  phoenix:
    image: arizephoenix/phoenix:latest
    ports:
      - "6006:6006"

  app:
    build: .
    depends_on:
      - phoenix
    environment:
      PHOENIX_COLLECTOR_ENDPOINT: http://phoenix:6006
      MODEL: anthropic/claude-opus-4-8
      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
    # The prompt to trace — override on the command line if you like.
    command: ["Summarize Arize Phoenix in one line."]

Dockerfile

# Image for the Arize Phoenix sample app (the Phoenix server runs as a separate
# compose service).
FROM python:3.13-slim

ENV PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

ENTRYPOINT ["python", "app.py"]

Related concepts

Related tools

Overview

When to use it

Pricing

When to use

How it flows

When to use

How it flows

Configure

Run with Docker Compose

Run with Docker Compose (in a devcontainer with DooD)

Notes

Example run