Create Assistant Provider

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

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

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)

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