Tutorial Setup Observability LLM & AI Agent Pakai Arize Phoenix di VPS

Tantangan Utama Aplikasi LLM: Black Box, Latency, dan Token Waste

Membangun aplikasi berbasis Large Language Model (LLM) atau AI Agent menghadirkan paradigma debugging yang berbeda dibanding arsitektur perangkat lunak konvensional. Pada aplikasi web standar, log HTTP status code, query SQL slow logs, dan stack trace exception cukup untuk mendeteksi bottleneck. Namun, pada rantai eksekusi LLM (LLM chain) atau AI Agent mandiri, masalah utama sering kali tersembunyi di balik layer abstraksi model yang bersifat non-deterministik.

Ada tiga masalah mendasar yang kerap ditemui saat aplikasi berbasis LLM masuk ke fase produksi:

• Opacity & Black Box Execution: Ketika AI Agent berbasis LangChain atau LlamaIndex gagal menyelesaikan tugas, sangat sulit mengetahui span mana yang bermasalah. Apakah retriever RAG mengambil dokumen yang tidak relevan? Apakah prompt template menghasilkan sintaks invalid? Atau apakah LLM mengalami infinite tool-calling loop?
• Token Cost Leakage: Konsumsi token membengkak tanpa kendali sering terjadi akibat iterasi prompt terlalu panjang, konteks RAG tidak terkompresi, atau sistem agent terjebak dalam rekomendasi tindakan berulang (looping agent decision).
• Latency Spikes: Berbeda dari API biasa yang merespons dalam milidetik, panggilan ke model seperti GPT-4o atau Claude 3.5 Sonnet memakan waktu 2 hingga 15 detik. Tanpa pengukuran latensi per komponen (Retrieval vs Embedding vs Completion), optimasi performa menjadi tidak terarah.

Logging sederhana menggunakan module logging bawaan Python atau console.log tidak mampu menampilkan relasi hierarki antar panggilan (parent-child span graphs). Untuk menyelesaikan masalah ini, dibutuhkan platform observability khusus LLM (LLMOps) yang mendukung protokol OpenTelemetry.

Mengenal Arize Phoenix untuk LLM Observability

Arize Phoenix adalah platform observability open-source yang dirancang khusus untuk tracing, evaluasi, dan pengujian aplikasi AI/LLM. Phoenix menggunakan standar industri OpenInference (ekstensi dari OpenTelemetry) untuk menangkap metadata panggilan LLM, retrieval context, prompt embeddings, hingga pemakaian token secara real-time.

Keunggulan utama Arize Phoenix bagi engineer yang mengutamakan privasi dan efisiensi biaya adalah kemampuannya untuk dijalankan secara self-hosted di VPS (Virtual Private Server) milik sendiri tanpa perlu mengirimkan data prompt sensitif ke platform SaaS pihak ketiga. Pengembang memiliki kontrol penuh atas retensi data, keamanan jaringan, dan alokasi resource server.

Persyaratan Sistem VPS

Sebelum memulai instalasi, pastikan spesifikasi VPS memenuhi standar minimum berikut:

• Sistem Operasi: Ubuntu 22.04 LTS atau Debian 12 (64-bit).
• CPU & RAM: Minimal 2 vCPU dan 4GB RAM (Rekomendasi 4 vCPU, 8GB RAM untuk throughput trace tinggi).
• Penyimpanan: Minimal 20GB NVMe/SSD untuk menampung volume database trace data.
• Prasyarat Perangkat Lunak: Docker Engine v24+ dan Docker Compose v2+.

Setup Server Arize Phoenix di VPS Menggunakan Docker

Untuk menjalankan Arize Phoenix secara stabil, metode paling efisien adalah menggunakan Docker Compose. Phoenix menyediakan OpenTelemetry Collector terintegrasi yang mendengarkan HTTP/gRPC span data pada port standar OTLP.

Langkah 1: Buat Direktori dan File Docker Compose

Buat direktori kerja baru di VPS Anda dan buat file docker-compose.yml dengan konfigurasi berikut:

version: '3.8'

services:
  phoenix:
    image: arizeai/phoenix:latest
    container_name: arize_phoenix
    restart: always
    ports:
      - "6006:6006" # Dashboard UI & HTTP Collector
      - "4317:4317" # OpenTelemetry gRPC Collector
      - "4318:4318" # OpenTelemetry HTTP Collector
    environment:
      - PHOENIX_PORT=6006
      - PHOENIX_GRPC_PORT=4317
      - PHOENIX_WORKING_DIR=/data
    volumes:
      - phoenix_data:/data

volumes:
  phoenix_data:
    driver: local

Langkah 2: Eksekusi Container dan Firewall UFW

Jalankan container Phoenix dalam mode detached (background) menggunakan perintah berikut:

docker compose up -d
docker compose ps

Pastikan port 6006 (UI Dashboard) dan 4317 (gRPC Tracing) diizinkan oleh sistem firewall VPS (UFW):

sudo ufw allow 6006/tcp
sudo ufw allow 4317/tcp
sudo ufw reload

Buka peramban dan akses http://IP_VPS_ANDA:6006. Dashboard UI Arize Phoenix akan menampilkan antarmuka kosong yang siap menerima telemetry span data.

Konfigurasi Reverse Proxy Nginx & SSL (Opsional untuk Produksi)

Mengekspos port UI secara langsung tanpa proteksi HTTPS sangat tidak disarankan pada lingkungan produksi. Gunakan Nginx sebagai reverse proxy beserta SSL Certbot untuk mengamankan akses ke UI Phoenix.

server {
    listen 80;
    server_name phoenix.domainanda.com;

    location / {
        proxy_pass http://127.0.0.1:6006;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Aktifkan sertifikat SSL gratis menggunakan Certbot:

sudo apt update && sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d phoenix.domainanda.com

Integrasi OpenInference dan OpenTelemetry pada Python Project

Setelah server Arize Phoenix berjalan di VPS, langkah berikutnya adalah mengonfigurasi proyek Python backend Anda agar mentransmisikan data trace secara otomatis.

Langkah 1: Instalasi Package Client

Pasang library OpenInference dan OpenTelemetry exporter pada Virtual Environment proyek Anda:

pip install arize-phoenix-otlp opentelemetry-sdk opentelemetry-exporter-otlp openinference-instrumentation-openai openinference-instrumentation-langchain

Langkah 2: Konfigurasi Telemetry Exporter dan Instrumentasi Auto

Skrip berikut menunjukkan cara mengintegrasikan OpenAI SDK dan LangChain agar setiap panggilan API dan eksekusi AI Agent secara otomatis terkirim ke server Phoenix di VPS melalui koneksi OTLP gRPC:

import os
from openai import OpenAI
from opentelemetry import trace as trace_api
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from openinference.instrumentation.openai import OpenAIInstrumentor
from openinference.instrumentation.langchain import LangChainInstrumentor

# 1. Konfigurasi OTLP Exporter mengarah ke gRPC Endpoint VPS
PHOENIX_GRPC_ENDPOINT = "http://IP_VPS_ANDA:4317"

tracer_provider = TracerProvider()
span_processor = BatchSpanProcessor(
    OTLPSpanExporter(endpoint=PHOENIX_GRPC_ENDPOINT, insecure=True)
)
tracer_provider.add_span_processor(span_processor)
trace_api.set_tracer_provider(tracer_provider)

# 2. Aktifkan auto-instrumentation untuk OpenAI dan LangChain
OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)
LangChainInstrumentor().instrument(tracer_provider=tracer_provider)

# 3. Inisialisasi Client OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY", "your-api-key"))

def execute_llm_chain(user_query: str):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Anda adalah asisten teknis senior yang ahli dalam infrastruktur cloud dan software engineering."}, 
            {"role": "user", "content": user_query}
        ],
        temperature=0.2,
        max_tokens=500
    )
    return response.choices[0].message.content

if __name__ == "__main__":
    result = execute_llm_chain("Jelaskan perbedaan gRPC dan HTTP/REST dalam konteks telemetri data!")
    print("Hasil LLM:", result)

Analisis Telemetri pada Phoenix Dashboard

Setiap eksekusi fungsi execute_llm_chain akan merekam span terperinci ke server Phoenix. Buka UI Dashboard di browser untuk melakukan analisa mendalam:

1. Tracing Span Hierarchy

Visualisasi grafik hierarki memperlihatkan alur panggilan dari parent span hingga child span tercecil. Anda dapat melihat waktu tunggu (latency) pada setiap tahapan, mulai dari eksekusi template prompt, pencarian dokumen vektor (retrieval), hingga waktu generate token oleh LLM API.

2. Token Consumption & Cost Estimation

Phoenix menghitung prompt token, completion token, dan total token per request secara otomatis. Informasi ini membantu mengidentifikasi komponen prompt yang boros token dan memperkirakan pengeluaran API per user request.

3. Debugging RAG (Retrieval-Augmented Generation)

Pada pipeline RAG, Phoenix menangkap dokumen teks yang ditarik dari Vector Database beserta score kemiripannya (cosine similarity/euclidean distance). Jika model memberikan jawaban halusinasi, engineer dapat langsung memeriksa apakah masalah berasal dari kualiatas konteks dokumen RAG yang relevansinya rendah.

Praktik Terbaik Produksi (Production Hardening & Disk Maintenance)

Saat menjalankan Arize Phoenix secara self-hosted di VPS produksi, perhatikan faktor pemeliharaan berikut:

• Manajemen Storage Data: File database SQLite/DuckDB internal Phoenix dapat membesar dengan cepat seiring tingginya trafik trace. Buat cron job berkala atau manfaatkan retensi policy bawaan untuk membersihkan span tua.
• Keamanan OTLP Endpoint: Port gRPC 4317 secara default tidak memiliki autentikasi bawaan. Gunakan firewall IP Whitelisting (UFW) agar port 4317 hanya dapat diakses oleh IP server aplikasi backend Anda.
• Batch Span Processor: Gunakan selalu BatchSpanProcessor (bukan SimpleSpanProcessor) pada aplikasi Python backend agar transmisi log telemetri berjalan secara asinkron tanpa memblokir siklus eksekusi utama aplikasi (non-blocking IO).

Kesimpulan

Mengimplementasikan Arize Phoenix di VPS memberikan kendali penuh terhadap sistem observability aplikasi LLM dan AI Agent. Dengan memanfaatkan standar terbuka OpenInference dan OpenTelemetry, pengembang dapat melacak akar masalah latensi, menganalisis kegagalan RAG retrieval, serta mencegah pemborosan token secara efisien tanpa harus mengorbankan privasi data.