Create Assistant

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

For setup and authentication options, see the Installation guide and Authentication.

Parameters

ConnectionConfig

required

Configuration for the client connection.

CreateAssistantRequest

required

Show child attributes

string

required

Assistant name.

CreateAssistantProviderRequest

required

Provider configuration for the assistant. Provide exactly one of model, agentkit, or websocket.

Show child attributes

string

Description for this provider configuration.

CreateAssistantProviderModel

Model-backed provider configuration.

Show child attributes

string

required

Model provider name, such as openai.

TextChatCompletePrompt

Prompt template used by the model provider.

Metadata[]

Provider-specific model options.

CreateAssistantProviderAgentkit

AgentKit provider configuration.

Show child attributes

string

required

AgentKit gRPC endpoint in host or host:port format.

map<string, string>

gRPC metadata sent to your AgentKit server, such as auth or routing keys.

string

Transport mode. Use TLS or PLAINTEXT. Defaults to TLS.

string

TLS verification mode. Use VERIFY or SKIP_VERIFY. Defaults to VERIFY.

string

Server name used for TLS verification when it differs from the dial address.

string

Optional PEM CA certificate for private or self-signed TLS.

uint32

Connection timeout in milliseconds. Allowed range: 1 to 300000.

uint32

Keepalive ping interval in milliseconds. Allowed range: 10000 to 3600000.

uint32

Keepalive response timeout in milliseconds. Allowed range: 1000 to 300000.

uint32

Maximum inbound gRPC message size. Allowed range: 1024 to 104857600.

uint32

Maximum outbound gRPC message size. Allowed range: 1024 to 104857600.

CreateAssistantProviderWebsocket

WebSocket provider configuration.

string

Assistant description.

string

Assistant visibility, for example private.

string

Assistant language code, for example en.

string[]

Tags to attach to the assistant.

CreateAssistantToolRequest[]

Tools to attach to the assistant.

CreateAssistantKnowledgeRequest[]

Knowledge sources to attach to the assistant.

Usage

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());

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);
}

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)

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)
}

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.

{
  "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
    }
  }
}

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());

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)

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)
}

Response

int32

Numeric status code for the operation.

boolean

Indicates whether the operation was successful.

Assistant

Created assistant.

Show child attributes

uint64

Unique identifier for the assistant.

string

Assistant name.

string

Assistant description.

string

Current assistant status.

string

Assistant visibility.

string

Active provider type.

AssistantProviderModel

Model provider details when the assistant uses a model-backed provider.

AssistantProviderAgentkit

AgentKit provider details when the assistant uses AgentKit.

Show child attributes

uint64

Unique identifier for the AgentKit provider version.

string

AgentKit gRPC endpoint.

map<string, string>

Metadata sent to the AgentKit backend.

string

Transport mode for the AgentKit connection.

string

TLS verification mode.

string

TLS server name override.

uint32

Connection timeout in milliseconds.

uint32

Keepalive ping interval in milliseconds.

uint32

Keepalive response timeout in milliseconds.

uint32

Maximum inbound gRPC message size.

uint32

Maximum outbound gRPC message size.

AssistantProviderWebsocket

WebSocket provider details when the assistant uses a WebSocket provider.

AssistantTool[]

Tools attached to the assistant.

Error

Error details when the operation fails.

Getting Started

Assistant

Calls

Endpoint

Parameters

Usage

Create an AgentKit assistant

Response

​Parameters

​Usage

​Create an AgentKit assistant

​Response

Parameters

Usage

Create an AgentKit assistant

Response