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

# Integrations

> Manage LLM and agent integrations programmatically. Create, list, retrieve, update, and delete provider and customer-hosted agent integrations.

<Note>
  The `integrations` client methods are currently in **ALPHA**. The API may change without notice. A one-time warning is emitted on first use.
</Note>

Manage Arize integrations. Integrations are polymorphic: **LLM** integrations configure a model provider (OpenAI, Anthropic, Gemini, AWS Bedrock, Custom, Vertex AI, or NVIDIA NIM), while **AGENT** integrations connect a customer-hosted agent exposed at an HTTPS endpoint.

## Key Capabilities

* List integrations of every type, or filter to a single type
* Retrieve an integration by name or ID
* Create LLM integrations for any supported provider
* Create agent integrations for customer-hosted agents
* Update LLM or agent integrations without replacing the entire resource
* Delete integrations

## Integration Types

Integration names are unique per `(account, type)`. When resolving an integration by name, pass `integration_type` to disambiguate.

| `IntegrationType` value | Description                       |
| ----------------------- | --------------------------------- |
| `LLM`                   | Model-provider integration        |
| `AGENT`                 | Customer-hosted agent integration |

## List Integrations

List all integrations you have access to. When `integration_type` is omitted, integrations of every type are returned in one merged list (most recently created first).

```python theme={null}
from arize.integrations.types import IntegrationType

resp = client.integrations.list(
    integration_type=IntegrationType.LLM,  # optional; omit for all types
    name="openai",                          # optional substring filter
    space="your-space-name-or-id",          # optional
    limit=50,
)

for integration in resp.integrations:
    print(integration.id, integration.name)
```

For details on pagination, field introspection, and data conversion (to dict/JSON/DataFrame), see [Response Objects](/docs/api-clients/python/version-8/overview#response-objects).

## Create an LLM Integration

Create an LLM integration by passing the provider-specific config. All 7 providers are supported — construct the matching `Create*Config` for the provider you want.

### OpenAI

```python theme={null}
from arize.integrations.types import CreateOpenAiConfig

integration = client.integrations.create_llm(
    name="my-openai",
    config=CreateOpenAiConfig(
        provider="OPEN_AI",
        api_key="sk-...",
    ),
)

print(integration.id, integration.name)
```

### Anthropic

```python theme={null}
from arize.integrations.types import CreateAnthropicConfig

integration = client.integrations.create_llm(
    name="my-anthropic",
    config=CreateAnthropicConfig(
        provider="ANTHROPIC",
        api_key="sk-ant-...",
    ),
)
```

### AWS Bedrock

AWS Bedrock nests an auth config (`CreateAwsBedrockDefaultAuth`, `CreateAwsBedrockBearerTokenAuth`, or `CreateAwsBedrockProxyWithHeadersAuth`).

```python theme={null}
from arize.integrations.types import (
    CreateAwsBedrockConfig,
    CreateAwsBedrockDefaultAuth,
)

integration = client.integrations.create_llm(
    name="my-bedrock",
    config=CreateAwsBedrockConfig(
        provider="AWS_BEDROCK",
        auth=CreateAwsBedrockDefaultAuth(
            auth_type="DEFAULT",
            role_arn="arn:aws:iam::123456789012:role/my-role",
        ),
        model_names=["anthropic.claude-3-5-sonnet-20241022-v2:0"],
    ),
)
```

The remaining providers use `CreateGeminiConfig`, `CreateCustomConfig`, `CreateVertexAiConfig`, and `CreateNvidiaNimConfig`. A pre-wrapped `CreateLlmConfig` union is also accepted.

## Create an Agent Integration

Agent integrations connect a customer-hosted agent exposed at an HTTPS endpoint. Provide a JSON Schema (Draft-07) describing the endpoint's request body.

```python theme={null}
integration = client.integrations.create_agent(
    name="my-agent",
    endpoint="https://agents.example.com/replay",
    input_schema={
        "type": "object",
        "properties": {"prompt": {"type": "string"}},
        "required": ["prompt"],
    },
    description="Customer support agent",  # optional
    headers={"X-Api-Key": "secret"},       # optional; encrypted at rest, never returned
)

print(integration.id, integration.name)
```

## Get an Integration

Retrieve an integration by name or ID. When resolving by name, pass `integration_type` (names are unique per `(account, type)`).

```python theme={null}
from arize.integrations.types import IntegrationType

integration = client.integrations.get(
    integration="my-openai",
    integration_type=IntegrationType.LLM,  # required when resolving by name
    space="your-space-name-or-id",          # optional visibility filter
)

print(integration.id, integration.name)
```

## Update an LLM Integration

Only the fields you pass are sent to the server; omitted fields are left unchanged. The provider is immutable, and config fields are provider-conditional (the server rejects fields that don't apply to the stored provider). Pass `None` to clear a nullable field (`api_key`, `base_url`, `headers`).

```python theme={null}
integration = client.integrations.update_llm(
    integration="my-openai",
    space="your-space-name-or-id",  # optional visibility filter
    name="my-openai-renamed",
    api_key="sk-new-key",
)

print(integration.name)
```

## Update an Agent Integration

Only the fields you pass are sent; omitted fields are left unchanged. Collection fields (`headers`, `request_presets`, `scopings`) replace the existing values when provided. Pass `None` to clear a nullable field (`description`, `headers`).

```python theme={null}
integration = client.integrations.update_agent(
    integration="my-agent",
    space="your-space-name-or-id",  # optional visibility filter
    endpoint="https://agents.example.com/v2/replay",
    description="Updated description",
)

print(integration.name)
```

## Delete an Integration

Delete an integration by name or ID. This operation is irreversible. When resolving by name, pass `integration_type`.

```python theme={null}
from arize.integrations.types import IntegrationType

client.integrations.delete(
    integration="my-openai",
    integration_type=IntegrationType.LLM,  # required when resolving by name
    space="your-space-name-or-id",          # optional visibility filter
)

print("Integration deleted")
```