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/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: String::from("NFTとは？"),
        }],
    };
    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("NFTとは？")),
        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 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("NFTとは？")),
        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>

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

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: String::from("NFTとは？"),
        }],
    };
    let result = client.chat_completion(req).await?;
    println!("{:?}", result.choices[0].message.content);

    Ok(())
}