# Arize Phoenix | Phoenix

URL: https://docs.arize.com/phoenix

## Overview
Arize Phoenix is an open-source AI observability tool that enables engineers and data scientists to experiment, evaluate, and troubleshoot AI and LLM applications through features like prompt management, comprehensive tracing, and integration with various frameworks and SDKs.

## Documentation Pages

- [Arize Phoenix](https://docs.arize.com/phoenix): Arize Phoenix is an open-source observability tool for AI and LLM applications that enables engineers and data scientists to visualize data, evaluate performance, and troubleshoot issues while providing integration capabilities with OpenTelemetry and OpenInference.
- [Quickstarts](https://docs.arize.com/phoenix/quickstart): The Quickstarts page for Arize Phoenix provides a comprehensive introduction to getting started with various functionalities, including tracing, prompts, datasets, experiments, evaluation, and inferences, across different programming languages and platforms.
- [User Guide](https://docs.arize.com/phoenix/user-guide): The documentation for Phoenix outlines a comprehensive platform that facilitates observability and optimization for LLM-based systems through features such as tracing, prompt engineering, experimentation, and evaluation, ensuring efficient development and maintenance of high-quality applications.
- [Examples](https://docs.arize.com/phoenix/notebooks): The "Examples" documentation page for Phoenix showcases various applications and use cases, including agent examples, LLM tracing, datasets and experiments, and performance evaluations, all aimed at enhancing user understanding and implementation of Phoenix's features.
- [Environments](https://docs.arize.com/phoenix/environments): The documentation page outlines how to use the Phoenix application across different environments, including running it in cloud settings, local notebooks, or via terminal/containers, while emphasizing the need for proper environment variable configuration for connection and trace collection.
- [Self-Hosting](https://docs.arize.com/phoenix/deployment): The Self-Hosting documentation for Phoenix outlines the requirements, configurations, and deployment options for running the Phoenix server as a containerized application that collects and analyzes OpenTelemetry traces, supporting both SQLite and PostgreSQL as database options.
- [Configuration](https://docs.arize.com/phoenix/deployment/configuration): The documentation provides an overview of how to customize the self-hosted deployment of Phoenix, detailing the ports, environment variables, and server configurations necessary for operation.
- [Docker](https://docs.arize.com/phoenix/deployment/docker): This documentation page provides a comprehensive guide for installing and setting up the Arize Phoenix environment locally using Docker, including configuration for PostgreSQL or SQLite databases.
- [Kubernetes](https://docs.arize.com/phoenix/deployment/kubernetes): The documentation provides instructions for deploying Phoenix on Kubernetes using either SQLite with a persistent disk or PostgreSQL, detailing the necessary prerequisites and offering step-by-step commands for setup.
- [Authentication](https://docs.arize.com/phoenix/deployment/authentication): This documentation page details the setup and management of authentication in the Arize Phoenix platform, including enabling authentication, user management, API key configurations, and integrating with OAuth2 identity providers.
- [Overview: Tracing](https://docs.arize.com/phoenix/tracing/llm-traces): Phoenix provides comprehensive tracing capabilities for LLM applications through OpenTelemetry integration, enabling users to understand execution paths, performance bottlenecks, and optimize configurations across various frameworks and SDKs.
- [Quickstart: Tracing](https://docs.arize.com/phoenix/tracing/llm-traces-1): The "Quickstart: Tracing" documentation page provides a step-by-step guide on how to collect and view traces in Phoenix using decorators, automatic instrumentation, and OpenTelemetry configuration in both Python and TypeScript.
- [Features: Tracing](https://docs.arize.com/phoenix/tracing/features-tracing): The Tracing documentation for Phoenix outlines its capabilities for AI observability, emphasizing the importance of instrumenting application code to gain insights into execution flow, facilitate debugging, and analyze performance metrics through detailed trace and span analysis.
- [Projects](https://docs.arize.com/phoenix/tracing/features-tracing/projects): The "Projects" feature in Arize Phoenix allows users to organize their LLM traces for better clarity and focus by segregating data by environments, applications, experiments, and teams, thereby facilitating comparative analysis and collaborative efforts as applications scale.
- [Annotations](https://docs.arize.com/phoenix/tracing/features-tracing/how-to-annotate-traces): The Annotations documentation in Phoenix describes how to capture and utilize feedback from end-users and large language models (LLMs) through annotations, facilitating iterative improvements in LLM applications by allowing users to annotate traces with labels and scores, and enabling tracking of changes during experimentation.
- [Sessions](https://docs.arize.com/phoenix/tracing/features-tracing/sessions): Sessions in Phoenix allow for tracking and organizing related traces across multi-turn conversations in AI applications, ensuring context is maintained while providing insights into conversation history, token usage, and latency.
- [Integrations: Tracing](https://docs.arize.com/phoenix/tracing/integrations-tracing): The Tracing integrations documentation explains how Phoenix supports various frameworks and SDKs in Python and JavaScript through OpenTelemetry auto-instrumentation to efficiently capture and trace requests across multiple AI platforms.
- [OpenAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/openai): The documentation page provides a comprehensive guide on integrating OpenAI with Phoenix for tracing, including setup instructions, code samples for different deployment environments, and methods to configure the Phoenix API for observability and evaluation of OpenAI LLM and embedding calls.
- [OpenAI Agents SDK](https://docs.arize.com/phoenix/tracing/integrations-tracing/openai-agents-sdk): The OpenAI Agents SDK documentation provides comprehensive instructions for integrating the SDK with the Phoenix platform, including setup for tracing, launching applications, and using various features to enhance debugging and evaluation of multi-agent systems.
- [LlamaIndex](https://docs.arize.com/phoenix/tracing/integrations-tracing/llamaindex): LlamaIndex is a powerful data framework enabling the integration of retrieval-augmented generation (RAG) with LLMs, allowing users to trace and monitor applications using the Phoenix platform through the LlamaIndexInstrumentor and OpenTelemetry.
- [LlamaIndex Workflows](https://docs.arize.com/phoenix/tracing/integrations-tracing/llamaindex-1): The documentation provides a guide for setting up and using the LlamaIndexInstrumentor to trace LlamaIndex Workflows, enabling observability and evaluation of agent development within the Phoenix platform.
- [LangChain](https://docs.arize.com/phoenix/tracing/integrations-tracing/langchain): This documentation page provides a detailed guide on how to set up and use tracing for LangChain applications with Arize Phoenix, including installation instructions, API configuration, and example code for instrumenting prompts and chains.
- [LangGraph](https://docs.arize.com/phoenix/tracing/integrations-tracing/langgraph): The LangGraph documentation provides guidance on setting up and using tracing with Arize Phoenix, including installation instructions, environment configuration, and integration with LangChain for enhanced observability and evaluation in LangGraph applications.
- [LiteLLM](https://docs.arize.com/phoenix/tracing/integrations-tracing/litellm): LiteLLM is a tool that allows developers to interface with multiple language model APIs in OpenAI format, featuring auto-instrumentation to capture API call traces within the Phoenix platform.
- [Haystack](https://docs.arize.com/phoenix/tracing/integrations-tracing/haystack): The documentation page provides guidance on setting up and utilizing Phoenix for auto-instrumentation of Haystack applications, including installation, configuration, and integration for observability and evaluation of machine learning models.
- [Anthropic](https://docs.arize.com/phoenix/tracing/integrations-tracing/anthropic): This documentation page provides a comprehensive guide on integrating the Anthropic SDK with the Phoenix framework for tracing and observability of large language model applications, including installation instructions, setup configurations, and example usage.
- [VertexAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/vertexai): This documentation page provides instructions on setting up tracing for VertexAI's SDK using the Phoenix framework, including installation, configuration, and integration for observability and evaluation of model invocations.
- [Bedrock](https://docs.arize.com/phoenix/tracing/integrations-tracing/bedrock): The documentation provides instructions on how to instrument AWS Bedrock LLM calls using the BedrockInstrument with OpenInference for observability and evaluation in the Phoenix application.
- [MistralAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/mistralai): The documentation page provides guidance on setting up MistralAI's SDK for tracing and observability using Phoenix, including installation instructions, environment configuration, and example code for capturing and managing LLM interactions.
- [Groq](https://docs.arize.com/phoenix/tracing/integrations-tracing/groq): The documentation page provides instructions on setting up tracing for Groq API calls using Arize Phoenix, detailing how to install necessary packages, set environment variables, and run a Groq application while ensuring observability and evaluation of low-latency AI model interactions.
- [Hugging Face smolagents](https://docs.arize.com/phoenix/tracing/integrations-tracing/hfsmolagents): Hugging Face smolagents is a minimalist AI agent framework that simplifies the creation and deployment of powerful agents, with Phoenix providing tools for auto-instrumentation to track and visualize agent activities efficiently.
- [CrewAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/crewai): The documentation provides a comprehensive overview of how to set up and run CrewAI with Phoenix, including instructions for installation, configuration, and integration for tracing and observability of multi-agent applications.
- [DSPy](https://docs.arize.com/phoenix/tracing/integrations-tracing/dspy): The documentation page provides a comprehensive guide on setting up tracing for DSPy applications using Phoenix, detailing installation, configuration, and observation of LLM workflows through the Phoenix interface.
- [Instructor](https://docs.arize.com/phoenix/tracing/integrations-tracing/instructor): The documentation page provides a comprehensive guide for setting up and using the Instructor component in Phoenix, including installation, configuration, and implementation steps for tracing and extracting structured data from natural language using OpenAI models.
- [OpenAI Node SDK](https://docs.arize.com/phoenix/tracing/integrations-tracing/openai-node-sdk): The OpenAI Node SDK documentation outlines the steps for automatically instrumenting the SDK using OpenTelemetry, enabling tracing capabilities to monitor and analyze the interactions with OpenAI's services.
- [LangChain.js](https://docs.arize.com/phoenix/tracing/integrations-tracing/langchain.js): The documentation page provides guidance on automatically instrumenting the LangChain.js framework using the Arize AI's instrumentation for tracing, detailing installation, setup, and support for various LangChain versions.
- [Vercel AI SDK](https://docs.arize.com/phoenix/tracing/integrations-tracing/vercel-ai-sdk): The Vercel AI SDK OpenInference package provides utilities to ingest spans from Vercel AI SDK (version 3.3 or higher) into platforms like Arize and Phoenix, requiring the installation of OpenTelemetry and appropriate configurations for span processing and telemetry activation.
- [LangFlow](https://docs.arize.com/phoenix/tracing/integrations-tracing/langflow): Langflow is an open-source visual framework that enables developers to design, prototype, and deploy applications using large language models (LLMs), and integrates with Arize Phoenix for enhanced observability and performance tracking of LLM workflows.
- [BeeAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/beeai): The documentation provides a guide on integrating the BeeAI framework with OpenTelemetry for automatic instrumentation to collect and export telemetry data in your applications.
- [How-to: Tracing](https://docs.arize.com/phoenix/tracing/how-to-tracing): The "How-to: Tracing" documentation provides comprehensive guidance on setting up tracing in Phoenix using both auto and manual instrumentation methods, customizing spans and attributes, and querying and logging evaluation results for performance tracking.
- [Setup Tracing](https://docs.arize.com/phoenix/tracing/how-to-tracing/setup-tracing): The "Setup Tracing" documentation provides guidelines for configuring tracing in Phoenix using decorators, Base OpenTelemetry, and TypeScript, along with instructions for managing projects and sessions.
- [Setup Tracing using Phoenix Decorators](https://docs.arize.com/phoenix/tracing/how-to-tracing/setup-tracing/instrument-python): This documentation page offers instructions on setting up tracing in OpenInference using decorators, enabling easier instrumentation of functions, chains, agents, and tools with OpenTelemetry.
- [Setup Tracing using Base OTEL](https://docs.arize.com/phoenix/tracing/how-to-tracing/setup-tracing/custom-spans): The documentation page provides a comprehensive guide on setting up tracing in Phoenix using the OpenTelemetry (OTEL) Trace API, detailing how to configure a tracer, create and manage spans, and utilize semantic attributes for enhanced tracking in your application.
- [Setup Tracing (TS)](https://docs.arize.com/phoenix/tracing/how-to-tracing/setup-tracing/javascript): This documentation page provides a detailed guide on setting up tracing for Node.js applications using OpenTelemetry with Phoenix, including installation procedures, SDK initialization, and how to create spans for telemetry data capture.
- [Setup Projects](https://docs.arize.com/phoenix/tracing/how-to-tracing/setup-tracing/setup-projects): The "Setup Projects" section of the Phoenix documentation explains how to log traces to specific projects by setting the PHOENIX_PROJECT_NAME environment variable or using the project name in the registration function, facilitating the grouping of traces for effective organization during trace data analysis.
- [Setup Sessions](https://docs.arize.com/phoenix/tracing/how-to-tracing/setup-tracing/setup-sessions): The "Setup Sessions" documentation page explains how to track and manage sessions in Arize Phoenix by associating traces with unique session identifiers and provides examples for Python and TypeScript implementations.
- [Add Metadata](https://docs.arize.com/phoenix/tracing/how-to-tracing/add-metadata): The "Add Metadata" section outlines how to enhance tracing by incorporating custom attributes, user IDs, session IDs, and prompt templates to better instrument and customize trace data.
- [Add Attributes, Metadata, Users](https://docs.arize.com/phoenix/tracing/how-to-tracing/add-metadata/customize-spans): The documentation page provides instructions on how to add attributes, metadata, users, and tags to spans in Phoenix using the OpenTelemetry context, including the use of context managers and decorators for customized span management.
- [Instrument Prompt Templates and Prompt Variables](https://docs.arize.com/phoenix/tracing/how-to-tracing/add-metadata/instrumenting-prompt-templates-and-prompt-variables): This documentation page explains how to instrument prompt templates and variables in order to track and visualize prompt changes using OpenTelemetry, enabling performance measurement through associated attributes in spans.
- [Feedback & Annotations](https://docs.arize.com/phoenix/tracing/how-to-tracing/feedback-and-annotations): The Feedback & Annotations documentation for Phoenix describes how to incorporate various types of feedback and annotations into traces, including human evaluations, LLM-generated labels, and manual annotations, to enhance trace analysis and evaluation processes.
- [Capture Feedback on Traces](https://docs.arize.com/phoenix/tracing/how-to-tracing/feedback-and-annotations/capture-feedback): The "Capture Feedback on Traces" documentation page explains how to collect and attach user feedback as annotations to spans in Arize Phoenix, allowing for better evaluation and understanding of application performance through user input.
- [Evaluating Phoenix Traces](https://docs.arize.com/phoenix/tracing/how-to-tracing/feedback-and-annotations/evaluating-phoenix-traces): This documentation page provides a step-by-step guide for evaluating traces captured in Phoenix, detailing how to prepare a trace dataset, generate evaluations, and upload the results to the Phoenix UI.
- [Log Evaluation Results](https://docs.arize.com/phoenix/tracing/how-to-tracing/feedback-and-annotations/llm-evaluations): The "Log Evaluation Results" documentation page explains how to send LLM evaluation results in dataframes to Phoenix, detailing the requirements for the evaluation data, connection setup, and methods for logging multiple evaluation dataframes along with project specification.
- [Importing & Exporting Traces](https://docs.arize.com/phoenix/tracing/how-to-tracing/importing-and-exporting-traces): The "Importing & Exporting Traces" documentation page provides guidance on how to import existing trace data into Phoenix and export trace data for querying.
- [Import Existing Traces](https://docs.arize.com/phoenix/tracing/how-to-tracing/importing-and-exporting-traces/importing-existing-traces): The documentation page explains how to import existing OpenInference traces into a Phoenix instance, detailing the necessary environment variable configurations and code snippets for loading traces from a dataframe or local file.
- [Export Data & Query Spans](https://docs.arize.com/phoenix/tracing/how-to-tracing/importing-and-exporting-traces/extract-data-from-spans): The "Export Data & Query Spans" documentation page provides detailed methods for exporting data from Phoenix, including options for downloading spans as dataframes, running span queries, applying filters, and extracting attributes for evaluations.
- [Advanced](https://docs.arize.com/phoenix/tracing/how-to-tracing/advanced): This documentation page provides instructions on advanced tracing techniques in Phoenix, including how to mask PII, suppress tracing, filter spans, and capture multimodal traces.
- [Mask Span Attributes](https://docs.arize.com/phoenix/tracing/how-to-tracing/advanced/masking-span-attributes): The "Mask Span Attributes" documentation page provides guidance on configuring observability settings for tracing in Phoenix, allowing users to hide sensitive inputs and outputs or limit the size of logged data through environment variables or code settings.
- [Suppress Tracing](https://docs.arize.com/phoenix/tracing/how-to-tracing/advanced/suppress-tracing): The "Suppress Tracing" documentation provides guidance on how to temporarily pause or permanently disable tracing in your code using context managers and auto-instrumentor uninstrumentation.
- [Filter Spans](https://docs.arize.com/phoenix/tracing/how-to-tracing/advanced/modifying-spans): The documentation page explains how to filter out or modify specific spans from being sent to Phoenix by implementing a custom `SpanProcessor` in OpenTelemetry.
- [Capture Multimodal Traces](https://docs.arize.com/phoenix/tracing/how-to-tracing/advanced/multimodal-tracing): The "Capture Multimodal Traces" documentation page outlines how to display images in Phoenix by connecting to a Phoenix instance and using OpenAI calls with base64-encoded images or image URLs.
- [Concepts: Tracing](https://docs.arize.com/phoenix/tracing/concepts-tracing): The "Tracing" documentation page provides an overview of tracing concepts, setup instructions, features, and integration options in the Phoenix framework for tracking and evaluating AI and model performance.
- [How Tracing Works](https://docs.arize.com/phoenix/tracing/concepts-tracing/how-does-tracing-work): The "How Tracing Works" documentation explains the components involved in tracing with Phoenix, including the role of instrumentation, exporters, collectors, and the OpenTelemetry Protocol (OTLP) for real-time troubleshooting of applications.
- [FAQs: Tracing](https://docs.arize.com/phoenix/tracing/concepts-tracing/faqs-tracing): The FAQs: Tracing documentation page provides guidance on how to log traces, manage tracing settings, and handle specific scenarios like getting token counts from streaming with OpenAI and customizing LangChain components for trace compatibility.
- [What are Traces](https://docs.arize.com/phoenix/tracing/concepts-tracing/what-are-traces): The "What are Traces" documentation page explains that traces are records of the paths taken by requests through an application, composed of spans that track specific operations, enhancing visibility and debugging for complex systems, particularly in LLM applications.
- [Use Cases: Tracing](https://docs.arize.com/phoenix/tracing/use-cases-tracing): The "Use Cases: Tracing" documentation page provides examples of how to leverage Phoenix tracing to enhance application performance and optimization across various integrations and use cases.
- [Evaluate RAG](https://docs.arize.com/phoenix/tracing/use-cases-tracing/rag-evaluation): This documentation page provides a tutorial on building and evaluating a Retrieval-Augmented Generation (RAG) pipeline using Phoenix Evals, highlighting the stages of RAG, data loading, indexing, querying, and performance evaluation metrics.
- [Structured Data Extraction](https://docs.arize.com/phoenix/tracing/use-cases-tracing/structured-extraction): This documentation page provides an overview of structured data extraction using large language models (LLMs) to extract structured information from unstructured text, detailing implementation, inspection, and evaluation strategies for the extraction process.
- [Overview: Prompts](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts): The "Overview: Prompts" documentation page provides insights into prompt engineering, highlighting features such as prompt management, a prompt playground for experimentation, and the importance of optimizing prompts for effective interactions with language models.
- [Prompt Management](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts/prompt-management): The Prompt Management documentation page explains how to systematically create, store, and modify prompts for interacting with large language models (LLMs), emphasizing benefits such as reusability, versioning, and collaboration to improve consistency and experimentation.
- [Prompt Playground](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts/prompt-playground): The Prompt Playground in Phoenix facilitates rapid iteration and testing of prompts across multiple AI providers, offering features like trace recording, dataset integration, and extensive prompt management tools for effective experimentation and evaluation.
- [Span Replay](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts/span-replay): The Span Replay feature in Phoenix allows users to replay previously traced LLM spans in the Prompt Playground, aiding in debugging and optimizing LLM performance by comparing outputs and adjusting parameters.
- [Prompts in Code](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts/prompts-in-code): The "Prompts in Code" documentation explains how to manage and manipulate prompts using Phoenix's Python and TypeScript SDKs, allowing for dynamic creation, updating, and formatting of prompts with runtime variables while supporting multiple AI providers.
- [Quickstart: Prompts](https://docs.arize.com/phoenix/prompt-engineering/quickstart-prompts): The Quickstart: Prompts documentation provides guidelines on creating, iterating, versioning, tagging, and utilizing prompts in Phoenix through the UI and Python/TypeScript SDKs, featuring a Prompt Playground for comparing prompt variations.
- [Quickstart: Prompts (UI)](https://docs.arize.com/phoenix/prompt-engineering/quickstart-prompts/quickstart-prompts-ui): The "Quickstart: Prompts (UI)" documentation provides a step-by-step guide for creating, testing, and updating prompts in the Phoenix application, including how to run prompts over datasets and manage multiple prompt versions.
- [Quickstart: Prompts (Python)](https://docs.arize.com/phoenix/prompt-engineering/quickstart-prompts/quickstart-prompts-python): The "Quickstart: Prompts (Python)" documentation provides a step-by-step guide for setting up and using prompts with the Phoenix SDK in Python, covering installation, creating, retrieving, and updating prompts.
- [Quickstart: Prompts (TS)](https://docs.arize.com/phoenix/prompt-engineering/quickstart-prompts/quickstart-prompts-ts): This documentation provides a quickstart guide for setting up and using Phoenix Prompts with TypeScript, covering installation, prompt creation, retrieval, and integration with different SDKs.
- [How to: Prompts](https://docs.arize.com/phoenix/prompt-engineering/how-to-prompts): This documentation page provides a comprehensive guide on how to perform prompt engineering using Phoenix, including configuring AI providers, managing prompts, creating and testing prompts, and utilizing the prompt playground for development.
- [Configure AI Providers](https://docs.arize.com/phoenix/prompt-engineering/how-to-prompts/configure-ai-providers): The "Configure AI Providers" documentation page explains how to securely set API keys for integrating AI providers like OpenAI, Azure OpenAI, Anthropic, and Google AI Studio in Phoenix, offering options for browser storage or server-side environment variables.
- [Using the Playground](https://docs.arize.com/phoenix/prompt-engineering/how-to-prompts/using-the-playground): The documentation page provides a guide on using the Phoenix Playground to create, test, and compare prompts for LLMs, configure models, and run experiments with datasets while tracking all activities in the Playground for analysis.
- [Create a prompt](https://docs.arize.com/phoenix/prompt-engineering/how-to-prompts/create-a-prompt): The documentation page explains how to create, manage, and edit prompts in Phoenix using both the Playground interface and programmatically via the Phoenix client in Python or TypeScript.
- [Test a prompt](https://docs.arize.com/phoenix/prompt-engineering/how-to-prompts/test-a-prompt): The "Test a Prompt" documentation page explains how to efficiently test and refine AI prompts using the Playground, including methods for testing individual prompts, evaluating them against datasets, comparing variations side-by-side, and implementing testing through code.
- [Tag a prompt](https://docs.arize.com/phoenix/prompt-engineering/how-to-prompts/tag-a-prompt): The documentation page explains how to tag prompts in Phoenix for version control, allowing users to deploy specific versions to different environments and track their modification history.
- [Using a prompt](https://docs.arize.com/phoenix/prompt-engineering/how-to-prompts/using-a-prompt): This documentation page outlines how to use prompts in the Phoenix framework, detailing methods for pulling prompts by name, ID, version, or tag, including best practices, integration considerations, and examples for both Python and TypeScript.
- [Concepts: Prompts](https://docs.arize.com/phoenix/prompt-engineering/concepts-prompts): The "Concepts: Prompts" documentation page provides an overview of how prompts are defined, managed, and utilized in Phoenix, emphasizing the importance of prompt templates, versioning, tagging, formatting, and the tools that enhance LLM interactions while ensuring structured response outputs.
- [Use Cases: Prompts](https://docs.arize.com/phoenix/prompt-engineering/use-cases-prompts): Prompt engineering involves the development and optimization of prompts to enhance the performance of language models across various applications, enabling better understanding and interaction with these models.
- [Prompt Optimization](https://docs.arize.com/phoenix/prompt-engineering/use-cases-prompts/prompt-optimization): This documentation page provides a comprehensive tutorial on using various prompt optimization techniques in Phoenix to enhance performance on a jailbreak classification task, including methods such as Few Shot Examples, Meta Prompting, Prompt Gradient Optimization, DSPy Prompt Tuning, and utilizing different models.
- [ReAct Prompting](https://docs.arize.com/phoenix/prompt-engineering/use-cases-prompts/react-prompting): ReAct Prompting is a technique that enhances LLM performance by guiding it to reason step-by-step before utilizing tools for problem-solving, thus improving transparency and enabling better task execution in real-world scenarios.
- [Chain-of-Thought Prompting](https://docs.arize.com/phoenix/prompt-engineering/use-cases-prompts/chain-of-thought-prompting): The Chain-of-Thought Prompting documentation explains how to enhance a language model's reasoning abilities through structured prompting techniques, demonstrating their effectiveness in solving complex tasks like math problems by guiding the model to think step by step.
- [Few Shot Prompting](https://docs.arize.com/phoenix/prompt-engineering/use-cases-prompts/few-shot-prompting): The "Few Shot Prompting" documentation page describes a technique in prompt engineering that enhances the performance of language models by providing multiple examples in prompts, demonstrating its effectiveness through a sentiment analysis task and tracking prompt impact on model results using the Phoenix framework.
- [Overview: Datasets](https://docs.arize.com/phoenix/datasets-and-experiments/overview-datasets): The documentation page provides an overview of datasets and experiments, emphasizing their importance in evaluating AI applications by collecting examples for assessment and enabling developers to conduct experiments for reliable performance feedback.
- [Quickstart: Datasets](https://docs.arize.com/phoenix/datasets-and-experiments/quickstart-datasets): The "Quickstart: Datasets" documentation outlines how to quickly set up the Phoenix framework to upload datasets, create evaluation tasks, define evaluators, and run experiments to improve AI and LLM application performance.
- [Concepts: Datasets](https://docs.arize.com/phoenix/datasets-and-experiments/concepts-datasets): Datasets in Phoenix are essential for experimentation and evaluation, allowing users to create, manage, and track collections of examples that include inputs, optional outputs, and metadata to assess application performance over time.
- [How-to: Datasets](https://docs.arize.com/phoenix/datasets-and-experiments/how-to-datasets): The "How-to: Datasets" documentation page outlines methods for creating and exporting datasets in Phoenix, highlighting various sources such as CSV files and Pandas, and emphasizing their significance for developing robust prompts, evaluations, and fine-tuning.
- [Creating Datasets](https://docs.arize.com/phoenix/datasets-and-experiments/how-to-datasets/creating-datasets): The "Creating Datasets" documentation page details various methods for uploading datasets to the Phoenix platform, including using CSV files, Pandas DataFrames, object syntax, and synthetic data generation, with specific examples provided for each approach.
- [Exporting Datasets](https://docs.arize.com/phoenix/datasets-and-experiments/how-to-datasets/exporting-datasets): The "Exporting Datasets" documentation page outlines how to export datasets in Phoenix, including options for CSV formatting, fine-tuning with OpenAI JSONL, and utilizing OpenAI Evals for model evaluation.
- [How-to: Experiments](https://docs.arize.com/phoenix/datasets-and-experiments/how-to-experiments): The "How-to: Experiments" documentation page provides guidelines on running experiments, uploading datasets, configuring and using evaluators, and conducting custom tasks within the Phoenix platform.
- [Run Experiments](https://docs.arize.com/phoenix/datasets-and-experiments/how-to-experiments/run-experiments): The "Run Experiments" documentation provides a step-by-step guide for setting up and executing experiments using Phoenix, including defining datasets, tasks, evaluators, and running the experiment within the framework.
- [Using Evaluators](https://docs.arize.com/phoenix/datasets-and-experiments/how-to-experiments/using-evaluators): The documentation page outlines how to use evaluators in Phoenix for assessing LLM and code outputs, providing examples of built-in evaluators, custom evaluator creation, and integration with experimental runs.
- [Use Cases: Experiments](https://docs.arize.com/phoenix/datasets-and-experiments/use-cases-datasets): The "Use Cases: Experiments" documentation page outlines how datasets and experiments enhance LLM applications by focusing on optimizing prompt techniques, Txt2SQL, document summarization, and email extraction.
- [Prompt Optimization](https://docs.arize.com/phoenix/datasets-and-experiments/use-cases-datasets/prompt-optimization): The "Prompt Optimization" section of the documentation provides various techniques and strategies, such as ReAct Prompting and Few-Shot Prompting, for enhancing the effectiveness and performance of AI prompts.
- [Text2SQL](https://docs.arize.com/phoenix/datasets-and-experiments/use-cases-datasets/text2sql): This documentation page provides a step-by-step guide for implementing a Text2SQL application using the Phoenix framework, including setting up the environment, constructing SQL queries from natural language, evaluating results, generating synthetic data, and optimizing model performance.
- [Summarization](https://docs.arize.com/phoenix/datasets-and-experiments/use-cases-datasets/summarization): This documentation page provides a step-by-step tutorial on using the Phoenix platform to create a summarization model, including dataset preparation, experiment setup, prompt engineering, and evaluation of summaries generated by different language models.
- [Email Extraction](https://docs.arize.com/phoenix/datasets-and-experiments/use-cases-datasets/email-extraction): The Email Extraction documentation page provides guidance on extracting email addresses using Phoenix, detailing setup instructions and use cases.
- [Overview: Evals](https://docs.arize.com/phoenix/evaluation/llm-evals): The Phoenix LLM Evals documentation outlines a robust framework for efficiently evaluating large language model (LLM) outputs through pre-tested templates and rigorous benchmarking, enabling high-throughput evaluations across various environments while ensuring reproducibility and integration with popular tools like LangChain and LlamaIndex.
- [Quickstart: Evals](https://docs.arize.com/phoenix/evaluation/evals): The "Quickstart: Evals" documentation page provides a step-by-step guide on how to install Phoenix Evals, prepare your dataset, and perform evaluations using built-in evaluators, including logging results for visualization in Phoenix.
- [Concepts: Evals](https://docs.arize.com/phoenix/evaluation/concepts-evals): The "Concepts: Evals" documentation page provides an overview of evaluating and monitoring applications using various methods, including leveraging language models as judges and custom task evaluations.
- [LLM as a Judge](https://docs.arize.com/phoenix/evaluation/concepts-evals/llm-as-a-judge): The "LLM as a Judge" documentation explains how to enhance the evaluation of language model outputs by using another LLM to assess various criteria such as hallucination, toxicity, and accuracy, thus improving efficiency and scalability in the evaluation process.
- [Eval Data Types](https://docs.arize.com/phoenix/evaluation/concepts-evals/evaluation-types): The Eval Data Types documentation outlines the different evaluation types supported by the Phoenix Library, highlighting the advantages of categorical evaluations over score-based evaluations for consistent decision-making in production environments.
- [Evals With Explanations](https://docs.arize.com/phoenix/evaluation/concepts-evals/evals-with-explanations): The "Evals With Explanations" documentation page describes how to obtain both evaluation outputs and their corresponding explanations from a language model using Phoenix, facilitating debugging of language model evaluations.
- [Evaluators](https://docs.arize.com/phoenix/evaluation/concepts-evals/evaluation): The documentation page outlines the evaluation capabilities of the Phoenix platform, detailing how to assess the quality of generated responses and retrievals within large language model applications, emphasizing the importance of evaluations for performance measurement and troubleshooting.
- [Custom Task Evaluation](https://docs.arize.com/phoenix/evaluation/concepts-evals/building-your-own-evals): The "Custom Task Evaluation" documentation page provides a step-by-step guide for building personalized evaluation templates using the LLM Evals library, outlining the process of choosing metrics, creating a golden dataset, selecting an LLM for evaluation, designing the evaluation template, and benchmarking performance on the dataset.
- [How to: Evals](https://docs.arize.com/phoenix/evaluation/how-to-evals): The "How to: Evals" documentation page provides guidance on using Phoenix Evaluators for various evaluation tasks, such as assessing AI performance, conducting online evaluations, and handling multimodal inputs.
- [Use Phoenix Evaluators](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals): The documentation page provides an overview of using Phoenix Evaluators, detailing supported models, benchmarking methods, and pre-tested evaluation templates for assessing the performance of language models.
- [Hallucinations](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/hallucinations): The "Hallucinations" documentation page explains the evaluation template designed to identify whether a model's generated responses contain hallucinations, specifically by analyzing the accuracy of answers based on referenced data.
- [Q&A on Retrieved Data](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/q-and-a-on-retrieved-data): The Q&A on Retrieved Data documentation outlines how to use the Q&A evaluation template to determine if a system's answer correctly addresses a given question based on reference context, and provides benchmarks for evaluating model performance.
- [Retrieval (RAG) Relevance](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/retrieval-rag-relevance): The "Retrieval (RAG) Relevance" documentation page provides guidelines on how to evaluate the relevance of retrieved chunks of information in response to specific queries using a predefined evaluation template and classification process.
- [Summarization](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/summarization-eval): The documentation page provides a guide on using the Summarization Eval Template to evaluate the quality of summaries against their original documents, detailing the required input variables, comparison criteria, and example code for implementation.
- [Code Generation](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/code-generation-eval): The Code Generation documentation page explains how to use a code readability evaluation template to assess the correctness and readability of generated code, detailing its implementation and benchmark results with various AI models.
- [Toxicity](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/toxicity): The Toxicity Eval documentation describes how to evaluate text for toxicity—defined as hateful, disparaging, or violent content—using a specific template and model, and provides instructions for running the evaluation along with benchmark results from various AI models.
- [AI vs Human (Groundtruth)](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/ai-vs-human-groundtruth): The "AI vs Human (Groundtruth)" documentation page explains how to evaluate AI-generated answers against human expert answers to assess accuracy and substance in responses, particularly within Retrieval-Augmented Generation (RAG) systems.
- [Reference (citation) Link](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/reference-link-evals): The documentation page provides guidelines on running citation evaluations in Phoenix, detailing model options and evaluation metrics for various AI models, thus answering common questions in the context of Q&A systems.
- [User Frustration](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/user-frustration): The User Frustration evaluation template assesses user interactions with conversation bots, determining if the user felt frustrated or satisfied based on the conversation's progression and concluding state.
- [SQL Generation Eval](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/sql-generation-eval): The SQL Generation Eval documentation provides guidelines for evaluating the correctness of SQL queries generated from human language prompts by analyzing the generated SQL in the context of specified instructions and responses.
- [Agent Function Calling Eval](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/tool-calling-eval): The Agent Function Calling Eval documentation outlines how to evaluate a model's ability to correctly select and execute tool calls based on user queries, including a prompt template and usage instructions.
- [Audio Emotion Detection](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals/audio-emotion-detection): The Audio Emotion Detection documentation outlines a template for classifying emotions from audio files by analyzing characteristics such as tone, pitch, pace, volume, and intensity to determine the most dominant emotion expressed.
- [Bring Your Own Evaluator](https://docs.arize.com/phoenix/evaluation/how-to-evals/bring-your-own-evaluator): This documentation page outlines how to create a custom evaluator within the Phoenix framework, requiring a dataset and a template prompt for evaluation, with examples for both categorical and numeric evaluations using specific functions.
- [Online Evals](https://docs.arize.com/phoenix/evaluation/how-to-evals/online-evals): The documentation provides a guide on using cron jobs to run periodic evaluations in Phoenix, which automatically processes traces and spans generated from a LangChain application to enhance the dataset with logs of evaluation results such as hallucination and relevance.
- [Multimodal Evals](https://docs.arize.com/phoenix/evaluation/how-to-evals/multimodal-evals): The Multimodal Evals documentation page provides guidelines for creating and utilizing evaluation templates that assess tasks across multiple input and output modalities, enabling users to evaluate diverse data types such as text, audio, and images effectively.
- [Use Cases: Evals](https://docs.arize.com/phoenix/use-cases-evals): The "Use Cases: Evals" documentation page provides end-to-end examples demonstrating the various applications for evaluating agents and models, including specific evaluations like assessing a Talk-to-your-Data agent and supporting multimodal evaluations.
- [Evaluating a Data Agent](https://docs.arize.com/phoenix/use-cases-evals/evaluating-a-data-agent): The "Evaluating a Data Agent" documentation page provides guidance on how to assess the performance and effectiveness of data agents within the Phoenix platform, including relevant concepts, methods, and use cases.
- [Overview: Retrieval](https://docs.arize.com/phoenix/retrieval/overview-retrieval): The "Overview: Retrieval" documentation page explains how Retrieval Augmented Generation (RAG) systems in Phoenix can evaluate and troubleshoot the effectiveness of their data retrieval processes to ensure relevance and accuracy in responses generated by large language models.
- [Quickstart: Retrieval](https://docs.arize.com/phoenix/retrieval/quickstart-retrieval): The Quickstart: Retrieval documentation provides instructions for logging retrievals from a vector datastore to Phoenix and running evaluations on those retrievals using various frameworks like LangChain and LlamaIndex.
- [Concepts: Retrieval](https://docs.arize.com/phoenix/retrieval/concepts-retrieval): The "Retrieval" documentation page provides best practices and guidance for troubleshooting, evaluating search and retrieval use cases, including benchmarking retrieval and conducting retrieval evaluations on document chunks.
- [Retrieval with Embeddings](https://docs.arize.com/phoenix/retrieval/concepts-retrieval/troubleshooting-llm-retrieval-with-vector-stores): The documentation page provides an overview of how to evaluate retrieval systems using embeddings, detailing methods to assess the correctness of LLM responses, the relevance of retrieved documents, and to identify knowledge gaps in a corpus to improve chatbot performance.
- [Benchmarking Retrieval](https://docs.arize.com/phoenix/retrieval/concepts-retrieval/benchmarking-retrieval-rag): The documentation page on "Benchmarking Retrieval" discusses the evaluation and performance analysis of Retrieval Augmented Generation (RAG) systems, focusing on metrics for assessing retrieval effectiveness and how to configure parameters like chunk size and retrieval approach for optimal results.
- [Retrieval Evals on Document Chunks](https://docs.arize.com/phoenix/retrieval/concepts-retrieval/retrieval-evals-on-document-chunks): The "Retrieval Evals on Document Chunks" documentation page explains how to assess the effectiveness of retrieval systems by evaluating the relevance of document chunks returned by queries, using helper functions provided by Phoenix to generate evaluation results for each chunk.
- [Quickstart: Inferences](https://docs.arize.com/phoenix/inferences/phoenix-inferences): The "Quickstart: Inferences" documentation provides a step-by-step guide for using Phoenix to visualize and analyze model inferences, from installing dependencies to launching the application with training and production datasets for comparative analysis.
- [How-to: Inferences](https://docs.arize.com/phoenix/inferences/how-to-inferences): The "How-to: Inferences" documentation page provides guidance on importing data, managing applications, exporting data for various purposes, and generating embeddings within the Phoenix platform.
- [Import Your Data](https://docs.arize.com/phoenix/inferences/how-to-inferences/define-your-schema): The "Import Your Data" documentation page explains how to create Phoenix inferences and schemas using various data formats, detailing the process of defining datasets from pandas dataframes and specifying schemas that include predictions, actuals, features, and embeddings.
- [Prompt and Response (LLM)](https://docs.arize.com/phoenix/inferences/how-to-inferences/define-your-schema/prompt-and-response-llm): This documentation page provides a guide on how to import prompts and responses from a Large Language Model (LLM), particularly for use in Retrieval-Augmented Generation (RAG) scenarios, along with examples of dataframes and schema definitions for managing inference data.
- [Retrieval (RAG)](https://docs.arize.com/phoenix/inferences/how-to-inferences/define-your-schema/retrieval-rag): This documentation page details the process of importing data for Retrieval-Augmented Generation (RAG) in Phoenix, emphasizing the requirement for matching retrieved document IDs and relevance scores within a specified dataframe schema.
- [Corpus Data](https://docs.arize.com/phoenix/inferences/how-to-inferences/define-your-schema/corpus-data): The "Corpus Data" documentation page explains how to create inferences and schemas for corpus data to enhance user queries with Retrieval-Augmented Generation (RAG) using a collection of documents to provide a knowledge base for a Large Language Model.
- [Export Data](https://docs.arize.com/phoenix/inferences/how-to-inferences/export-your-data): The documentation page provides instructions on how to export data, specifically embeddings, from the Phoenix UI, detailing methods for exporting selected clusters or all clusters as a dataframe.
- [Generate Embeddings](https://docs.arize.com/phoenix/inferences/how-to-inferences/generating-embeddings): The documentation page explains how to generate embeddings using the Arize Phoenix Python SDK, including the automatic generation of embeddings for various data types like computer vision, natural language, and tabular data with minimal user code required.
- [Manage the App](https://docs.arize.com/phoenix/inferences/how-to-inferences/manage-the-app): This documentation page explains how to manage inferences in the Phoenix application, including defining inference sets, launching a session, accessing the UI, and properly closing the session.
- [Use Example Inferences](https://docs.arize.com/phoenix/inferences/how-to-inferences/use-example-inferences): The "Use Example Inferences" documentation page provides guidance on how to download, inspect, and launch Phoenix applications using concrete examples of inferences, including steps to load example data and explore its structure.
- [Concepts: Inferences](https://docs.arize.com/phoenix/inferences/inferences): The Inferences documentation explains how to define and use inferences and schemas in Phoenix, detailing their components, the need for primary and reference inference sets, and the creation of schemas for different types of data.
- [API: Inferences](https://docs.arize.com/phoenix/inferences/inference-and-schema): The "API: Inferences" documentation page provides detailed descriptions of the classes and methods used for creating and managing inferences with the Phoenix platform, including how to process and analyze data using schemas and handle embedding features.
- [Use-Cases: Inferences](https://docs.arize.com/phoenix/inferences/use-cases-inferences): The "Use-Cases: Inferences" section of the Phoenix documentation outlines various applications and practical scenarios for utilizing inference models within the platform.
- [Embeddings Analysis](https://docs.arize.com/phoenix/inferences/use-cases-inferences/embeddings-analysis): The "Embeddings Analysis" documentation page in Phoenix provides insights into monitoring embedding drift and performance by utilizing euclidean distance metrics, clustering algorithms, and UMAP point-cloud visualizations to analyze semantic meaning and identify anomalies over time.
- [Session](https://docs.arize.com/phoenix/api/session): The documentation covers the session management in Phoenix, detailing methods to launch, access, and close sessions, configure parameters, handle data exports, filter spans, and manage environment variables for optimal use of the platform.
- [Client](https://docs.arize.com/phoenix/api/client): The documentation page provides an overview of the `phoenix.Client` class, detailing its methods for uploading and downloading data to and from Phoenix servers using HTTP requests, along with parameters for customizing these operations.
- [Evals](https://docs.arize.com/phoenix/api/evals): The documentation page provides an overview of the Phoenix Evals functionality, detailing how to evaluate outputs generated by LLMs using various evaluators, alongside example usages for running evaluations, classifying data, and generating prompts.
- [Models](https://docs.arize.com/phoenix/api/evaluation-models): This documentation page outlines the API models available for integrating various large language models (LLMs) such as OpenAI, Vertex AI, and others, detailing their configuration, authentication requirements, and usage examples within Arize Phoenix Evals.
- [Ragas](https://docs.arize.com/phoenix/integrations/ragas): The Ragas documentation page outlines how to enhance RAG (Retrieval-Augmented Generation) pipelines with the integration of Ragas for synthetic data generation and evaluation, alongside the Phoenix framework for tracing and analysis, helping users build robust workflows and ensure response quality.
- [Frequently Asked Questions](https://docs.arize.com/phoenix/reference/frequently-asked-questions): The Frequently Asked Questions (FAQs) documentation page for Phoenix provides answers regarding its features, usage, integration options, pricing, and compatibility with other tools and environments.
- [OpenInference](https://docs.arize.com/phoenix/reference/open-inference): OpenInference is an open standard that delineates specifications for model inference and LLM application tracing, facilitating the capture of application execution and inference logs across various model types.
- [Resources](https://docs.arize.com/phoenix/reference/resources): The documentation page offers a comprehensive overview of Arize Phoenix, detailing its functionalities for enhancing observability in Large Language Models (LLMs) through setup instructions for tracing, integration with various APIs, and methods for performance evaluation and optimization.
- [Contribute to Phoenix](https://docs.arize.com/phoenix/reference/contribute-to-phoenix): This documentation page provides guidelines for contributing to the Phoenix project, detailing steps for picking issues, submitting code, and the review process.
- [Release Notes](https://docs.arize.com/phoenix/reference/release-notes): The Release Notes documentation page provides an overview of recent updates and improvements to the Phoenix platform, including new features, enhancements, and bug fixes related to tracing, prompts, projects, sessions, and authentication, among others.
- [Tracing](https://docs.arize.com/phoenix/tracing/llm-traces): Phoenix provides extensive tracing capabilities for LLM applications via OpenTelemetry, allowing users to monitor execution paths, performance metrics, and operational insights to enhance reliability and efficiency across various frameworks and SDKs.
- [Prompts](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts): The documentation page provides an overview of prompt engineering in Phoenix, highlighting features such as prompt management, a prompt playground for testing, and tools for tracking and optimizing prompts for large language model interactions.
- [Datasets and Experiments](https://docs.arize.com/phoenix/datasets-and-experiments/overview-datasets#datasets): The "Datasets & Experiments" overview explains how datasets are essential for evaluating AI applications by providing the necessary input examples for assessments, while experiments help developers understand the impact of changes on performance, ultimately leading to improved product reliability.
- [Evals](https://docs.arize.com/phoenix/evaluation/llm-evals): The Phoenix LLM Evals library offers a fast, robust solution for evaluating large language model performance through pre-tested templates, data science rigor, and support for varying environments, ensuring reliable results for production use.
- [AI Providers](https://docs.arize.com/phoenix/prompt-engineering/how-to-prompts/configure-ai-providers): The documentation page outlines how to configure AI Providers in Phoenix, detailing options for securely storing API keys, setting environment variables for various AI platforms such as OpenAI and Anthropic, and integrating with OpenAI-compatible LLM providers.
- [Features](https://docs.arize.com/phoenix#features): Arize Phoenix is an open-source AI observability tool that facilitates experimentation, evaluation, and troubleshooting of AI and LLM applications by providing features such as prompt management, tracing capabilities, and tools for running evaluations on datasets.
- [Quickstarts](https://docs.arize.com/phoenix#quickstarts): Arize Phoenix is an open-source observability tool designed for AI and LLM applications that facilitates experimentation, evaluation, and troubleshooting through comprehensive tracing, prompt engineering, and dataset management.
- [Next Steps](https://docs.arize.com/phoenix#next-steps): Arize Phoenix is an open-source observability tool designed to facilitate the experimentation, evaluation, and troubleshooting of AI and LLM applications, enabling developers to visualize data, assess performance, and improve models through comprehensive tracing, prompt engineering, and dataset management features.
- [Try our Tutorials](https://docs.arize.com/phoenix#try-our-tutorials): Arize Phoenix is an open-source AI observability tool designed for experimentation, evaluation, and troubleshooting of AI and LLM applications, allowing users to visualize data, evaluate performance, and track issues effectively while integrating with various frameworks and instrumentation.
- [Add Integrations](https://docs.arize.com/phoenix#add-integrations): Arize Phoenix is an open-source observability tool aimed at enhancing experimentation, evaluation, and troubleshooting for AI and LLM applications, allowing engineers to visualize data, assess performance, and streamline their prompt engineering workflows through its comprehensive tracing, evaluation, and dataset management features.
- [Community](https://docs.arize.com/phoenix#community): Arize Phoenix is an open-source AI observability tool that facilitates experimentation, evaluation, and troubleshooting of AI and LLM applications by providing features for prompt engineering, tracing, evaluation, and managing datasets.
- [NextQuickstarts](https://docs.arize.com/phoenix/quickstart): The Quickstarts documentation page for Arize Phoenix provides an introductory guide with step-by-step instructions and helpful resources to help users start utilizing Phoenix for various tasks such as tracing, prompts, datasets, experiments, evaluation, and inferences.
- [Integrations: Tracing](https://docs.arize.com/phoenix/tracing/integrations-tracing): The Phoenix documentation page on Tracing details the integration of various frameworks and SDKs using OpenTelemetry auto-instrumentation to capture and trace requests across Python and JavaScript platforms.
- [](https://docs.arize.com/phoenix#features): Arize Phoenix is an open-source observability tool designed for the experimentation, evaluation, and troubleshooting of AI and LLM applications, providing features for prompt management, tracing, and evaluation to help AI engineers and data scientists visualize data, assess performance, and enhance their applications.
- [streamline your prompt engineering](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts): The "Overview: Prompts" documentation describes how to effectively manage and optimize prompts for interacting with large language models (LLMs) using Phoenix's various features, such as prompt management, a prompt playground, and SDKs for code integration.
- [Prompt Management](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts/prompt-management): The Prompt Management documentation page explains how to create, store, and modify prompts for interacting with large language models (LLMs), offering benefits such as reusability, versioning, and collaboration to enhance consistency and experimentation.
- [Prompt Playground](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts/prompt-playground): Phoenix's Prompt Playground facilitates efficient prompt iteration and testing with support for various AI providers, enabling users to rapidly evaluate and manage prompts while recording runs as traces and experiments.
- [Span Replay](https://docs.arize.com/phoenix#span-replay): Arize Phoenix is an open-source observability tool that facilitates the experimentation, evaluation, and troubleshooting of AI and LLM applications, providing features such as tracing, prompt engineering, and dataset management to enhance performance visualization and analysis.
- [Prompts in Code](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts/prompts-in-code): The "Prompts in Code" documentation page explains how to manage and manipulate prompts programmatically using Phoenix's Python and TypeScript SDKs, allowing for dynamic creation, updating, and formatting of prompt templates with support for various AI providers.
- [Tracing](https://docs.arize.com/phoenix/tracing/llm-traces): The Tracing Overview documentation for Phoenix details how to utilize OpenTelemetry to trace and analyze the execution of large language model applications, enabling insights into performance, token usage, runtime exceptions, and more for optimization and reliability.
- [LlamaIndex](https://docs.arize.com/phoenix/tracing/integrations-tracing/llamaindex): LlamaIndex is a data framework designed to enhance LLM applications through retrieval-augmented generation (RAG), offering tracing instrumentation via the LlamaIndexInstrumentor for monitoring and collecting operational data within the Phoenix environment.
- [LangChain](https://docs.arize.com/phoenix/tracing/integrations-tracing/langchain): The documentation page provides a comprehensive guide on integrating and using the Phoenix tracing system with LangChain applications, including setup instructions, customization options, and the process for observing and evaluating traces.
- [DSPy](https://docs.arize.com/phoenix/tracing/integrations-tracing/dspy): The documentation page provides a comprehensive guide on setting up and using the DSPy Instrumentor with Phoenix for observing and evaluating language model applications, detailing installation steps, configuration options, and code examples to facilitate the integration.
- [OpenAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/openai): The documentation page provides a comprehensive guide for integrating and using the Arize Phoenix platform with OpenAI, detailing installation, setup, and best practices for tracing OpenAI LLM and embedding calls in Python applications.
- [Bedrock](https://docs.arize.com/phoenix/tracing/integrations-tracing/bedrock): The documentation page provides instructions on setting up tracing for AWS Bedrock models using OpenInference and Phoenix, enabling observability and evaluation of LLM applications through telemetry data collection.
- [Mistral](https://docs.arize.com/phoenix/tracing/integrations-tracing/mistralai): This documentation page provides a comprehensive guide on how to instrument LLM calls using the MistralAI SDK with the Arize Phoenix platform for observability and evaluation through various setup options, including local instances and Docker.
- [Vertex](https://docs.arize.com/phoenix/tracing/integrations-tracing/vertexai): The documentation page provides instructions for setting up and using the VertexAI SDK with the Phoenix observability and evaluation platform, including installation, configuration, and integration steps.
- [Javascript](https://docs.arize.com/phoenix/tracing/how-to-tracing/setup-tracing/javascript): This documentation page provides a comprehensive guide on setting up tracing for Node.js applications using OpenTelemetry and Phoenix, including installation of necessary packages, initialization of the SDK, creation of spans, and best practices for exporting telemetry data.
- [evaluate your application](https://docs.arize.com/phoenix/evaluation/llm-evals): The Phoenix LLM Evals library provides a robust framework for evaluating large language models (LLMs) using pre-tested templates, optimizing for speed and accuracy while allowing seamless integration across various environments.
- [run LLM-based evaluations](https://docs.arize.com/phoenix/evaluation/how-to-evals/running-pre-tested-evals): The "Use Phoenix Evaluators" documentation provides an overview of how to utilize pre-tested evaluation templates for LLMs, highlighting supported models and their benchmarked performance metrics for various evaluation tasks such as hallucination detection, summarization, and code generation.
- [Direct integration of LLM-based and code-based evaluators](https://docs.arize.com/phoenix/tracing/how-to-tracing/feedback-and-annotations/evaluating-phoenix-traces): The "Evaluating Phoenix Traces" documentation page provides a comprehensive guide on how to evaluate trace datasets in Arize Phoenix, including steps for connecting to Phoenix, preparing trace datasets, generating evaluations, and uploading results to the Phoenix UI.
- [Human annotation capabilities](https://docs.arize.com/phoenix/tracing/features-tracing/how-to-annotate-traces): The documentation page explains how to effectively capture and utilize feedback in Phoenix through annotations from end users, evaluations from large language models (LLMs), and human annotations, allowing for improved tracking and evaluation of application performance.
- [Phoenix Datasets & Experiments](https://docs.arize.com/phoenix/datasets-and-experiments/overview-datasets): The Datasets and Experiments documentation provides an overview of how datasets facilitate evaluations in AI application development by offering a collection of examples for assessing changes, while experiments help clarify the impact of modifications on performance, thereby reducing guesswork in the development process.
- [Run Experiments](https://docs.arize.com/phoenix/datasets-and-experiments/how-to-experiments/run-experiments): The "Run Experiments" documentation page provides a step-by-step guide on how to set up and execute experiments in Phoenix, including loading datasets, defining tasks and evaluators, and running the experiment with OpenAI instrumentation.
- [Collect relevant traces into a Dataset](https://docs.arize.com/phoenix/datasets-and-experiments/how-to-datasets): The "How-to: Datasets" documentation page explains how to create and export datasets in Phoenix for building prompts, evaluations, and fine-tuning, using various methods such as CSV files, Pandas, spans, or synthetic data.
- [Run Datasets through Prompt Playground](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts/prompt-playground): Phoenix's Prompt Playground is an interactive tool designed for quickly iterating and testing prompts across various AI providers while systematically managing, evaluating, and recording prompt experiments and results.
- [](https://docs.arize.com/phoenix#quickstarts): Arize Phoenix is an open-source AI observability tool that facilitates experimentation, evaluation, and troubleshooting of AI and LLM applications by providing comprehensive tracing, prompt management, and evaluation capabilities.
- [](https://docs.arize.com/phoenix#next-steps): Arize Phoenix is an open-source AI observability tool that helps AI engineers and data scientists visualize data, evaluate performance, troubleshoot issues, and streamline prompt engineering workflows across various language models and frameworks.
- [](https://docs.arize.com/phoenix#try-our-tutorials): Arize Phoenix is an open-source observability tool for AI and LLM applications, providing features for prompt engineering, tracing, evaluation, and datasets management to help engineers visualize data, evaluate performance, and troubleshoot issues effectively.
- [Try our Tutorials](https://docs.arize.com/phoenix/notebooks): The documentation page provides examples and tutorials for using Phoenix, showcasing agent implementations, tracing capabilities, dataset creation, LLM evaluation, and detailed data analysis to enhance performance and troubleshooting in various applications.
- [](https://docs.arize.com/phoenix#add-integrations): Arize Phoenix is an open-source AI observability tool that facilitates experimentation, evaluation, and troubleshooting for AI and LLM applications, enabling users to visualize data, evaluate performance, and track issues efficiently.
- [Add Integrations](https://docs.arize.com/phoenix/tracing/integrations-tracing): The "Integrations: Tracing" documentation page outlines how Phoenix integrates with various frameworks and SDKs in Python and JavaScript for auto-instrumentation using OpenTelemetry, enabling efficient tracing of requests and connections with multiple AI platforms.
- [](https://docs.arize.com/phoenix#community): Arize Phoenix is an open-source AI observability tool designed for experimentation, evaluation, and troubleshooting of AI and LLM applications, allowing users to visualize data, evaluate performance, track issues, and utilize various integrations and features for prompt engineering, tracing, and dataset management.
- [Tracing](https://docs.arize.com/phoenix/tracing/llm-traces-1): The "Quickstart: Tracing" documentation page provides a comprehensive guide on how to collect application traces using Phoenix, detailing three options for integration—decorators, automatic instrumentation for libraries, and base OpenTelemetry instrumentation.
- [Prompt Playground](https://docs.arize.com/phoenix/prompt-engineering/quickstart-prompts): The Quickstart: Prompts documentation page provides guidance on creating, iterating, versioning, tagging, and utilizing prompts in Phoenix through the UI or Python/TypeScript SDKs, including features like the Prompt Playground for comparing variations.
- [Datasets and Experiments](https://docs.arize.com/phoenix/datasets-and-experiments/quickstart-datasets): The Quickstart: Datasets documentation for Phoenix provides a concise guide on setting up datasets, creating tasks, utilizing evaluators, and running experiments to evaluate and improve AI and LLM application performance.
- [Evaluation](https://docs.arize.com/phoenix/evaluation/evals): The "Quickstart: Evals" documentation provides a step-by-step guide on how to install Phoenix Evals, prepare datasets, evaluate data from LLM applications using various evaluators, and analyze the evaluation results.
- [Inferences](https://docs.arize.com/phoenix/inferences/phoenix-inferences): The Quickstart for Inferences in Phoenix provides a step-by-step guide to set up and visualize model performance through an interactive UMAP view, allowing users to analyze inferences for various model types while facilitating the identification of model drift and performance issues.