> ## 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

> Create an assistant from the Rapida SDK.

Creates an assistant with one provider configuration. You can also attach tags, tools, and knowledge during creation.

<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="CreateAssistantRequest" required>
  <Expandable>
    <ParamField body="name" type="string" required>
      Assistant name.
    </ParamField>

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

      <Expandable>
        <ParamField body="description" type="string">
          Description for this provider configuration.
        </ParamField>

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

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

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

            <ParamField body="assistantModelOptions" type="Metadata[]">
              Provider-specific model options.
            </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, such as auth or routing keys.
            </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.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField body="description" type="string">
      Assistant description.
    </ParamField>

    <ParamField body="visibility" type="string">
      Assistant visibility, for example `private`.
    </ParamField>

    <ParamField body="language" type="string">
      Assistant language code, for example `en`.
    </ParamField>

    <ParamField body="tags" type="string[]">
      Tags to attach to the assistant.
    </ParamField>

    <ParamField body="assistantTools" type="CreateAssistantToolRequest[]">
      Tools to attach to the assistant.
    </ParamField>

    <ParamField body="assistantKnowledges" type="CreateAssistantKnowledgeRequest[]">
      Knowledge sources to attach to the assistant.
    </ParamField>
  </Expandable>
</ParamField>

## Usage

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

  const auth = ConnectionConfig.WithPersonalToken({
    Authorization: "AUTHORIZATION_TOKEN_PLACEHOLDER",
    AuthId: "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 modelOption = new Metadata();
  modelOption.setKey("model");
  modelOption.setValue("gpt-4o-mini");

  const model = new CreateAssistantProviderRequest.CreateAssistantProviderModel();
  model.setModelprovidername("openai");
  model.setTemplate(template);
  model.addAssistantmodeloptions(modelOption);

  const provider = new CreateAssistantProviderRequest();
  provider.setDescription("Primary model provider");
  provider.setModel(model);

  const request = new CreateAssistantRequest();
  request.setName("Support assistant");
  request.setDescription("Answers customer support questions.");
  request.setVisibility("private");
  request.setLanguage("en");
  request.setTagsList(["support", "production"]);
  request.setAssistantprovider(provider);

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

  ```javascript Node.js theme={null}
  import {
    ConnectionConfig,
    CreateAssistant,
    CreateAssistantRequest,
    CreateAssistantProviderRequest,
    Metadata,
    TextChatCompletePrompt,
    TextPrompt,
  } from "@rapidaai/nodejs";

  const connectionCfg = ConnectionConfig.DefaultConnectionConfig(
    ConnectionConfig.WithSDK({
      ApiKey: process.env.RAPIDA_API_KEY,
    })
  );

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

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

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

  const model = new CreateAssistantProviderRequest.CreateAssistantProviderModel();
  model.setModelprovidername("openai");
  model.setTemplate(template);
  model.addAssistantmodeloptions(modelOption);

  const provider = new CreateAssistantProviderRequest();
  provider.setDescription("Primary model provider");
  provider.setModel(model);

  const request = new CreateAssistantRequest();
  request.setName("Support assistant");
  request.setDescription("Answers customer support questions.");
  request.setVisibility("private");
  request.setLanguage("en");
  request.setTagsList(["support", "production"]);
  request.setAssistantprovider(provider);

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

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

  from rapida import (
      ConnectionConfig,
      CreateAssistantProviderRequest,
      CreateAssistantRequest,
      Metadata,
      TextChatCompletePrompt,
      TextPrompt,
      create_assistant,
  )

  connection_config = ConnectionConfig.default_connection_config(
      ConnectionConfig.with_sdk(os.getenv("RAPIDA_API_KEY"))
  )

  provider = CreateAssistantProviderRequest(
      description="Primary model provider",
      model=CreateAssistantProviderRequest.CreateAssistantProviderModel(
          modelProviderName="openai",
          template=TextChatCompletePrompt(
              prompt=[
                  TextPrompt(
                      role="system",
                      content="You are a helpful support assistant.",
                  )
              ],
          ),
          assistantModelOptions=[
              Metadata(key="model", value="gpt-4o-mini"),
          ],
      ),
  )

  response = create_assistant(
      client_cfg=connection_config,
      request=CreateAssistantRequest(
          name="Support assistant",
          description="Answers customer support questions.",
          visibility="private",
          language="en",
          tags=["support", "production"],
          assistantProvider=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.WithSDK(os.Getenv("RAPIDA_API_KEY")),
  	)

  	response, err := clients.CreateAssistant(
  		context.Background(),
  		connectionConfig,
  		&protos.CreateAssistantRequest{
  			Name:        "Support assistant",
  			Description: "Answers customer support questions.",
  			Visibility:  "private",
  			Language:    "en",
  			Tags:        []string{"support", "production"},
  			AssistantProvider: &protos.CreateAssistantProviderRequest{
  				Description: "Primary model provider",
  				AssistantProvider: &protos.CreateAssistantProviderRequest_Model{
  					Model: &protos.CreateAssistantProviderRequest_CreateAssistantProviderModel{
  						ModelProviderName: "openai",
  						Template: &protos.TextChatCompletePrompt{
  							Prompt: []*protos.TextPrompt{{
  								Role:    "system",
  								Content: "You are a helpful support assistant.",
  							}},
  						},
  						AssistantModelOptions: []*protos.Metadata{{
  							Key:   "model",
  							Value: "gpt-4o-mini",
  						}},
  					},
  				},
  			},
  		},
  	)
  	if err != nil {
  		fmt.Printf("error while creating assistant: %+v\n", err)
  		return
  	}
  	fmt.Printf("create assistant response: %+v\n", response)
  }
  ```
</CodeGroup>

## Create an AgentKit assistant

Use the `agentkit` provider when Rapida should handle telephony, STT, and TTS while your backend handles reasoning over the AgentKit gRPC stream.

<CodeGroup>
  ```json REST request theme={null}
  {
    "name": "AgentKit support assistant",
    "description": "Routes live conversations to a custom AgentKit backend.",
    "visibility": "private",
    "language": "en",
    "tags": ["support", "agentkit"],
    "assistantProvider": {
      "description": "AgentKit production backend",
      "agentkit": {
        "agentKitUrl": "agent.your-domain.com:50051",
        "metadata": {
          "authorization": "shared-token",
          "tenant": "acme"
        },
        "transportSecurity": "TLS",
        "tlsVerification": "VERIFY",
        "tlsServerName": "agent.your-domain.com",
        "connectTimeoutMs": 10000,
        "keepaliveTimeMs": 30000,
        "keepaliveTimeoutMs": 10000,
        "maxRecvMessageBytes": 16777216,
        "maxSendMessageBytes": 16777216
      }
    }
  }
  ```

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

  const auth = ConnectionConfig.WithPersonalToken({
    Authorization: process.env.RAPIDA_AUTHORIZATION,
    AuthId: 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 provider = new CreateAssistantProviderRequest();
  provider.setDescription("AgentKit production backend");
  provider.setAgentkit(agentkit);

  const request = new CreateAssistantRequest();
  request.setName("AgentKit support assistant");
  request.setDescription("Routes live conversations to a custom AgentKit backend.");
  request.setVisibility("private");
  request.setLanguage("en");
  request.setTagsList(["support", "agentkit"]);
  request.setAssistantprovider(provider);

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

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

  from rapida import (
      ConnectionConfig,
      CreateAssistantProviderRequest,
      CreateAssistantRequest,
      create_assistant,
  )

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

  provider = CreateAssistantProviderRequest(
      description="AgentKit production backend",
      agentkit=CreateAssistantProviderRequest.CreateAssistantProviderAgentkit(
          agentKitUrl="agent.your-domain.com:50051",
          metadata={"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 = create_assistant(
      client_cfg=connection_config,
      request=CreateAssistantRequest(
          name="AgentKit support assistant",
          description="Routes live conversations to a custom AgentKit backend.",
          visibility="private",
          language="en",
          tags=["support", "agentkit"],
          assistantProvider=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.CreateAssistantRequest{
  		Name:        "AgentKit support assistant",
  		Description: "Routes live conversations to a custom AgentKit backend.",
  		Visibility:  "private",
  		Language:    "en",
  		Tags:        []string{"support", "agentkit"},
  		AssistantProvider: &protos.CreateAssistantProviderRequest{
  			Description: "AgentKit 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.CreateAssistant(context.Background(), connectionConfig, request)
  	if err != nil {
  		fmt.Printf("error while creating AgentKit assistant: %+v\n", err)
  		return
  	}
  	fmt.Printf("create assistant 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="data" type="Assistant">
  Created assistant.

  <Expandable>
    <ParamField body="id" type="uint64">
      Unique identifier for the assistant.
    </ParamField>

    <ParamField body="name" type="string">
      Assistant name.
    </ParamField>

    <ParamField body="description" type="string">
      Assistant description.
    </ParamField>

    <ParamField body="status" type="string">
      Current assistant status.
    </ParamField>

    <ParamField body="visibility" type="string">
      Assistant visibility.
    </ParamField>

    <ParamField body="assistantProvider" type="string">
      Active provider type.
    </ParamField>

    <ParamField body="assistantProviderModel" type="AssistantProviderModel">
      Model provider details when the assistant uses a model-backed provider.
    </ParamField>

    <ParamField body="assistantProviderAgentkit" type="AssistantProviderAgentkit">
      AgentKit provider details when the assistant uses AgentKit.

      <Expandable>
        <ParamField body="id" type="uint64">
          Unique identifier for the AgentKit provider version.
        </ParamField>

        <ParamField body="url" type="string">
          AgentKit gRPC endpoint.
        </ParamField>

        <ParamField body="metadata" type="map<string, string>">
          Metadata sent to the AgentKit backend.
        </ParamField>

        <ParamField body="transportSecurity" type="string">
          Transport mode for the AgentKit connection.
        </ParamField>

        <ParamField body="tlsVerification" type="string">
          TLS verification mode.
        </ParamField>

        <ParamField body="tlsServerName" type="string">
          TLS server name override.
        </ParamField>

        <ParamField body="connectTimeoutMs" type="uint32">
          Connection timeout in milliseconds.
        </ParamField>

        <ParamField body="keepaliveTimeMs" type="uint32">
          Keepalive ping interval in milliseconds.
        </ParamField>

        <ParamField body="keepaliveTimeoutMs" type="uint32">
          Keepalive response timeout in milliseconds.
        </ParamField>

        <ParamField body="maxRecvMessageBytes" type="uint32">
          Maximum inbound gRPC message size.
        </ParamField>

        <ParamField body="maxSendMessageBytes" type="uint32">
          Maximum outbound gRPC message size.
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField body="assistantProviderWebsocket" type="AssistantProviderWebsocket">
      WebSocket provider details when the assistant uses a WebSocket provider.
    </ParamField>

    <ParamField body="assistantTools" type="AssistantTool[]">
      Tools attached to the assistant.
    </ParamField>
  </Expandable>
</ParamField>

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