Struct OpenAiModel

pub struct OpenAiModel {

    pub messages: Option<Vec<OpenAiMessage>>,
    pub tools: Option<Vec<AnyscaleModelToolsInner>>,
    pub tool_ids: Option<Vec<String>>,
    pub knowledge_base: Option<CreateCustomKnowledgeBaseDto>,
    pub knowledge_base_id: Option<String>,
    pub provider: ProviderTrue,
    pub model: ModelTrue,
    pub fallback_models: Option<Vec<FallbackModelsTrue>>,
    pub tool_strict_compatibility_mode: Option<ToolStrictCompatibilityModeTrue>,
    pub temperature: Option<f64>,
    pub max_tokens: Option<f64>,
    pub emotion_recognition_enabled: Option<bool>,
    pub num_fast_turns: Option<f64>,
}

Fields

messages: Option<Vec<OpenAiMessage>>

This is the starting state for the conversation.

tools: Option<Vec<AnyscaleModelToolsInner>>

These are the tools that the assistant can use during the call. To use existing tools, use toolIds. Both tools and toolIds can be used together.

tool_ids: Option<Vec<String>>

These are the tools that the assistant can use during the call. To use transient tools, use tools. Both tools and toolIds can be used together.

knowledge_base: Option<CreateCustomKnowledgeBaseDto>

knowledge_base_id: Option<String>

This is the ID of the knowledge base the model will use.

provider: ProviderTrue

This is the provider that will be used for the model.

model: ModelTrue

This is the OpenAI model that will be used. When using Vapi OpenAI or your own Azure Credentials, you have the option to specify the region for the selected model. This shouldn’t be specified unless you have a specific reason to do so. Vapi will automatically find the fastest region that make sense. This is helpful when you are required to comply with Data Residency rules. Learn more about Azure regions here https://azure.microsoft.com/en-us/explore/global-infrastructure/data-residency/. @default undefined

fallback_models: Option<Vec<FallbackModelsTrue>>

These are the fallback models that will be used if the primary model fails. This shouldn’t be specified unless you have a specific reason to do so. Vapi will automatically find the fastest fallbacks that make sense.

tool_strict_compatibility_mode: Option<ToolStrictCompatibilityModeTrue>

Azure OpenAI doesn’t support maxLength right now https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/structured-outputs?tabs=python-secure%2Cdotnet-entra-id&pivots=programming-language-csharp#unsupported-type-specific-keywords. Need to strip. - strip-parameters-with-unsupported-validation will strip parameters with unsupported validation. - strip-unsupported-validation will keep the parameters but strip unsupported validation. @default strip-unsupported-validation

temperature: Option<f64>

This is the temperature that will be used for calls. Default is 0 to leverage caching for lower latency.

max_tokens: Option<f64>

This is the max number of tokens that the assistant will be allowed to generate in each turn of the conversation. Default is 250.

emotion_recognition_enabled: Option<bool>

This determines whether we detect user’s emotion while they speak and send it as an additional info to model. Default false because the model is usually are good at understanding the user’s emotion from text. @default false

num_fast_turns: Option<f64>

This sets how many turns at the start of the conversation to use a smaller, faster model from the same provider before switching to the primary model. Example, gpt-3.5-turbo if provider is openai. Default is 0. @default 0

Implementations

impl OpenAiModel

pub fn new(provider: ProviderTrue, model: ModelTrue) -> OpenAiModel

Trait Implementations

impl Clone for OpenAiModel

fn clone(&self) -> OpenAiModel

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OpenAiModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for OpenAiModel

fn default() -> OpenAiModel

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OpenAiModel

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OpenAiModel

fn eq(&self, other: &OpenAiModel) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OpenAiModel

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for OpenAiModel