Struct openai_api_rs::v1::api::Client

pub struct Client {
    pub api_key: String,
}

Fields

api_key: String

Implementations

impl Client

pub fn new(api_key: String) -> Self

Examples found in repository

examples/embedding.rs (line 7)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
    let req = EmbeddingRequest {
        model: "text-embedding-ada-002".to_string(),
        input: "story time".to_string(),
        user: Option::None,
    };
    let result = client.embedding(req).await?;
    println!("{:?}", result.data);

    Ok(())
}

examples/chat_completion.rs (line 7)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
    let req = ChatCompletionRequest {
        model: chat_completion::GPT4.to_string(),
        messages: vec![chat_completion::ChatCompletionMessage {
            role: chat_completion::MessageRole::user,
            content: Some(String::from("What is Bitcoin?")),
            name: None,
            function_call: None,
        }],
        functions: None,
        function_call: None,
    };
    let result = client.chat_completion(req).await?;
    println!("{:?}", result.choices[0].message.content);
    Ok(())
}

examples/completion.rs (line 7)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
    let req = CompletionRequest {
        model: completion::GPT3_TEXT_DAVINCI_003.to_string(),
        prompt: Some(String::from("What is Bitcoin?")),
        suffix: None,
        max_tokens: Some(3000),
        temperature: Some(0.9),
        top_p: Some(1.0),
        n: None,
        stream: None,
        logprobs: None,
        echo: None,
        stop: Some(vec![String::from(" Human:"), String::from(" AI:")]),
        presence_penalty: Some(0.6),
        frequency_penalty: Some(0.0),
        best_of: None,
        logit_bias: None,
        user: None,
    };
    let result = client.completion(req).await?;
    println!("{:}", result.choices[0].text);

    Ok(())
}

examples/function_call.rs (line 18)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());

    let mut properties = HashMap::new();
    properties.insert(
        "coin".to_string(),
        Box::new(chat_completion::JSONSchemaDefine {
            schema_type: Some(chat_completion::JSONSchemaType::String),
            description: Some("The cryptocurrency to get the price of".to_string()),
            enum_values: None,
            properties: None,
            required: None,
            items: None,
        }),
    );

    let req = ChatCompletionRequest {
        model: chat_completion::GPT3_5_TURBO_0613.to_string(),
        messages: vec![chat_completion::ChatCompletionMessage {
            role: chat_completion::MessageRole::user,
            content: Some(String::from("What is the price of Ethereum?")),
            name: None,
            function_call: None,
        }],
        functions: Some(vec![chat_completion::Function {
            name: String::from("get_coin_price"),
            description: Some(String::from("Get the price of a cryptocurrency")),
            parameters: Some(chat_completion::FunctionParameters {
                schema_type: chat_completion::JSONSchemaType::Object,
                properties: Some(properties),
                required: Some(vec![String::from("coin")]),
            }),
        }]),
        function_call: Some("auto".to_string()),
    };

    let result = client.chat_completion(req).await?;

    match result.choices[0].finish_reason {
        chat_completion::FinishReason::stop => {
            println!("Stop");
            println!("{:?}", result.choices[0].message.content);
        }
        chat_completion::FinishReason::length => {
            println!("Length");
        }
        chat_completion::FinishReason::function_call => {
            println!("FunctionCall");
            #[derive(Serialize, Deserialize)]
            struct Currency {
                coin: String,
            }
            let function_call = result.choices[0].message.function_call.as_ref().unwrap();
            let name = function_call.name.clone().unwrap();
            let arguments = function_call.arguments.clone().unwrap();
            let c: Currency = serde_json::from_str(&arguments)?;
            let coin = c.coin;
            if name == "get_coin_price" {
                let price = get_coin_price(&coin).await;
                println!("{} price: {}", coin, price);
            }
        }
        chat_completion::FinishReason::content_filter => {
            println!("ContentFilter");
        }
        chat_completion::FinishReason::null => {
            println!("Null");
        }
    }
    Ok(())
}

pub async fn post<T: Serialize>( &self, path: &str, params: &T ) -> Result<Response, APIError>

pub async fn get(&self, path: &str) -> Result<Response, APIError>

pub async fn delete(&self, path: &str) -> Result<Response, APIError>

pub async fn completion( &self, req: CompletionRequest ) -> Result<CompletionResponse, APIError>

Examples found in repository

examples/completion.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
    let req = CompletionRequest {
        model: completion::GPT3_TEXT_DAVINCI_003.to_string(),
        prompt: Some(String::from("What is Bitcoin?")),
        suffix: None,
        max_tokens: Some(3000),
        temperature: Some(0.9),
        top_p: Some(1.0),
        n: None,
        stream: None,
        logprobs: None,
        echo: None,
        stop: Some(vec![String::from(" Human:"), String::from(" AI:")]),
        presence_penalty: Some(0.6),
        frequency_penalty: Some(0.0),
        best_of: None,
        logit_bias: None,
        user: None,
    };
    let result = client.completion(req).await?;
    println!("{:}", result.choices[0].text);

    Ok(())
}

pub async fn edit(&self, req: EditRequest) -> Result<EditResponse, APIError>

pub async fn image_generation( &self, req: ImageGenerationRequest ) -> Result<ImageGenerationResponse, APIError>

pub async fn image_edit( &self, req: ImageEditRequest ) -> Result<ImageEditResponse, APIError>

pub async fn image_variation( &self, req: ImageVariationRequest ) -> Result<ImageVariationResponse, APIError>

pub async fn embedding( &self, req: EmbeddingRequest ) -> Result<EmbeddingResponse, APIError>

Examples found in repository

examples/embedding.rs (line 13)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
    let req = EmbeddingRequest {
        model: "text-embedding-ada-002".to_string(),
        input: "story time".to_string(),
        user: Option::None,
    };
    let result = client.embedding(req).await?;
    println!("{:?}", result.data);

    Ok(())
}

pub async fn file_list(&self) -> Result<FileListResponse, APIError>

pub async fn file_upload( &self, req: FileUploadRequest ) -> Result<FileUploadResponse, APIError>

pub async fn file_delete( &self, req: FileDeleteRequest ) -> Result<FileDeleteResponse, APIError>

pub async fn file_retrieve( &self, req: FileRetrieveRequest ) -> Result<FileRetrieveResponse, APIError>

pub async fn file_retrieve_content( &self, req: FileRetrieveContentRequest ) -> Result<FileRetrieveContentResponse, APIError>

pub async fn chat_completion( &self, req: ChatCompletionRequest ) -> Result<ChatCompletionResponse, APIError>

Examples found in repository

examples/chat_completion.rs (line 19)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
    let req = ChatCompletionRequest {
        model: chat_completion::GPT4.to_string(),
        messages: vec![chat_completion::ChatCompletionMessage {
            role: chat_completion::MessageRole::user,
            content: Some(String::from("What is Bitcoin?")),
            name: None,
            function_call: None,
        }],
        functions: None,
        function_call: None,
    };
    let result = client.chat_completion(req).await?;
    println!("{:?}", result.choices[0].message.content);
    Ok(())
}

examples/function_call.rs (line 53)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());

    let mut properties = HashMap::new();
    properties.insert(
        "coin".to_string(),
        Box::new(chat_completion::JSONSchemaDefine {
            schema_type: Some(chat_completion::JSONSchemaType::String),
            description: Some("The cryptocurrency to get the price of".to_string()),
            enum_values: None,
            properties: None,
            required: None,
            items: None,
        }),
    );

    let req = ChatCompletionRequest {
        model: chat_completion::GPT3_5_TURBO_0613.to_string(),
        messages: vec![chat_completion::ChatCompletionMessage {
            role: chat_completion::MessageRole::user,
            content: Some(String::from("What is the price of Ethereum?")),
            name: None,
            function_call: None,
        }],
        functions: Some(vec![chat_completion::Function {
            name: String::from("get_coin_price"),
            description: Some(String::from("Get the price of a cryptocurrency")),
            parameters: Some(chat_completion::FunctionParameters {
                schema_type: chat_completion::JSONSchemaType::Object,
                properties: Some(properties),
                required: Some(vec![String::from("coin")]),
            }),
        }]),
        function_call: Some("auto".to_string()),
    };

    let result = client.chat_completion(req).await?;

    match result.choices[0].finish_reason {
        chat_completion::FinishReason::stop => {
            println!("Stop");
            println!("{:?}", result.choices[0].message.content);
        }
        chat_completion::FinishReason::length => {
            println!("Length");
        }
        chat_completion::FinishReason::function_call => {
            println!("FunctionCall");
            #[derive(Serialize, Deserialize)]
            struct Currency {
                coin: String,
            }
            let function_call = result.choices[0].message.function_call.as_ref().unwrap();
            let name = function_call.name.clone().unwrap();
            let arguments = function_call.arguments.clone().unwrap();
            let c: Currency = serde_json::from_str(&arguments)?;
            let coin = c.coin;
            if name == "get_coin_price" {
                let price = get_coin_price(&coin).await;
                println!("{} price: {}", coin, price);
            }
        }
        chat_completion::FinishReason::content_filter => {
            println!("ContentFilter");
        }
        chat_completion::FinishReason::null => {
            println!("Null");
        }
    }
    Ok(())
}

pub async fn audio_transcription( &self, req: AudioTranscriptionRequest ) -> Result<AudioTranscriptionResponse, APIError>

pub async fn audio_translation( &self, req: AudioTranslationRequest ) -> Result<AudioTranslationResponse, APIError>

pub async fn create_fine_tune( &self, req: CreateFineTuneRequest ) -> Result<CreateFineTuneResponse, APIError>

pub async fn list_fine_tune(&self) -> Result<ListFineTuneResponse, APIError>

pub async fn retrieve_fine_tune( &self, req: RetrieveFineTuneRequest ) -> Result<RetrieveFineTuneResponse, APIError>

pub async fn cancel_fine_tune( &self, req: CancelFineTuneRequest ) -> Result<CancelFineTuneResponse, APIError>

pub async fn list_fine_tune_events( &self, req: ListFineTuneEventsRequest ) -> Result<ListFineTuneEventsResponse, APIError>

pub async fn delete_fine_tune( &self, req: DeleteFineTuneModelRequest ) -> Result<DeleteFineTuneModelResponse, APIError>

pub async fn create_moderation( &self, req: CreateModerationRequest ) -> Result<CreateModerationResponse, APIError>