samples/arize-phoenix_1 — awesome-ai-stack

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

.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"]