1 of 20

SDK and API Reference

Overview

Phoenix provides SDK and API access to log, query, and evaluate LLM traces across Python, TypeScript, and REST interfaces. Our documentation offers flexible integration points to fit your workflow.

Python

Overview

Features

Installation

Install via pip.

pip install -Uq arize-phoenix-client

Usage

from phoenix.client import Client

client = Client(base_url="your-server-url")  # base_url defaults to http://localhost:6006

Authentication (if applicable)

Phoenix API key can be an environment variable...

import os

os.environ["PHOENIX_API_KEY"] = "your-api-key"

...or passed directly to the client.

from phoenix.client import Client

client = Client(api_key="your-api-key")

Custom Headers

By default, the Phoenix client will use the bearer authentication scheme in the HTTP headers, but if you need different headers, e.g. for Phoenix Cloud, they can also be customized via an environment variable...

import os

os.environ["PHOENIX_CLIENT_HEADERS"] = "api-key=your-api-key,"  # use `api-key` for Phoenix Cloud

...or passed directly to the client.

from phoenix.client import Client

client = Client(headers={"api-key": "your-api-key"})  # use `api-key` for Phoenix Cloud

Prompt Management

With the Phoenix client, you can push and pull prompts to and from your Phoenix server.

from phoenix.client import Client
from phoenix.client.types import PromptVersion

# Change base_url to your Phoenix server URL
base_url = "http://localhost:6006"
client = Client(base_url=base_url)

# prompt identifier consists of alphanumeric characters, hyphens or underscores
prompt_identifier = "haiku-writer"

content = "Write a haiku about {{topic}}"
prompt = client.prompts.create(
    name=prompt_identifier,
    version=PromptVersion(
        [{"role": "user", "content": content}],
        model_name="gpt-4o-mini",
    ),
)

The client can retrieve a prompt by its name.

prompt = client.prompts.get(prompt_identifier=prompt_identifier)

The prompt can be used to generate completions.

from openai import OpenAI

variables = {"topic": "programming"}
resp = OpenAI().chat.completions.create(**prompt.format(variables=variables))
print(resp.choices[0].message.content)

Project Management

The Phoenix client provides synchronous and asynchronous interfaces for interacting with Phoenix Projects.

Key Features

Get a project by ID or name
List all projects
Create a new project with optional description
Update a project’s description (note: names cannot be changed)
Delete a project by ID or name

Usage Examples

from phoenix.client import Client
client = Client(base_url="your-server-url")

# List all projects
projects = client.projects.list()

# Get a project by ID or name
project = client.projects.get(project_id="UHJvamVjdDoy")
project = client.projects.get(project_name="My Project")

# Create a project
new_project = client.projects.create(
    name="New Project",
    description="This is a new project"
)

# Update a project
updated_project = client.projects.update(
    project_id="UHJvamVjdDoy",
    description="Updated description"
)

# Delete a project
client.projects.delete(project_name="My Project")

Python pacakges

arize-phoenix-evals

Tooling to evaluate LLM applications including RAG relevance, answer relevance, and more.

Phoenix's approach to LLM evals is notable for the following reasons:

Includes pre-tested templates and convenience functions for a set of common Eval “tasks”
Data science rigor applied to the testing of model and template combinations
Designed to run as fast as possible on batches of data
Includes benchmark datasets and tests for each eval function

Installation

Install the arize-phoenix sub-package via pip

pip install arize-phoenix-evals

Note you will also have to install the LLM vendor SDK you would like to use with LLM Evals. For example, to use OpenAI's GPT-4, you will need to install the OpenAI Python SDK:

pip install 'openai>=1.0.0'

Usage

Here is an example of running the RAG relevance eval on a dataset of Wikipedia questions and answers:

import os
from phoenix.evals import (
    RAG_RELEVANCY_PROMPT_TEMPLATE,
    RAG_RELEVANCY_PROMPT_RAILS_MAP,
    OpenAIModel,
    download_benchmark_dataset,
    llm_classify,
)
from sklearn.metrics import precision_recall_fscore_support, confusion_matrix, ConfusionMatrixDisplay

os.environ["OPENAI_API_KEY"] = "<your-openai-key>"

# Download the benchmark golden dataset
df = download_benchmark_dataset(
    task="binary-relevance-classification", dataset_name="wiki_qa-train"
)
# Sample and re-name the columns to match the template
df = df.sample(100)
df = df.rename(
    columns={
        "query_text": "input",
        "document_text": "reference",
    },
)
model = OpenAIModel(
    model="gpt-4",
    temperature=0.0,
)


rails =list(RAG_RELEVANCY_PROMPT_RAILS_MAP.values())
df[["eval_relevance"]] = llm_classify(df, model, RAG_RELEVANCY_PROMPT_TEMPLATE, rails)
#Golden dataset has True/False map to -> "irrelevant" / "relevant"
#we can then scikit compare to output of template - same format
y_true = df["relevant"].map({True: "relevant", False: "irrelevant"})
y_pred = df["eval_relevance"]

# Compute Per-Class Precision, Recall, F1 Score, Support
precision, recall, f1, support = precision_recall_fscore_support(y_true, y_pred)

arize-phoenix-client

Phoenix Client is a lightweight package for interacting with the Phoenix server.

The Python client is currently a work in progress. Please refer to the status below for the latest updates.

Features

API - Interact with Phoenix's OpenAPI REST interface
Prompt Management - Pull / push / and invoke prompts stored in Phoenix

Installation

Install via pip.

pip install -Uq arize-phoenix-client

Usage

from phoenix.client import Client

client = Client(base_url="your-server-url")  # base_url defaults to http://localhost:6006

Authentication (if applicable)

Phoenix API key can be an environment variable...

import os

os.environ["PHOENIX_API_KEY"] = "your-api-key"

...or passed directly to the client.

from phoenix.client import Client

client = Client(api_key="your-api-key")

Custom Headers

import os

os.environ["PHOENIX_CLIENT_HEADERS"] = "api-key=your-api-key,"  # use `api-key` for Phoenix Cloud

...or passed directly to the client.

from phoenix.client import Client

client = Client(headers={"api-key": "your-api-key"})  # use `api-key` for Phoenix Cloud

Prompt Management

With the Phoenix client, you can push and pull prompts to and from your Phoenix server.

from phoenix.client import Client
from phoenix.client.types import PromptVersion

# Change base_url to your Phoenix server URL
base_url = "http://localhost:6006"
client = Client(base_url=base_url)

# prompt identifier consists of alphanumeric characters, hyphens or underscores
prompt_identifier = "haiku-writer"

content = "Write a haiku about {{topic}}"
prompt = client.prompts.create(
    name=prompt_identifier,
    version=PromptVersion(
        [{"role": "user", "content": content}],
        model_name="gpt-4o-mini",
    ),
)

The client can retrieve a prompt by its name.

prompt = client.prompts.get(prompt_identifier=prompt_identifier)

The prompt can be used to generate completions.

from openai import OpenAI

variables = {"topic": "programming"}
resp = OpenAI().chat.completions.create(**prompt.format(variables=variables))
print(resp.choices[0].message.content)

arize-phoenix-otel

Provides a lightweight wrapper around OpenTelemetry primitives with Phoenix-aware defaults. Phoenix Otel also gives you acces to tracing decorators for common GenAI patterns.

These defaults are aware of environment variables you may have set to configure Phoenix:

PHOENIX_COLLECTOR_ENDPOINT
PHOENIX_PROJECT_NAME
PHOENIX_CLIENT_HEADERS
PHOENIX_API_KEY
PHOENIX_GRPC_PORT

Installation

Install via pip.

Examples

The phoenix.otel module provides a high-level register function to configure OpenTelemetry tracing by setting a global TracerProvider. The register function can also configure headers and whether or not to process spans one by one or by batch.

Quickstart

This is all you need to get started using OTel with Phoenix! register defaults to sending spans to an endpoint at http://localhost using gRPC.

Phoenix Authentication

If the PHOENIX_API_KEY environment variable is set, register will automatically add anauthorization header to each span payload.

Configuring the collector endpoint

There are two ways to configure the collector endpoint:

Using environment variables
Using the endpoint keyword argument

Using environment variables

If you're setting the PHOENIX_COLLECTOR_ENDPOINT environment variable, register will automatically try to send spans to your Phoenix server using gRPC.

Specifying the endpoint directly

When passing in the endpoint argument, you must specify the fully qualified endpoint. For example, in order to export spans via HTTP to localhost, use Pheonix's HTTP collector endpoint:http://localhost:6006/v1/traces. The default gRPC endpoint is different: http://localhost:4317. If the PHOENIX_GRPC_PORT environment variable is set, it will override the default gRPC port.

Additionally, the protocol argument can be used to enforce the OTLP transport protocol regardless of the endpoint specified. This might be useful in cases such as when the GRPC endpoint is bound to a different port than the default (4317). The valid protocols are: "http/protobuf", and "grpc".

Additional configuration

register can be configured with different keyword arguments:

project_name: The Phoenix project name (or PHOENIX_PROJECT_NAME env. var)
headers: Headers to send along with each span payload (or PHOENIX_CLIENT_HEADERS env. var)
batch: Whether or not to process spans in batch

A drop-in replacement for OTel primitives

For more granular tracing configuration, these wrappers can be used as drop-in replacements for OTel primitives:

Wrappers have Phoenix-aware defaults to greatly simplify the OTel configuration process. A specialendpoint keyword argument can be passed to either a TracerProvider, SimpleSpanProcessor orBatchSpanProcessor in order to automatically infer which SpanExporter to use to simplify setup.

Using environment variables

Specifying the endpoint directly

Further examples

Users can gradually add OTel components as desired:

Configuring resources

Using a BatchSpanProcessor

Specifying a custom GRPC endpoint

TypeScript

Overview

This package provides a TypeSript client for the Arize Phoenix API.

Installation

Configuration

The client will automatically read environment variables from your environment, if available.

The following environment variables are used:

PHOENIX_HOST - The base URL of the Phoenix API.
PHOENIX_API_KEY - The API key to use for authentication.
PHOENIX_CLIENT_HEADERS - Custom headers to add to all requests. A JSON stringified object.

Alternatively, you can pass configuration options to the client directly, and they will be prioritized over environment variables and default values.

Prompts

@arizeai/phoenix-client provides a prompts export that exposes utilities for working with prompts for LLMs.

Creating a Prompt and push it to Phoenix

The createPrompt function can be used to create a prompt in Phoenix for version control and reuse.

Prompts that are pushed to Phoenix are versioned and can be tagged.

Pulling a Prompt from Phoenix

The getPrompt function can be used to pull a prompt from Phoenix based on some Prompt Identifier and returns it in the Phoenix SDK Prompt type.

Using a Phoenix Prompt with an LLM Provider SDK

The toSDK helper function can be used to convert a Phoenix Prompt to the format expected by an LLM provider SDK. You can then use the LLM provider SDK as normal, with your prompt.

If your Prompt is saved in Phoenix as openai, you can use the toSDK function to convert the prompt to the format expected by OpenAI, or even Anthropic and Vercel AI SDK. We will do a best effort conversion to your LLM provider SDK of choice.

The following LLM provider SDKs are supported:

REST Endpoints

Endpoints are accessible via strongly-typed string literals and TypeScript auto-completion inside of the client object.

Examples

To run examples, install dependencies using pnpm and run:

Compatibility

Because of this, this package only works with the arize-phonix server 8.0.0 and above.

Compatibility Table:

TypeScript Packages

MCP Server

MCP server implementation for Arize Phoenix providing unified interface to Phoenix's capabilities.

Phoenix MCP Server is an implementation of the Model Context Protocol for the Arize Phoenix platform. It provides a unified interface to Phoenix's capabilites.

You can use Phoenix MCP Server for:

Prompts Management: Create, list, update, and iterate on prompts
Datasets: Explore datasets, and syntesize new examples
Experiments: Pull experiment results and visualize them with the help of an LLM

Installation

This MCP server can be used using npx and can be directly integrated with clients like Claude Desktop, Cursor, and more.

Development

Install

This package is managed via a pnpm workspace.

This only needs to be repeated if dependencies change or there is a change to the phoenix-client.

Building

To build the project:

Development Mode

To run in development mode:

Debugging

You can build and run the MCP inspector using the following:

Environment Variables

When developing, the server requires the following environment variables:

PHOENIX_API_KEY: Your Phoenix API key
PHOENIX_BASE_URL: The base URL for Phoenix

Make sure to set these in a .env file. See .env.example.

License

Apache 2.0

Rest API

Overview

The Phoenix REST API allows you to access and interact with observability data programmatically. You can use it to retrieve project information, query traces and spans, access prompts, and automate analysis workflows directly from your environment.

Example Request

Get dataset by ID

Example Response

Datasets

REST API methods for interacting with Phoenix datasets

Experiments

REST API methods for interacting with Phoenix experiments

Spans

REST API methods for interacting with Phoenix spans

Traces

REST API methods for interacting with Phoenix traces

Prompts

REST API methods for interacting with Phoenix prompts

Projects

REST API methods for interacting with Phoenix projects

Users

Overview

Features

- Interact with Phoenix's OpenAPI REST interface
- - Methods for loading, inspecting, and interacting with tracing and evaluation sessions
- - Upload and download data to and from Phoenix
- - Define and run evaluations across models, traces, or datasets
- - Track, evaluate, and compare multiple runs under different conditions
- - Integrate tracing and metrics using OpenTelemetry for automatic or manual instrumentation
- - Transform spans and evaluations into datasets, define structures for features and predictions, and manage embedding columns
- Pull, push, and invoke prompts stored in Phoenix
- Create, read, update, and delete projects in Phoenix

Installation

Install via pip.

pip install -Uq arize-phoenix-client

Usage

from phoenix.client import Client

client = Client(base_url="your-server-url")  # base_url defaults to http://localhost:6006

Authentication (if applicable)

Phoenix API key can be an environment variable...

import os

os.environ["PHOENIX_API_KEY"] = "your-api-key"

...or passed directly to the client.

from phoenix.client import Client

client = Client(api_key="your-api-key")

Custom Headers

import os

os.environ["PHOENIX_CLIENT_HEADERS"] = "api-key=your-api-key,"  # use `api-key` for Phoenix Cloud

...or passed directly to the client.

from phoenix.client import Client

client = Client(headers={"api-key": "your-api-key"})  # use `api-key` for Phoenix Cloud

Prompt Management

With the Phoenix client, you can push and pull prompts to and from your Phoenix server.

from phoenix.client import Client
from phoenix.client.types import PromptVersion

# Change base_url to your Phoenix server URL
base_url = "http://localhost:6006"
client = Client(base_url=base_url)

# prompt identifier consists of alphanumeric characters, hyphens or underscores
prompt_identifier = "haiku-writer"

content = "Write a haiku about {{topic}}"
prompt = client.prompts.create(
    name=prompt_identifier,
    version=PromptVersion(
        [{"role": "user", "content": content}],
        model_name="gpt-4o-mini",
    ),
)

The client can retrieve a prompt by its name.

prompt = client.prompts.get(prompt_identifier=prompt_identifier)

The prompt can be used to generate completions.

from openai import OpenAI

variables = {"topic": "programming"}
resp = OpenAI().chat.completions.create(**prompt.format(variables=variables))
print(resp.choices[0].message.content)

To learn more about prompt engineering using Phenix, see the .

Project Management

The Phoenix client provides synchronous and asynchronous interfaces for interacting with Phoenix Projects.

Key Features

Get a project by ID or name
List all projects
Create a new project with optional description
Update a project’s description (note: names cannot be changed)
Delete a project by ID or name

Usage Examples

from phoenix.client import Client
client = Client(base_url="your-server-url")

# List all projects
projects = client.projects.list()

# Get a project by ID or name
project = client.projects.get(project_id="UHJvamVjdDoy")
project = client.projects.get(project_name="My Project")

# Create a project
new_project = client.projects.create(
    name="New Project",
    description="This is a new project"
)

# Update a project
updated_project = client.projects.update(
    project_id="UHJvamVjdDoy",
    description="Updated description"
)

# Delete a project
client.projects.delete(project_name="My Project")

arize-phoenix-otel

Provides a lightweight wrapper around OpenTelemetry primitives with Phoenix-aware defaults. Phoenix Otel also gives you acces to tracing decorators for common GenAI patterns.

These defaults are aware of environment variables you may have set to configure Phoenix:

PHOENIX_COLLECTOR_ENDPOINT
PHOENIX_PROJECT_NAME
PHOENIX_CLIENT_HEADERS
PHOENIX_API_KEY
PHOENIX_GRPC_PORT

phoenix/packages/phoenix-otel/README.md at main · Arize-ai/phoenixGitHub

Installation

Install via pip.

pip install -Uq arize-phoenix-otel

Examples

Quickstart

from phoenix.otel import register
tracer_provider = register()

This is all you need to get started using OTel with Phoenix! register defaults to sending spans to an endpoint at http://localhost using gRPC.

Phoenix Authentication

If the PHOENIX_API_KEY environment variable is set, register will automatically add anauthorization header to each span payload.

Configuring the collector endpoint

There are two ways to configure the collector endpoint:

Using environment variables
Using the endpoint keyword argument

Using environment variables

If you're setting the PHOENIX_COLLECTOR_ENDPOINT environment variable, register will automatically try to send spans to your Phoenix server using gRPC.

# export PHOENIX_COLLECTOR_ENDPOINT=https://your-phoenix.com:6006

from phoenix.otel import register
tracer_provider = register()

Specifying the endpoint directly

from phoenix.otel import register
tracer_provider = register(endpoint="http://localhost:6006/v1/traces")

from phoenix.otel import register
tracer_provider = register(endpoint="http://localhost:9999", protocol="grpc")

Additional configuration

register can be configured with different keyword arguments:

project_name: The Phoenix project name (or PHOENIX_PROJECT_NAME env. var)
headers: Headers to send along with each span payload (or PHOENIX_CLIENT_HEADERS env. var)
batch: Whether or not to process spans in batch

from phoenix.otel import register
tracer_provider = register(
    project_name="otel-test", headers={"Authorization": "Bearer TOKEN"}, batch=True
)

A drop-in replacement for OTel primitives

For more granular tracing configuration, these wrappers can be used as drop-in replacements for OTel primitives:

from opentelemetry import trace as trace_api
from phoenix.otel import HTTPSpanExporter, TracerProvider, SimpleSpanProcessor

tracer_provider = TracerProvider()
span_exporter = HTTPSpanExporter(endpoint="http://localhost:6006/v1/traces")
span_processor = SimpleSpanProcessor(span_exporter=span_exporter)
tracer_provider.add_span_processor(span_processor)
trace_api.set_tracer_provider(tracer_provider)

Using environment variables

# export PHOENIX_COLLECTOR_ENDPOINT=http://localhost:6006

from opentelemetry import trace as trace_api
from phoenix.otel import TracerProvider

tracer_provider = TracerProvider()
trace_api.set_tracer_provider(tracer_provider)

Specifying the endpoint directly

from opentelemetry import trace as trace_api
from phoenix.otel import TracerProvider

tracer_provider = TracerProvider(endpoint="http://localhost:4317")
trace_api.set_tracer_provider(tracer_provider)

Further examples

Users can gradually add OTel components as desired:

Configuring resources

# export PHOENIX_COLLECTOR_ENDPOINT=http://localhost:6006

from opentelemetry import trace as trace_api
from phoenix.otel import Resource, PROJECT_NAME, TracerProvider

tracer_provider = TracerProvider(resource=Resource({PROJECT_NAME: "my-project"}))
trace_api.set_tracer_provider(tracer_provider)

Using a BatchSpanProcessor

# export PHOENIX_COLLECTOR_ENDPOINT=http://localhost:6006

from opentelemetry import trace as trace_api
from phoenix.otel import TracerProvider, BatchSpanProcessor

tracer_provider = TracerProvider()
batch_processor = BatchSpanProcessor()
tracer_provider.add_span_processor(batch_processor)

Specifying a custom GRPC endpoint

from opentelemetry import trace as trace_api
from phoenix.otel import TracerProvider, BatchSpanProcessor, GRPCSpanExporter

tracer_provider = TracerProvider()
batch_processor = BatchSpanProcessor(
    span_exporter=GRPCSpanExporter(endpoint="http://custom-endpoint.com:6789")
)
tracer_provider.add_span_processor(batch_processor)

Overview

This package provides a TypeSript client for the Arize Phoenix API.

Installation

# or yarn, pnpm, bun, etc...
npm install @arizeai/phoenix-client

Configuration

The client will automatically read environment variables from your environment, if available.

The following environment variables are used:

PHOENIX_HOST - The base URL of the Phoenix API.
PHOENIX_API_KEY - The API key to use for authentication.
PHOENIX_CLIENT_HEADERS - Custom headers to add to all requests. A JSON stringified object.

PHOENIX_HOST='http://localhost:12345' PHOENIX_API_KEY='xxxxxx' pnpx tsx examples/list_datasets.ts
# emits the following request:
# GET http://localhost:12345/v1/datasets
# headers: {
#   "Authorization": "Bearer xxxxxx",
# }

Alternatively, you can pass configuration options to the client directly, and they will be prioritized over environment variables and default values.

const phoenix = createClient({
  options: {
    baseUrl: "http://localhost:6006",
    headers: {
      Authorization: "Bearer xxxxxx",
    },
  },
});

Prompts

@arizeai/phoenix-client provides a prompts export that exposes utilities for working with prompts for LLMs.

Creating a Prompt and push it to Phoenix

The createPrompt function can be used to create a prompt in Phoenix for version control and reuse.

import { createPrompt, promptVersion } from "@arizeai/phoenix-client/prompts";

const version = createPrompt({
  name: "my-prompt",
  description: "test-description",
  version: promptVersion({
    description: "version description here",
    modelProvider: "OPENAI",
    modelName: "gpt-3.5-turbo",
    template: [
      {
        role: "user",
        content: "{{ question }}",
      },
    ],
    invocationParameters: {
      temperature: 0.8,
    },
  }),
});

Prompts that are pushed to Phoenix are versioned and can be tagged.

Pulling a Prompt from Phoenix

The getPrompt function can be used to pull a prompt from Phoenix based on some Prompt Identifier and returns it in the Phoenix SDK Prompt type.

import { getPrompt } from "@arizeai/phoenix-client/prompts";

const prompt = await getPrompt({ name: "my-prompt" });
// ^ you now have a strongly-typed prompt object, in the Phoenix SDK Prompt type

const promptByTag = await getPrompt({ tag: "production", name: "my-prompt" });
// ^ you can optionally specify a tag to filter by

const promptByVersionId = await getPrompt({
  versionId: "1234567890",
});
// ^ you can optionally specify a prompt version Id to filter by

Using a Phoenix Prompt with an LLM Provider SDK

The toSDK helper function can be used to convert a Phoenix Prompt to the format expected by an LLM provider SDK. You can then use the LLM provider SDK as normal, with your prompt.

The following LLM provider SDKs are supported:

Vercel AI SDK: ai
OpenAI: openai
Anthropic: anthropic

import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";
import { getPrompt, toSDK } from "@arizeai/phoenix-client/prompts";

const prompt = await getPrompt({ name: "my-prompt" });
const promptAsAI = toSDK({
  sdk: "ai",
  // ^ the SDK you want to convert the prompt to, supported SDKs are listed above
  variables: {
    "my-variable": "my-value",
  },
  // ^ you can format the prompt with variables, if the prompt has any variables in its template
  //   the format (Mustache, F-string, etc.) is specified in the Prompt itself
  prompt,
});
// ^ promptAsAI is now in the format expected by the Vercel AI SDK generateText function

const response = await generateText({
  model: openai(prompt.model_name),
  // ^ the model adapter provided by the Vercel AI SDK can be swapped out for any other model
  //   adapter supported by the Vercel AI SDK. Take care to use the correct model name for the
  //   LLM provider you are using.
  ...promptAsAI,
});

REST Endpoints

The client provides a REST API for all endpoints defined in the .

Endpoints are accessible via strongly-typed string literals and TypeScript auto-completion inside of the client object.

import { createClient } from "@arizeai/phoenix-client";

const phoenix = createClient();

// Get all datasets
const datasets = await phoenix.GET("/v1/datasets");

// Get specific prompt
const prompt = await phoenix.GET("/v1/prompts/{prompt_identifier}/latest", {
  params: {
    path: {
      prompt_identifier: "my-prompt",
    },
  },
});

A comprehensive overview of the available endpoints and their parameters is available in the OpenAPI viewer within Phoenix, or in the .

Examples

To run examples, install dependencies using pnpm and run:

pnpm install
pnpx tsx examples/list_datasets.ts
# change the file name to run other examples

Compatibility

This package utilizes to generate the types from the Phoenix OpenAPI spec.

Because of this, this package only works with the arize-phonix server 8.0.0 and above.

Compatibility Table:

Phoenix Client Version

Phoenix Server Version

POST /v1/prompts HTTP/1.1 Host: Content-Type: application/json Accept: */* Content-Length: 847 { "prompt": { "name": "text", "description": "text", "source_prompt_id": "text" }, "version": { "description": "text", "model_provider": "OPENAI", "model_name": "text", "template": { "type": "text", "messages": [ { "role": "user", "content": "text" } ] }, "template_type": "STR", "template_format": "MUSTACHE", "invocation_parameters": { "type": "text", "openai": { "temperature": 1, "max_tokens": 1, "max_completion_tokens": 1, "frequency_penalty": 1, "presence_penalty": 1, "top_p": 1, "seed": 1, "reasoning_effort": "low" } }, "tools": { "type": "text", "tools": [ { "type": "text", "function": { "name": "text", "description": "text", "parameters": { "ANY_ADDITIONAL_PROPERTY": "anything" }, "strict": true } } ], "tool_choice": { "type": "text" }, "disable_parallel_tool_calls": true }, "response_format": { "type": "text", "json_schema": { "name": "text", "description": "text", "schema": { "ANY_ADDITIONAL_PROPERTY": "anything" }, "strict": true } } } }

{ "data": { "description": "text", "model_provider": "OPENAI", "model_name": "text", "template": { "type": "text", "messages": [ { "role": "user", "content": "text" } ] }, "template_type": "STR", "template_format": "MUSTACHE", "invocation_parameters": { "type": "text", "openai": { "temperature": 1, "max_tokens": 1, "max_completion_tokens": 1, "frequency_penalty": 1, "presence_penalty": 1, "top_p": 1, "seed": 1, "reasoning_effort": "low" } }, "tools": { "type": "text", "tools": [ { "type": "text", "function": { "name": "text", "description": "text", "parameters": { "ANY_ADDITIONAL_PROPERTY": "anything" }, "strict": true } } ], "tool_choice": { "type": "text" }, "disable_parallel_tool_calls": true }, "response_format": { "type": "text", "json_schema": { "name": "text", "description": "text", "schema": { "ANY_ADDITIONAL_PROPERTY": "anything" }, "strict": true } }, "id": "text" } }

{ "data": [ { "description": "text", "model_provider": "OPENAI", "model_name": "text", "template": { "type": "text", "messages": [ { "role": "user", "content": "text" } ] }, "template_type": "STR", "template_format": "MUSTACHE", "invocation_parameters": { "type": "text", "openai": { "temperature": 1, "max_tokens": 1, "max_completion_tokens": 1, "frequency_penalty": 1, "presence_penalty": 1, "top_p": 1, "seed": 1, "reasoning_effort": "low" } }, "tools": { "type": "text", "tools": [ { "type": "text", "function": { "name": "text", "description": "text", "parameters": { "ANY_ADDITIONAL_PROPERTY": "anything" }, "strict": true } } ], "tool_choice": { "type": "text" }, "disable_parallel_tool_calls": true }, "response_format": { "type": "text", "json_schema": { "name": "text", "description": "text", "schema": { "ANY_ADDITIONAL_PROPERTY": "anything" }, "strict": true } }, "id": "text" } ], "next_cursor": "text" }