Phoenix now allows you to track token-based costs for LLM runs automatically, calculating costs from token counts and model pricing data and rolling them up to trace and project levels for comprehensive analysis.

New Features:

• Automatic calculation of token-based costs using Phoenix’s built-in model pricing table.

• Support for custom pricing configurations in Settings > Models when needed.

• Token counts and model information are captured automatically when using OpenInference auto-instrumentation with OpenAI, Anthropic, and other supported SDKs.

• For manual instrumentation, token count attributes can be included in spans to enable cost tracking.

• OpenTelemetry users can leverage OpenInference semantic conventions to include token counts in LLM spans.

More Information:

Phoenix’s Playground now supports Amazon Bedrock, allowing users to run prompts directly against Bedrock-hosted models within the platform.

New Features:

• Run prompts on Amazon Bedrock models seamlessly from Phoenix’s Playground.

• Compare outputs side-by-side with other model providers for better evaluation.

• Instantly track usage metrics, latency, and cost associated with Bedrock models.

• Fine-tune prompt strategies within Phoenix without needing to switch tools.

We’ve added a comprehensive management and provisioning layer to Phoenix, enabling enhanced team collaboration and access control.

New Features:

• Ability to create and manage multiple customized Phoenix spaces tailored to different teams and use cases.

• Granular user access management for each individual space.

• Support for multiple users collaborating within the same Phoenix projects.

New Features:

• Added an optional sessionId argument to the Project.sessions GraphQL field, enabling filtering by session_id.

• Integrated support across the backend resolver and frontend UI to seamlessly filter and display sessions matching a specific session_id.

We’ve added support for Ollama in the Playground, enabling you to experiment with Ollama models and customize model parameters directly within the platform for more flexible and tailored prompt versioning.

We’re excited to announce that Phoenix can now be deployed via a Helm chart for Kubernetes.

This allows you to:

• Quickly spin up Phoenix with a single helm install and a single YAML file.

• Launch using the infrastructure and deployment patterns recommended by the Phoenix team, ensuring consistency and ease of maintenance.

• Easily upgrade to the latest Phoenix features and improvements over time.

Whether you are self-hosting in a cloud Kubernetes cluster or on-premises, the new Helm chart makes deploying Phoenix simpler and more reliable than ever.

Set up Instructions

New visualizations Phoenix provide deeper insights into experiment performance over time.

With Experiment Progress Charts, you can now:

• Visualize how evaluation scores evolve across experiment runs

• Monitor evaluator performance and detect regressions

• Analyze latency trends to identify bottlenecks and inefficiencies

These collapsible visual tools eliminate the need for manual inspection and make it significantly easier to track the impact of changes in your LLM or agent workflows.

New Features:

• Added POST /projects/{project_identifier}/spans route for span ingestion.

• Added log_spans client method to submit a sequence of spans, rejecting the entire batch if any span is invalid or not unique.

• Added log_spans_dataframe for submitting spans as a dataframe.

• Introduced uniquify_spans and uniquify_spans_dataframe helpers to regenerate span and trace IDs while preserving relationships.

• Improved validation and error handling to prevent partial ingestion and ensure safe, conflict-free span creation.

Example Usage

from phoenix.client import Client
from phoenix.client.helpers.spans import uniquify_spans

client = Client()

spans = [
    {
        "name": "llm_call",
        "context": {"trace_id": "trace_123", "span_id": "span_456"},
        "start_time": "2024-01-15T10:00:00Z",
        "end_time": "2024-01-15T10:00:05Z",
        "span_kind": "LLM"
    }
]

unique_spans = uniquify_spans(spans)
result = client.spans.log_spans(
    project_identifier="my-project",
    spans=unique_spans,
)

This release enables filtering of datasets by name across both the API and user interface, integrating a live search input along with support for pagination and sorting to improve data navigation and usability.

• Added a DatasetFilter input and enum to the GraphQL schema, allowing users to filter datasets by name using case-insensitive matching.

• Created a debounced DatasetsSearch component on the Datasets page that lets users filter results live as they type.