Integrations

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

An integration is either an LLM (model-provider) connection or an AGENT (customer-hosted endpoint) connection; each returned Integration is a polymorphic union carrying a type discriminator, so call AsLlmIntegration or AsAgentIntegration after checking Discriminator. The Get, Delete, UpdateAgent, and UpdateLLM methods accept either an integration name or an ID — because names are unique per account and type, Get and Delete require Type when a name is passed, and Space optionally narrows name resolution. Use CreateAgent / UpdateAgent for agent integrations and CreateLLM / UpdateLLM for LLM integrations. On CreateLLM, set exactly one per-provider field on CreateLLMConfig; setting zero or more than one returns integrations.ErrInvalidProviderConfig without contacting the server.

List Integrations

List returns a paginated list of integrations. Defaults to a page size of 50. Type, when set, filters to a single category (IntegrationTypeLLM or IntegrationTypeAgent); when omitted, every type is returned, each item carrying its own type discriminator. Space, when non-empty, filters by space (substring match on space name, or exact match if a base64 resource ID is passed). Signature:

func (c *Client) List(ctx context.Context, req ListRequest) (*ListIntegrations, error)

Usage Example:

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    "github.com/Arize-ai/client-go-v2/arize"
    "github.com/Arize-ai/client-go-v2/arize/integrations"
)

func main() {
    client, err := arize.NewClient(arize.Config{APIKey: "your-api-key"})
    if err != nil {
        log.Fatal(err)
    }

    resp, err := client.Integrations.List(context.Background(), integrations.ListRequest{
        Space: "your-space-name-or-id",
        Type:  integrations.IntegrationTypeLLM,
        Limit: 25,
    })
    if err != nil {
        var unauthorized *arize.UnauthorizedError
        if errors.As(err, &unauthorized) {
            log.Fatalf("unauthorized: %v", unauthorized)
        }
        log.Fatal(err)
    }

    for _, integration := range resp.Integrations {
        if llm, err := integration.AsLlmIntegration(); err == nil {
            fmt.Printf("%s: %s (llm)\n", llm.Id, llm.Name)
        }
    }
}

Get an Integration

Get returns a single integration, resolving by name or ID. When Integration is a name, Type is required (names are unique per account and type); a name without a type, like an unresolvable name, returns *arize.ResourceNotFoundError. Signature:

func (c *Client) Get(ctx context.Context, req GetRequest) (*Integration, error)

Usage Example:

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    "github.com/Arize-ai/client-go-v2/arize"
    "github.com/Arize-ai/client-go-v2/arize/integrations"
)

func main() {
    client, err := arize.NewClient(arize.Config{APIKey: "your-api-key"})
    if err != nil {
        log.Fatal(err)
    }

    integration, err := client.Integrations.Get(
        context.Background(),
        integrations.GetRequest{
            Integration: "your-integration-name-or-id",
            Type:        integrations.IntegrationTypeLLM,
            Space:       "your-space-name-or-id",
        },
    )
    if err != nil {
        var notFound *arize.NotFoundError
        if errors.As(err, &notFound) {
            log.Fatalf("integration not found: %v", notFound)
        }
        log.Fatal(err)
    }

    d, err := integration.Discriminator()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("integration type=%s\n", d)
}

Create an Agent Integration

CreateAgent creates a new AGENT (type=AGENT) integration — a customer-hosted HTTPS endpoint Arize calls for replay — and returns it. Endpoint and InputSchema (a Draft-07 JSON Schema) are required. Signature:

func (c *Client) CreateAgent(ctx context.Context, req CreateAgentRequest) (*Integration, error)

Usage Example:

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    "github.com/Arize-ai/client-go-v2/arize"
    "github.com/Arize-ai/client-go-v2/arize/integrations"
)

func main() {
    client, err := arize.NewClient(arize.Config{APIKey: "your-api-key"})
    if err != nil {
        log.Fatal(err)
    }

    integration, err := client.Integrations.CreateAgent(
        context.Background(),
        integrations.CreateAgentRequest{
            Name:     "my-agent",
            Endpoint: "https://agent.example.com/replay",
            InputSchema: map[string]any{
                "type": "object",
                "properties": map[string]any{
                    "prompt": map[string]any{"type": "string"},
                },
            },
        },
    )
    if err != nil {
        var unprocessable *arize.UnprocessableEntityError
        if errors.As(err, &unprocessable) {
            log.Fatalf("invalid agent config: %v", unprocessable)
        }
        log.Fatal(err)
    }

    agent, err := integration.AsAgentIntegration()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("created agent integration %s\n", agent.Id)
}

Create an LLM Integration

CreateLLM creates a new LLM (type=LLM) integration and returns it. Config selects the provider: set exactly one of its per-provider fields (OpenAI, Anthropic, Gemini, AWSBedrock, Custom, VertexAI, NvidiaNIM, LiteLLM, Fireworks, TogetherAi). Setting zero or more than one returns integrations.ErrInvalidProviderConfig. Signature:

func (c *Client) CreateLLM(ctx context.Context, req CreateLLMRequest) (*Integration, error)

Usage Example:

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    "github.com/Arize-ai/client-go-v2/arize"
    "github.com/Arize-ai/client-go-v2/arize/integrations"
)

func main() {
    client, err := arize.NewClient(arize.Config{APIKey: "your-api-key"})
    if err != nil {
        log.Fatal(err)
    }

    integration, err := client.Integrations.CreateLLM(
        context.Background(),
        integrations.CreateLLMRequest{
            Name: "my-openai",
            Config: integrations.CreateLLMConfig{
                OpenAI: &integrations.CreateOpenAIConfig{
                    APIKey: "sk-...",
                },
            },
        },
    )
    if err != nil {
        if errors.Is(err, integrations.ErrInvalidProviderConfig) {
            log.Fatal("set exactly one provider on CreateLLMConfig")
        }
        log.Fatal(err)
    }

    llm, err := integration.AsLlmIntegration()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("created llm integration %s\n", llm.Id)
}

Update an Agent Integration

UpdateAgent patches an existing agent integration, resolving by name or ID (the type is fixed to AGENT), and returns the updated integration. Only non-nil patch fields are sent; nil fields are left unchanged. For nullable fields (Description, Headers), pass a pointer to the empty value to clear the field. Returns integrations.ErrNoUpdateFields without contacting the server when no patch fields are set. Signature:

func (c *Client) UpdateAgent(ctx context.Context, req UpdateAgentRequest) (*Integration, error)

Usage Example:

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    "github.com/Arize-ai/client-go-v2/arize"
    "github.com/Arize-ai/client-go-v2/arize/integrations"
)

func main() {
    client, err := arize.NewClient(arize.Config{APIKey: "your-api-key"})
    if err != nil {
        log.Fatal(err)
    }

    newEndpoint := "https://agent.example.com/replay-v2"
    integration, err := client.Integrations.UpdateAgent(
        context.Background(),
        integrations.UpdateAgentRequest{
            Integration: "your-integration-name-or-id",
            Space:       "your-space-name-or-id",
            Endpoint:    &newEndpoint,
        },
    )
    if err != nil {
        if errors.Is(err, integrations.ErrNoUpdateFields) {
            log.Fatal("no fields to update")
        }
        var notFound *arize.NotFoundError
        if errors.As(err, &notFound) {
            log.Fatalf("integration not found: %v", notFound)
        }
        log.Fatal(err)
    }

    agent, err := integration.AsAgentIntegration()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("updated agent integration %s\n", agent.Id)
}

Update an LLM Integration

UpdateLLM patches an existing LLM integration, resolving by name or ID (the type is fixed to LLM), and returns the updated integration. Only non-nil patch fields are sent; nil fields are left unchanged. The provider is immutable. For nullable fields (APIKey, BaseURL, Headers), pass a pointer to the empty value to clear the field. Field applicability is provider-specific and enforced server-side. Returns integrations.ErrNoUpdateFields without contacting the server when no patch fields are set. Signature:

func (c *Client) UpdateLLM(ctx context.Context, req UpdateLLMRequest) (*Integration, error)

Usage Example:

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    "github.com/Arize-ai/client-go-v2/arize"
    "github.com/Arize-ai/client-go-v2/arize/integrations"
)

func main() {
    client, err := arize.NewClient(arize.Config{APIKey: "your-api-key"})
    if err != nil {
        log.Fatal(err)
    }

    newKey := "sk-rotated-..."
    integration, err := client.Integrations.UpdateLLM(
        context.Background(),
        integrations.UpdateLLMRequest{
            Integration: "your-integration-name-or-id",
            Space:       "your-space-name-or-id",
            APIKey:      &newKey,
        },
    )
    if err != nil {
        if errors.Is(err, integrations.ErrNoUpdateFields) {
            log.Fatal("no fields to update")
        }
        var notFound *arize.NotFoundError
        if errors.As(err, &notFound) {
            log.Fatalf("integration not found: %v", notFound)
        }
        log.Fatal(err)
    }

    llm, err := integration.AsLlmIntegration()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("updated llm integration %s\n", llm.Id)
}

Delete an Integration

Delete removes an integration, resolving by name or ID. When Integration is a name, Type is required; a name without a type, like an unresolvable name, returns *arize.ResourceNotFoundError. It returns only an error. Signature:

func (c *Client) Delete(ctx context.Context, req DeleteRequest) error

Usage Example:

package main

import (
    "context"
    "errors"
    "log"

    "github.com/Arize-ai/client-go-v2/arize"
    "github.com/Arize-ai/client-go-v2/arize/integrations"
)

func main() {
    client, err := arize.NewClient(arize.Config{APIKey: "your-api-key"})
    if err != nil {
        log.Fatal(err)
    }

    err = client.Integrations.Delete(
        context.Background(),
        integrations.DeleteRequest{
            Integration: "your-integration-name-or-id",
            Type:        integrations.IntegrationTypeLLM,
            Space:       "your-space-name-or-id",
        },
    )
    if err != nil {
        var notFound *arize.NotFoundError
        if errors.As(err, &notFound) {
            log.Printf("no integration to remove: %v", notFound)
            return
        }
        log.Fatal(err)
    }
}

Skills

MCP server

API reference

API clients

List Integrations

Get an Integration

Create an Agent Integration

Create an LLM Integration

Update an Agent Integration

Update an LLM Integration

Delete an Integration

​List Integrations

​Get an Integration

​Create an Agent Integration

​Create an LLM Integration

​Update an Agent Integration

​Update an LLM Integration

​Delete an Integration

List Integrations

Get an Integration

Create an Agent Integration

Create an LLM Integration

Update an Agent Integration

Update an LLM Integration

Delete an Integration