> ## Documentation Index
> Fetch the complete documentation index at: https://doc.rapida.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Create Assistant Provider

> Create a provider configuration for an existing assistant.

Creates a new provider configuration for an existing assistant. Use this operation to create a new assistant version backed by a model, AgentKit, or WebSocket provider.

The new provider is created as a version candidate. Promote it with [Update assistant version](/api-reference/assistant/update-assistant-version) when you want the assistant to use it for live traffic.

<Info>
  For setup and authentication options, see the [Installation guide](/api-reference/installation) and [Authentication](/api-reference/authentication).
</Info>

## Parameters

<ParamField body="connectionConfig" type="ConnectionConfig" required>
  Configuration for the client connection.
</ParamField>

<ParamField body="request" type="CreateAssistantProviderRequest" required>
  Provider configuration for an existing assistant. Provide exactly one of `model`, `agentkit`, or `websocket`.

  <Expandable>
    <ParamField body="assistantId" type="uint64" required>
      Assistant ID that owns this provider version.
    </ParamField>

    <ParamField body="description" type="string">
      Version note or change description.
    </ParamField>

    <ParamField body="model" type="CreateAssistantProviderModel">
      Model-backed provider configuration.

      <Expandable>
        <ParamField body="modelProviderName" type="string" required>
          Model provider name, such as `openai`, `anthropic`, or `azure-foundry`.
        </ParamField>

        <ParamField body="template" type="TextChatCompletePrompt">
          Prompt template used by the model provider.
        </ParamField>

        <ParamField body="assistantModelOptions" type="Metadata[]">
          Provider-specific model options, such as `model.name`, `model.id`, and `model.temperature`.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField body="agentkit" type="CreateAssistantProviderAgentkit">
      AgentKit provider configuration.

      <Expandable>
        <ParamField body="agentKitUrl" type="string" required>
          AgentKit gRPC endpoint in `host` or `host:port` format.
        </ParamField>

        <ParamField body="metadata" type="map<string, string>">
          gRPC metadata sent to your AgentKit server.
        </ParamField>

        <ParamField body="transportSecurity" type="string">
          Transport mode. Use `TLS` or `PLAINTEXT`. Defaults to `TLS`.
        </ParamField>

        <ParamField body="tlsVerification" type="string">
          TLS verification mode. Use `VERIFY` or `SKIP_VERIFY`. Defaults to `VERIFY`.
        </ParamField>

        <ParamField body="tlsServerName" type="string">
          Server name used for TLS verification when it differs from the dial address.
        </ParamField>

        <ParamField body="certificate" type="string">
          Optional PEM CA certificate for private or self-signed TLS.
        </ParamField>

        <ParamField body="connectTimeoutMs" type="uint32">
          Connection timeout in milliseconds. Allowed range: `1` to `300000`.
        </ParamField>

        <ParamField body="keepaliveTimeMs" type="uint32">
          Keepalive ping interval in milliseconds. Allowed range: `10000` to `3600000`.
        </ParamField>

        <ParamField body="keepaliveTimeoutMs" type="uint32">
          Keepalive response timeout in milliseconds. Allowed range: `1000` to `300000`.
        </ParamField>

        <ParamField body="maxRecvMessageBytes" type="uint32">
          Maximum inbound gRPC message size. Allowed range: `1024` to `104857600`.
        </ParamField>

        <ParamField body="maxSendMessageBytes" type="uint32">
          Maximum outbound gRPC message size. Allowed range: `1024` to `104857600`.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField body="websocket" type="CreateAssistantProviderWebsocket">
      WebSocket provider configuration.

      <Expandable>
        <ParamField body="websocketUrl" type="string" required>
          WebSocket backend URL.
        </ParamField>

        <ParamField body="headers" type="map<string, string>">
          Headers sent when Rapida connects to the WebSocket backend.
        </ParamField>

        <ParamField body="connectionParameters" type="map<string, string>">
          Connection parameters sent to the WebSocket backend.
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

## Usage

<CodeGroup>
  ```ts React theme={null}
  import {
    ConnectionConfig,
    CreateAssistantProvider,
    CreateAssistantProviderRequest,
    Metadata,
    TextChatCompletePrompt,
    TextPrompt,
  } from "@rapidaai/react";

  const auth = ConnectionConfig.WithDebugger({
    authorization: "AUTHORIZATION_TOKEN_PLACEHOLDER",
    userId: "AUTH_ID_PLACEHOLDER",
    projectId: "PROJECT_ID_PLACEHOLDER",
  });
  const connectionCfg = ConnectionConfig.DefaultConnectionConfig(auth);

  const systemPrompt = new TextPrompt();
  systemPrompt.setRole("system");
  systemPrompt.setContent("You are a helpful support assistant.");

  const template = new TextChatCompletePrompt();
  template.addPrompt(systemPrompt);

  const modelName = new Metadata();
  modelName.setKey("model.name");
  modelName.setValue("gpt-4o-mini");

  const model = new CreateAssistantProviderRequest.CreateAssistantProviderModel();
  model.setModelprovidername("openai");
  model.setTemplate(template);
  model.setAssistantmodeloptionsList([modelName]);

  const request = new CreateAssistantProviderRequest();
  request.setAssistantid("ASSISTANT_ID_PLACEHOLDER");
  request.setDescription("Tune prompt and model parameters");
  request.setModel(model);

  const response = await CreateAssistantProvider(connectionCfg, request);
  console.dir(response.toObject());
  ```

  ```javascript Node.js theme={null}
  import {
    ConnectionConfig,
    CreateAssistantProvider,
    CreateAssistantProviderRequest,
  } from "@rapidaai/nodejs";

  const auth = ConnectionConfig.WithDebugger({
    authorization: process.env.RAPIDA_AUTHORIZATION,
    userId: process.env.RAPIDA_AUTH_ID,
    projectId: process.env.RAPIDA_PROJECT_ID,
  });
  const connectionCfg = ConnectionConfig.DefaultConnectionConfig(auth);

  const agentkit = new CreateAssistantProviderRequest.CreateAssistantProviderAgentkit();
  agentkit.setAgentkiturl("agent.your-domain.com:50051");
  agentkit.setTransportsecurity("TLS");
  agentkit.setTlsverification("VERIFY");
  agentkit.setTlsservername("agent.your-domain.com");
  agentkit.setConnecttimeoutms(10000);
  agentkit.setKeepalivetimems(30000);
  agentkit.setKeepalivetimeoutms(10000);
  agentkit.setMaxrecvmessagebytes(16777216);
  agentkit.setMaxsendmessagebytes(16777216);
  agentkit.getMetadataMap().set("authorization", process.env.AGENTKIT_TOKEN || "");

  const request = new CreateAssistantProviderRequest();
  request.setAssistantid(process.env.RAPIDA_ASSISTANT_ID);
  request.setDescription("Move AgentKit to the production backend");
  request.setAgentkit(agentkit);

  try {
    const response = await CreateAssistantProvider(connectionCfg, request);
    console.dir(response.toObject());
  } catch (error) {
    console.error("Error with CreateAssistantProvider call:", error);
  }
  ```

  ```python Python theme={null}
  import os
  from pprint import pprint

  from rapida import (
      ConnectionConfig,
      CreateAssistantProviderRequest,
      Metadata,
      TextChatCompletePrompt,
      TextPrompt,
      create_assistant_provider,
  )

  auth = ConnectionConfig.with_debugger(
      authorization=os.getenv("RAPIDA_AUTHORIZATION"),
      user_id=os.getenv("RAPIDA_AUTH_ID"),
      project_id=os.getenv("RAPIDA_PROJECT_ID"),
  )
  connection_config = ConnectionConfig.default_connection_config(auth)

  provider = CreateAssistantProviderRequest(
      assistantId=int(os.getenv("RAPIDA_ASSISTANT_ID")),
      description="Tune prompt and model parameters",
      model=CreateAssistantProviderRequest.CreateAssistantProviderModel(
          modelProviderName="openai",
          template=TextChatCompletePrompt(
              prompt=[
                  TextPrompt(
                      role="system",
                      content="You are a helpful support assistant.",
                  )
              ],
          ),
          assistantModelOptions=[
              Metadata(key="model.name", value="gpt-4o-mini"),
          ],
      ),
  )

  response = create_assistant_provider(
      client_cfg=connection_config,
      request=provider,
  )
  pprint(response)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"
  	"os"

  	"github.com/rapidaai/rapida-go/rapida/clients"
  	"github.com/rapidaai/rapida-go/rapida/connections"
  	protos "github.com/rapidaai/rapida-go/protos"
  )

  func main() {
  	connectionConfig := connections.DefaultconnectionConfig(
  		connections.WithPersonalToken(
  			os.Getenv("RAPIDA_AUTHORIZATION"),
  			os.Getenv("RAPIDA_AUTH_ID"),
  			os.Getenv("RAPIDA_PROJECT_ID"),
  		),
  	)

  	request := &protos.CreateAssistantProviderRequest{
  		AssistantId: 2227823180112723968,
  		Description: "Move AgentKit to the production backend",
  		AssistantProvider: &protos.CreateAssistantProviderRequest_Agentkit{
  			Agentkit: &protos.CreateAssistantProviderRequest_CreateAssistantProviderAgentkit{
  				AgentKitUrl:         "agent.your-domain.com:50051",
  				Metadata:            map[string]string{"authorization": os.Getenv("AGENTKIT_TOKEN")},
  				TransportSecurity:   "TLS",
  				TlsVerification:     "VERIFY",
  				TlsServerName:       "agent.your-domain.com",
  				ConnectTimeoutMs:    10000,
  				KeepaliveTimeMs:     30000,
  				KeepaliveTimeoutMs:  10000,
  				MaxRecvMessageBytes: 16777216,
  				MaxSendMessageBytes: 16777216,
  			},
  		},
  	}

  	response, err := clients.CreateAssistantProvider(context.Background(), connectionConfig, request)
  	if err != nil {
  		fmt.Printf("error while creating assistant provider: %+v\n", err)
  		return
  	}
  	fmt.Printf("create assistant provider response: %+v\n", response)
  }
  ```
</CodeGroup>

## Response

<ParamField body="code" type="int32">
  Numeric status code for the operation.
</ParamField>

<ParamField body="success" type="boolean">
  Indicates whether the operation was successful.
</ParamField>

<ParamField body="assistantProviderModel" type="AssistantProviderModel">
  Returned when you create a model-backed provider version.
</ParamField>

<ParamField body="assistantProviderAgentkit" type="AssistantProviderAgentkit">
  Returned when you create an AgentKit provider version.
</ParamField>

<ParamField body="assistantProviderWebsocket" type="AssistantProviderWebsocket">
  Returned when you create a WebSocket provider version.
</ParamField>

<ParamField body="error" type="Error">
  Error details when the operation fails.
</ParamField>