The Phoenix client now includes the SpanQuery DSL, enabling more advanced and flexible span querying for distributed tracing and telemetry data. This allows users to perform complex queries on span data, improving trace analysis and debugging.

In addition, the get_spans_dataframe method has been migrated, offering an easy-to-use way to extract span-related information as a Pandas DataFrame. This simplifies data processing and visualization, making it easier to analyze trace data within Python-based environments.

Improvements and Bug Fixes 🐛

When stopping the Phoenix server via Ctrl+C, the shutdown process now exits cleanly without displaying a traceback or returning a non-zero exit code. Previously, a KeyboardInterrupt and CancelledError traceback could appear, ending the process with status code 130. The server now swallows the interrupt for a smoother shutdown experience, exiting with code 0 by default to reflect intentional termination.

Improvements and Bug Fixes 🐛

Phoenix now supports Transport Layer Security (TLS) for both HTTP and gRPC connections, enabling encrypted communication and optional mutual TLS (mTLS) authentication. This enhancement provides a more secure foundation for production deployments.

Highlights:

• Secure HTTP & gRPC Connections: Phoenix can now serve over HTTPS and secure gRPC.

• Flexible TLS Configuration: TLS settings are managed via environment variables.

• Optional Client Verification: Support for mTLS with configurable client certificate validation.

• Improved Testing: TLS-aware infrastructure added to integration tests.

• Better Visibility: Server startup logs now display TLS status.

Configuration Options

Set the following environment variables to enable and customize TLS:

What’s New?

This release introduces automatic distributed tracing for Anthropic’s Model Context Protocol (MCP). Using OpenTelemetry, you can now:

• Propagate context across MCP client-server boundaries

• Generate end-to-end traces of your AI system across services and languages

• Gain full visibility into how models access and use external context

The openinference-instrumentation-mcp package handles this for you by:

• Creating spans for MCP client operations

• Injecting trace context into MCP requests

• Extracting and continuing the trace context on the server

• Associating the context with OTEL spans on the server side

Set up

1. Instrument both MCP client and server with OpenTelemetry.

2. Add the openinference-instrumentation-mcp package.

3. Spans will propagate across services, appearing as a single connected trace in Phoenix.

Full example usage is available:

Walkthrough Video

Acknowledgments

Big thanks to Adrian Cole and Anuraag Agrawal for their contributions to this feature.

Newly added to the OpenAI Agent SDK is support for MCP Span Info, allowing for the tracing and extraction of useful information about MCP tool listings. Use the Phoenix OpenAI Agents SDK for powerful agent tracing.

Phoenix v9.0.0 release brings major updates to annotation support, and a whole host of other improvements.

Up until now, Phoenix has only supported one annotation of a given type on each trace. We've now unlocked that limit, allowing you to capture multiple values of an annotation label on each span.

In addition, we've added:

• API support for annotations - create, query, and update annotations through the REST API

• Additional support for code evaluations as annotations

• Support for arbitrary metadata on annotations

• Annotation configurations to structure your annotations within and across projects

Data Retention 💿

Now you can create custom global and per-project data retention polices to remove traces after a certain window of time, or based on number of traces. Additionally, you can now view your disk usage in the Settings page of Phoenix.

Hotkeys 🔥

We've added hotkeys to Phoenix!

You can now use j and k to quickly page through your traces, and e and n to add annotations and notes - you never have to lift your hands off the keyboard again!

Full v9.0.0 Release

Improvements and Bug Fixes 🐛

• Performance: Do not refetch tables when trace and span details closed

• UI: Redirect /v1/traces to root path

• Playground: Update GPT-4.1 models in Playground

We've added a host of new methods to the JS client:

Full list of supported JS/TS Client Methods:

Phoenix now supports programmatic API key creation through a new endpoint, making it easier to automate project setup and trace logging. To enable this, set the PHOENIX_ADMIN_SECRET environment variable in your deployment.

Improvements and Bug Fixes 🐛

We've introduced the OpenAI Agents SDK for Python which provides enhanced visibility into agent behavior and performance.

Installation

pip install openinference-instrumentation-openai-agents openai-agents

• Includes an OpenTelemetry Instrumentor that traces agents, LLM calls, tool usage, and handoffs.

• With minimal setup, use the register function to connect your app to Phoenix and view real-time traces of agent workflows.

For more details on a quick setup, check out our integration documentation:

Walkthrough Video

Improvements and Bug Fixes 🐛

Improvements and Bug Fixes 🐛

Improvements and Bug Fixes 🐛

We've added the ability to resize Span, Trace, and Session tables. Resizing preferences are now persisted in the tracing store, ensuring settings are maintained per-project and per-table.

Improvements and Bug Fixes 🐛

We’ve introduced several enhancements to Projects, providing greater flexibility and control over how you interact with data. These updates include:

• Custom Time Ranges: You can now specify custom time ranges to filter traces and spans.

• Root Span Filter for Spans: Improved filtering options allow you to filter by root spans, helping to isolate and debug issues more effectively.

Improvements and Bug Fixes 🐛

• Save and Load from Prompts: You can now save and load configurations directly from prompts.

• Save and Load from Default Model Config: Default model configurations can be saved and loaded.

• Budget Token Management: Added the ability to adjust the budget token value.

• Thinking Configuration Toggle: You can now enable or disable the “thinking” feature.

Important Note: The default model config does not automatically apply to saved prompts. To include default thinking settings, ensure they are saved within the specific prompt.

Improvements and Bug Fixes 🐛

With hosted instances, your data is stored between sessions, and you can easily share your work with team members.

We are partnering with LlamaIndex to power a new observability platform in LlamaCloud: LlamaTrace. LlamaTrace will automatically capture traces emitted from your LlamaIndex applications, and store them in a persistent, cloud- accessible Phoenix instance.

This update enhances the Project Management API with more flexible project identification:

• Enhanced project identification: Added support for identifying projects by both ID and hex-encoded name and introduced a new _get_project_by_identifier helper function

Also includes streamlined operations, better validation & error handling, and expanded test coverage.

Improvements and Bug Fixes 🐛

We’ve added support for Prompt Tagging in the Phoenix client. This new feature gives you more control and visibility over your prompts throughout the development lifecycle.

• Tag prompts directly in your code and see those tags reflected in the Phoenix UI.

• Label prompt versions as development, staging, or production — or define your own custom tags.

• Add tag descriptions to provide additional context or list out all tags.

Improvements and Bug Fixes 🐛

Improved trace navigation by automatically scrolling the selected span into view when a user navigates to a specific trace. This enhancement eliminates the need for manual searching or scrolling, allowing users to immediately focus on the span of interest. It's especially useful when navigating from links or alerts that point to a specific span, improving debugging efficiency. This change contributes to a smoother and more intuitive trace exploration experience.

Improvements and Bug Fixes 🐛

The new span aside moves the Span Annotation editor into a dedicated panel, providing a clearer view for adding annotations and enhancing customization of your setup. Read this documentation to learn how annotations can be used.

Improvements and Bug Fixes 🐛

Phoenix v10.5.0 now supports Deepseek and xAI models in Playground natively. Previous versions of Phoenix supported these as custom model endpoints, but that process has now been streamlined to offer these model providers from the main Playground dropdown.

Within each project, there is now a Config tab to enhance customization. The default tab can now be set per project, ensuring the preferred view is displayed.

Improvements and Bug Fixes 🐛

• Experiments: Included delete experiment option to action menu

• Feature: Added support for specifying admin users via an environment variable at startup

• Annotation: Now displays metadata

• Settings Page: Now split across tabs for improved navigation and easier access

• Feedback: Added full metadata

• Projects: Improved performance

• UI: Added date format descriptions to explanations

You can now specify one or more admin users at startup using an environment variable. This is especially useful for managed deployments, allowing you to define admin access in a manifest or configuration file. The specified users will be automatically seeded into the database, enabling immediate login without manual setup.

Improvements and Bug Fixes 🐛

This release introduces a REST API for managing projects, complete with full CRUD functionality and access control. Key features include:

• CRUD Operations: Create, read, update, and delete projects via the new API endpoints.

• Role-Based Access Control:

  • Admins can create, read, update, and delete projects

  • Members can create and read projects, but cannot modify or delete them.

• Additional Safeguards: Immutable Project Names, Default Project Protection, Comprehensive Integration Tests

Improvements and Bug Fixes 🐛

Sessions allow you to group multiple responses into a single thread. Each response is still captured as a single trace, but each trace is linked together and presented in a combined view.

Bug Fixes and Improvements 🐛

• Prompt Playground: Added support for arbitrary string model names Added support for Gemini 2.0 Flash Improved template editor ergonomics

• Evals: Added multimodal message template support

• Tracing: Added JSON pretty printing for structured data outputs (thank you sraibagiwith100x!) Added a breakdown of token types in project summary

• Bug Fixes: Changed trace latency to be computed every time, rather than relying on root span latency, Added additional type checking to handle non-string values when manually instrumenting (thank you Manuel del Verme!)

You can now run Experiments using the Phoenix JS client! Use Experiments to test different iterations of your applications over a set of test cases, then evaluate the results.

This release includes:

• Native tracing of tasks and evaluators

• Async concurrency queues

• Support for any evaluator (including bring your own evals)

Code Implementation

import { createClient } from "@arizeal/phoenix-client";
import {
  asEvaluator,
  runExperiment,
} from "@arizeal/phoenix-client/experiments";
import type { Example } from "@arizeal/phoenix-client/types/datasets";
import { Factuality } from "autoevals";
import OpenAI from "openai";

const phoenix = createClient();
const openai = new OpenAI();

/** Your AI Task */
const task = async (example: Example) => {
  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      { role: "system", content: "You are a helpful assistant." },
      { role: "user", content: JSON.stringify(example.input, null, 2) },
    ],
  });
  return response.choices[0]?.message?.content ?? "No response";
};

await runExperiment({
  dataset: "dataset_id",
  experimentName: "experiment_name",
  client: phoenix,
  task,
  evaluators: [
    asEvaluator({
      name: "Factuality",
      kind: "LLM",
      evaluate: async (params) => {
        const result = await Factuality({
          output: JSON.stringify(params.output, null, 2),
          input: JSON.stringify(params.input, null, 2),
          expected: JSON.stringify(params.expected, null, 2),
        });
        return {
          score: result.score,
          label: result.name,
          explanation: (result.metadata?.rationale as string) ?? "",
          metadata: result.metadata ?? {},
        };
      },
    }),
  ],
});

Phoenix prompt management will now let you create, modify, tag, and version control prompts for your applications. Some key highlights from this release:

• Versioning & Iteration: Seamlessly manage prompt versions in both Phoenix and your codebase.

• New TypeScript Client: Sync prompts with your JavaScript runtime, now with native support for OpenAI, Anthropic, and the Vercel AI SDK.

• New Python Client: Sync templates and apply them to AI SDKs like OpenAI, Anthropic, and more.

• Standardized Prompt Handling: Native normalization for OpenAI, Anthropic, Azure OpenAI, and Google AI Studio.

• Enhanced Metadata Propagation: Track prompt metadata on Playground spans and experiment metadata in dataset runs.

New update overview:

• Evals: o3 support, Audio & Multi-Modal Evaluations

Improvements and Bug Fixes 🐛

Datasets: Datasets are a new core feature in Phoenix that live alongside your projects. They can be imported, exported, created, curated, manipulated, and viewed within the platform, and should make a few flows much easier:

• Fine-tuning: You can now create a dataset based on conditions in the UI, or by manually choosing examples, then export these into csv or jsonl formats readymade for fine-tuning APIs.

• Experimentation: External datasets can be uploaded into Phoenix to serve as the test cases for experiments run in the platform.

Experiments: Our new Datasets and Experiments feature enables you to create and manage datasets for rigorous testing and evaluation of your models. You can now run comprehensive experiments to measure and analyze the performance of your LLMs in various scenarios.

Phoenix has made it even simpler to get started with tracing by introducing one-line auto-instrumentation. By using register(auto_instrument=True), you can enable automatic instrumentation in your application, which will set up instrumentors based on your installed packages.

from phoenix.otel import register

register(auto_instrument=True)

We are introducing a new built-in function call evaluator that scores the function/tool-calling capabilities of your LLMs. This off-the-shelf evaluator will help you ensure that your models are not just generating text but also effectively interacting with tools and functions as intended.

This evaluator checks for issues arising from function routing, parameter extraction, and function generation.

Our integration with Guardrails AI allows you to capture traces on guard usage and create datasets based on these traces. This integration is designed to enhance the safety and reliability of your LLM applications, ensuring they adhere to predefined rules and guidelines.

In addition to using our automatic instrumentors and tracing directly using OTEL, we've now added our own layer to let you have the granularity of manual instrumentation without as much boilerplate code.

You can now access a tracer object with streamlined options to trace functions and code blocks. The main two options are:

• Using the decorator @tracer.chain traces the entire function automatically as a Span in Phoenix. The input, output, and status attributes are set based on the function's parameters and return value.

• Using the tracer in a with clause allows you to trace specific code blocks within a function. You manually define the Span name, input, output, and status.

We’ve added a Python auto-instrumentation library for the Google GenAI SDK. This enables seamless tracing of GenAI workflows with full OpenTelemetry compatibility. Traces can be exported to any OpenTelemetry collector.

Installation

For more details on how to set up the tracing integration seamlessly:

Additionally, the Google GenAI instrumentor is now supported and works seamlessly with Span Replay in Phoenix, enabling deep trace inspection and replay for more effective debugging and observability.

Acknowledgements

Big thanks to Harrison Chu for his contributions.

We've added Authentication and Rules-based Access Controls to Phoenix. This was a long-requested feature set, and we're excited for the new uses of Phoenix this will unlock!

The auth feature set includes:

• Secure Access: All of Phoenix’s UI & APIs (REST, GraphQL, gRPC) now require access tokens or API keys. Keep your data safe!

• RBAC (Role-Based Access Control): Admins can manage users; members can update their profiles—simple & secure.

• API Keys: Now available for seamless, secure data ingestion & querying.

• OAuth2 Support: Easily integrate with Google, AWS Cognito, or Auth0. ✉ Password Resets via SMTP to make security a breeze.

Bug Fixes and Improvements 🐛

• Numerous stability improvements to our hosted Phoenix instances accessed on app.phoenix.arize.com

• Added a new command to easily launch a Phoenix client from the cli: phoenix serve

• Implemented simple email sender to simplify dependencies

• Improved error handling for imported spans

• Replaced hdbscan with fast-hdbscan Added PHOENIX_CSRF_TRUSTED_ORIGINS environment variable to set trusted origins

• Added support for Mistral 1.0

• Fixed an issue that caused px.Client().get_spans_dataframe() requests to time out

Sessions allow you to group multiple responses into a single thread. Each response is still captured as a single trace, but each trace is linked together and presented in a combined view.

Bug Fixes and Improvements 🐛

• Added support for FastAPI and GraphQL extensions

• Fixed a bug where Anthropic LLM as a Judge responses would be labeled as unparseable

• Fixed a bug causing 500 errors on client.get_traces_dataset() and client.get_spans_dataframe()

• Added the ability for authentication to work from behind a proxy

• Added an environment variable to set default admin passwords in auth

Available in Phoenix v10.5.0+

Deepseek and xAI models are now available in Prompt Playground!

We've added a host of new methods to the JS client:

You can now run Experiments using the Phoenix JS client! Use Experiments to test different iterations of your applications over a set of test cases, then evaluate the results.

This release includes:

• Native tracing of tasks and evaluators

• Async concurrency queues

• Support for any evaluator (including bring your own evals)

Available in Phoenix 9.0.0+

Phoenix's v9.0.0 release brings with it:

• Customizable data retention policies

We’ve added a Python auto-instrumentation library for the Google GenAI SDK. This enables seamless tracing of GenAI workflows with full OpenTelemetry compatibility. Additionally, the Google GenAI instrumentor is now supported and works seamlessly with Span Replay in Phoenix.

Available in Phoenix 8.30+

The Phoenix client now includes the SpanQuery DSL for more advanced span querying. Additionally, a get_spans_dataframe method has been added to facilitate easier data extraction for span-related information.

Available in Phoenix 8.29+

Phoenix now supports Transport Layer Security (TLS) for both HTTP and gRPC connections, enabling encrypted communication and optional mutual TLS (mTLS) authentication. This enhancement provides a more secure foundation for production deployments.

Available in Phoenix 8.28+

When stopping the Phoenix server via Ctrl+C, the shutdown process now exits cleanly with code 0 to reflect intentional termination. Previously, this would trigger a traceback with KeyboardInterrupt, misleadingly indicating a failure.

Available in Phoenix 8.27+

Improved trace navigation by automatically scrolling the selected span into view when a user navigates to a specific trace. This enhances usability by making it easier to locate and focus on the relevant span without manual scrolling.

Available in Phoenix 8.26+

We’ve released openinference-instrumentation-mcp, a new package in the OpenInference OSS library that enables seamless OpenTelemetry context propagation across MCP clients and servers. It automatically creates spans, injects and extracts context, and connects the full trace across services to give you complete visibility into your MCP-based AI systems.

Big thanks to Adrian Cole and Anuraag Agrawal for their contributions to this feature.

Available in Phoenix 8.26+

Phoenix now supports programmatic API key creation through a new endpoint, making it easier to automate project setup and trace logging. To enable this, set the PHOENIX_ADMIN_SECRET environment variable in your deployment.

Available in Phoenix 8.25+

Available in Phoenix 8.24+

This update enhances the Project Management API with more flexible project identification We've added support for identifying projects by both ID and hex-encoded name and introduced a new _get_project_by_identifier helper function.

Available in Phoenix 8.23+

Available in Phoenix 8.22+

Available in Phoenix 8.21+

The new span aside moves the Span Annotation editor into a dedicated panel, providing a clearer view for adding annotations and enhancing customization of your setup. Read this documentation to learn how annotations can be used.

Available in Phoenix 8.20+

Newly added to the OpenAI Agent SDK is support for MCP Span Info, allowing for the tracing and extraction of useful information about MCP tool listings. Use the Phoenix OpenAI Agents SDK for powerful agent tracing.

Available in Phoenix 8.20+

Available in Phoenix 8.19+

Available in Phoenix 8.17+

You can now preconfigure admin users at startup using an environment variable, making it easier to manage access during deployment. Admins defined this way are automatically seeded into the database and ready to log in.

03.20.2025: Delete Experiment from Action Menu 🗑️

Available in Phoenix 8.16+

You can now delete experiments directly from the action menu, making it quicker to manage and clean up your workspace.

Available in Phoenix 8.15+

Available in Phoenix 8.14+

We've added the ability to resize Span, Trace, and Session tables. Resizing preferences are now persisted in the tracing store, ensuring settings are maintained per-project and per-table.

Available in Phoenix 8.13+

pip install openinference-instrumentation-openai-agents openai-agents

Available in Phoenix 8.11+

You can now save and load configurations directly from prompts or default model settings. Additionally, you can adjust the budget token value and enable/disable the "thinking" feature, giving you more control over model behavior and resource allocation.

Available in Phoenix 8.9+

Prompt Playground now supports new GPT and Anthropic models new models with enhanced configuration options. Instrumentation options have been improved for better traceability, and evaluation capabilities have expanded to cover Audio & Multi-Modal Evaluations. Phoenix also introduces new integration support for LiteLLM Proxy & Cleanlabs evals.

Available in Phoenix 8.8+

We’ve rolled out several enhancements to Projects, offering more flexibility and control over your data. Key updates include persistent column selection, advanced filtering options for metadata and spans, custom time ranges, and improved performance for tracing views. These changes streamline workflows, making data navigation and debugging more efficient.

Available in Phoenix 8.0+

Phoenix prompt management will now let you create, modify, tag, and version control prompts for your applications. Some key highlights from this release:

• Versioning & Iteration: Seamlessly manage prompt versions in both Phoenix and your codebase.

• New TypeScript Client: Sync prompts with your JavaScript runtime, now with native support for OpenAI, Anthropic, and the Vercel AI SDK.

• New Python Client: Sync templates and apply them to AI SDKs like OpenAI, Anthropic, and more.

• Standardized Prompt Handling: Native normalization for OpenAI, Anthropic, Azure OpenAI, and Google AI Studio.

• Enhanced Metadata Propagation: Track prompt metadata on Playground spans and experiment metadata in dataset runs.

Available in Phoenix 8.0+

Phoenix has made it even simpler to get started with tracing by introducing one-line auto-instrumentation. By using register(auto_instrument=True), you can enable automatic instrumentation in your application, which will set up instrumentors based on your installed packages.

from phoenix.otel import register

register(auto_instrument=True)

Available in Phoenix 7.9+

In addition to using our automatic instrumentors and tracing directly using OTEL, we've now added our own layer to let you have the granularity of manual instrumentation without as much boilerplate code.

You can now access a tracer object with streamlined options to trace functions and code blocks. The main two options are using the decorator @tracer.chain and using the tracer in a with clause.

Available in Phoenix 7.0+

Sessions allow you to group multiple responses into a single thread. Each response is still captured as a single trace, but each trace is linked together and presented in a combined view.

Available in Phoenix 6.0+

Prompt Playground is now available in the Phoenix platform! This new release allows you to test the effects of different prompts, tools, and structured output formats to see which performs best.

• Replay individual spans with modified prompts, or run full Datasets through your variations.

• Easily test different models, prompts, tools, and output formats side-by-side, directly in the platform.

Available in Phoenix 5.0+

We've added Authentication and Rules-based Access Controls to Phoenix. This was a long-requested feature set, and we're excited for the new uses of Phoenix this will unlock!

Available in Phoenix 4.11.0+

Our integration with Guardrails AI allows you to capture traces on guard usage and create datasets based on these traces. This integration is designed to enhance the safety and reliability of your LLM applications, ensuring they adhere to predefined rules and guidelines.

Phoenix is now available for deployment as a fully hosted service.

We are partnering with LlamaIndex to power a new observability platform in LlamaCloud: LlamaTrace. LlamaTrace will automatically capture traces emitted from your LlamaIndex application.

Available in Phoenix 4.6+

Datasets: Datasets are a new core feature in Phoenix that live alongside your projects. They can be imported, exported, created, curated, manipulated, and viewed within the platform, and make fine-turning and experimentation easier.n

Available in Phoenix 4.6+