samples/arize-phoenix_1 — awesome-ai-stack

예제

Arize Phoenix — LLM 호출 트레이싱 (self-host)

실제로 실행 가능한 미니 프로젝트입니다. 받아서 Docker로 실행해 보세요.

GitHub에서 samples/arize-phoenix_1 보기 ↗

2026년 6월 28일

Arize Phoenix — LLM 호출 트레이싱 (self-host)

아주 작은 Phoenix 데모입니다. 함께 들어 있는 docker-compose가 Phoenix 서버를 띄우고, 앱은 OpenTelemetry 트레이싱을 등록한 뒤 LiteLLM 호출을 한 번(자동 계측) 하고, Phoenix에서 span을 다시 조회해 왕복을 검증합니다 — "에러 안 났다"가 아니라 실제로 들어갔는지 확인합니다.

설정

cd samples/arize-phoenix_1
cp .env.sample .env
# .env 편집: ANTHROPIC_API_KEY 설정 (트레이싱할 호출용)

Phoenix 자체는 키가 필요 없고, 모델 키만 넣으면 됩니다. .env는 gitignore 처리되어 있고, .env.sample만 커밋됩니다.

Docker Compose로 실행

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

앱이 Phoenix를 기다렸다가 트레이싱할 호출을 보내고, 다시 읽어온 span을 출력합니다. UI는 http://localhost:6006에서 볼 수 있습니다. 끝나면 정리하세요:

docker compose down -v

Docker Compose로 실행 (DooD를 쓰는 devcontainer에서)

호스트 Docker 데몬과 통신하는 dev container(Docker-outside-of-Docker)에서는 attach된 docker compose up이 앱을 실제로 실행했는데도 출력을 안 보여줄 수 있습니다. 실시간 attach 스트림이 VM 경계에서 출력을 흘려버리기 때문이니, detached로 실행하고 로그로 확인하세요:

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

참고

트레이싱할 호출은 LiteLLM을 거치므로 docker-compose.yml의 MODEL을 어떤 제공자로든 바꾸고 해당 키만 넣으면 됩니다.
Phoenix Cloud로 보내려면 PHOENIX_COLLECTOR_ENDPOINT를 거기로 지정하고 번들 서버는 건너뛰세요.

실행 결과

모델 표현은 실행마다 다릅니다 — LLM은 비결정적입니다. 여기서 보여주는 건 트레이스 왕복입니다. 아래는 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"]