> ## Documentation Index
> Fetch the complete documentation index at: https://arize-ax.mintlify.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# AI Provider Integrations Overview

> Learn how to connect Arize to your AI provider to run prompts and LLM-as-a-judge evaluations

Arize integrates with LLMs from a range of providers to power the following:

* [Prompt playgrounds](/ax/improve/test-a-prompt)
* [Evaluations](/ax/evaluate/evaluators/llm-as-a-judge)
* [Alyx](/ax/alyx) (Alyx runs on Arize provided models, or on your AI provider)

<Info>
  Note: By adding integrations, your data may be sent to your provider for certain actions within Arize AX (e.g., prompt playground) and your account may be billed for usage.
</Info>

## Supported Providers

<CardGroup columns={2}>
  <Card title="Anthropic" href="/ax/security-and-settings/integrations-playground/anthropic" />

  <Card title="AWS Bedrock" href="/ax/security-and-settings/integrations-playground/aws-bedrock" />

  <Card title="Azure OpenAI Service" href="/ax/security-and-settings/integrations-playground/azure-openai" />

  <Card title="Gemini" href="/ax/security-and-settings/integrations-playground/gemini" />

  <Card title="NVIDIA" href="/ax/security-and-settings/integrations-playground/nvidia-nim" />

  <Card title="OpenAI" href="/ax/security-and-settings/integrations-playground/openai" />

  <Card title="VertexAI" href="/ax/security-and-settings/integrations-playground/vertexai" />

  <Card title="Custom Model Endpoints" href="/ax/security-and-settings/integrations-playground/custom-llm-models" />
</CardGroup>

## Set up your AI Provider Integration

You can set up your AI provider integration using our skills, code, or in Arize AX

### Set up an Integration Using Arize Skills

1. Install the [Arize Skills](/ax/agents/arize-skills) for your coding agent.
2. Ask your agent to create the relevant integration:

   <Prompt description="Create an OpenAI integration named 'my-openai' with my API key sk-proj...">
     Create an OpenAI integration named 'my-openai' with my API key sk-proj...
   </Prompt>

### Set up an Integration in Arize AX

To configure integrations in Arize AX, **Navigate to Settings -> [AI Providers](https://app.arize.com/account/ai-providers)**.

<Frame caption="The AI Provider integrations tab">
  ![The AI Provider integrations tab](https://storage.googleapis.com/arize-phoenix-assets/assets/images/arize-docs-images/ai-integration-providers.png)
</Frame>

From here you can add a new integration by selecting your provider. You can also view and edit existing integrations.

### Set up an Integration Using Code

<Tabs>
  <Tab title="CLI">
    1. Install the CLI:

       ```bash theme={null}
       pip install arize-ax-cli
       ```

    2. Set up your profile (required before running other commands):

       ```bash theme={null}
       ax profiles create
       ```

    3. List all AI integrations:

       ```bash theme={null}
       ax ai-integrations list
       ```

    4. Create an OpenAI integration

       ```bash theme={null}
       ax ai-integrations create \
           --name "My OpenAI Integration" \
           --provider openAI \
           --api-key $OPENAI_API_KEY
       ```

    5. Create an Anthropic integration

       ```bash theme={null}
       ax ai-integrations create \
           --name "My Anthropic Integration" \
           --provider anthropic \
           --api-key $ANTHROPIC_API_KEY
       ```

    6. Create an Azure OpenAI integration

       ```bash theme={null}
       ax ai-integrations create \
           --name "My Azure OpenAI Integration" \
           --provider azureOpenAI \
           --api-key $AZURE_OPENAI_API_KEY \
           --base-url "https://my-resource.openai.azure.com/"
       ```

    7. Create an AWS Bedrock integration

       ```bash theme={null}
       ax ai-integrations create \
           --name "My Bedrock Integration" \
           --provider awsBedrock \
           --role-arn "arn:aws:iam::123456789012:role/ArizeBedrockRole"
       ```

    8. Create a Vertex AI integration

       ```bash theme={null}
       ax ai-integrations create \
           --name "My Vertex AI Integration" \
           --provider vertexAI \
           --project-id "my-gcp-project" \
           --location "us-central1"
       ```

    9. Create a Gemini integration

       ```bash theme={null}
       ax ai-integrations create \
           --name "My Gemini Integration" \
           --provider gemini \
           --api-key $GEMINI_API_KEY
       ```

    10. Create an NVIDIA NIM integration

        ```bash theme={null}
        ax ai-integrations create \
            --name "My NVIDIA NIM Integration" \
            --provider nvidiaNim \
            --api-key $NVIDIA_API_KEY \
            --base-url "https://integrate.api.nvidia.com/v1"
        ```

    11. Create a Custom (OpenAI-compatible) integration

        ```bash theme={null}
        ax ai-integrations create \
            --name "My Custom Integration" \
            --provider custom \
            --base-url "https://my-llm-proxy.example.com/v1" \
            --api-key $CUSTOM_LLM_API_KEY
        ```
  </Tab>

  <Tab title="TypeScript SDK">
    1. Install dependencies:

       ```bash theme={null}
       npm install @arizeai/ax-client
       ```

    2. Set up the Arize client:

       ```typescript theme={null}
       import { createClient } from "@arizeai/ax-client";

       const apiKey = process.env.ARIZE_API_KEY;

       const client = createClient({
           baseUrl: "https://api.arize.com/v2",
           apiKey: apiKey,
       });
       ```

    3. List existing integrations:

       ```typescript theme={null}
       // List all AI integrations
       const integrations = await client.aiIntegrations.list();
       ```

    4. Create an integration:

       ```typescript theme={null}
       import { createAiIntegration } from "@arizeai/ax-client";

       const integration = await createAiIntegration({
           name: "My OpenAI Integration",
           provider: "openAI",
           apiKey: "sk-...",
           modelNames: ["gpt-4o", "gpt-4o-mini"],
           enableDefaultModels: true,
       });
       ```
  </Tab>

  <Tab title="Python SDK">
    1. Install the Arize Python SDK:

       ```bash theme={null}
       pip install 'arize'
       ```

    2. Set up the Arize client:

       ```python theme={null}
       import os
       from arize import ArizeClient

       api_key = os.environ["ARIZE_API_KEY"]

       client = ArizeClient(api_key=api_key)
       ```

    3. List all AI integrations
       ```python theme={null}
       integrations = client.ai_integrations.list()
       ```

    4. Create AI integrations

       ```python theme={null}
       # Create an OpenAI integration
       integration = client.ai_integrations.create(
           name="My OpenAI Integration",
           provider="openAI",
           api_key=os.environ["OPENAI_API_KEY"],
       )

       # Create an Anthropic integration
       integration = client.ai_integrations.create(
           name="My Anthropic Integration",
           provider="anthropic",
           api_key=os.environ["ANTHROPIC_API_KEY"],
       )

       # Create an AWS Bedrock integration
       integration = client.ai_integrations.create(
           name="My Bedrock Integration",
           provider="awsBedrock",
           provider_metadata={"role_arn": "arn:aws:iam::123456789012:role/ArizeBedrockRole"},
       )
       ```
  </Tab>

  <Tab title="REST">
    1. List existing integrations:

       ```bash theme={null}
       curl -X GET "https://api.arize.com/v2/ai-integrations" \
           -H "Authorization: Bearer $ARIZE_API_KEY" \
           -H "Content-Type: application/json"
       ```

    2. Create an integration:

       ```bash theme={null}
       curl -X POST "https://api.arize.com/v2/ai-integrations" \
           -H "Authorization: Bearer $ARIZE_API_KEY" \
           -H "Content-Type: application/json" \
           -d '{
               "name": "My OpenAI Integration",
               "provider": "openAI",
               "api_key": "'"$OPENAI_API_KEY"'"
           }'
       ```
  </Tab>
</Tabs>