openai-rs / openai-api Goto Github PK

A simple Rust library for OpenAI API, free from complex async operations and redundant dependencies.

License: MIT License

Rust 100.00%

chatgpt chatgpt-api openai openai-api rust

openai-api's Introduction

OpenAI API for Rust

A community-maintained library provides a simple and convenient way to interact with the OpenAI API. No complex async and redundant dependencies.

API

check official API reference

API	Support
Models	✔️
Completions	✔️
Chat	✔️
Images	✔️
Embeddings	✔️
Audio	✔️
Files	❌
Fine-tunes	❌
Moderations	❌
Engines	❌

Usage

Add the following to your Cargo.toml file:

openai_api_rust = "0.1.9"

Export your API key into the environment variables

export OPENAI_API_KEY=<your_api_key>

Then use the crate in your Rust code:

use openai_api_rust::*;
use openai_api_rust::chat::*;
use openai_api_rust::completions::*;

fn main() {
    // Load API key from environment OPENAI_API_KEY.
    // You can also hadcode through `Auth::new(<your_api_key>)`, but it is not recommended.
    let auth = Auth::from_env().unwrap();
    let openai = OpenAI::new(auth, "https://api.openai.com/v1/");
    let body = ChatBody {
        model: "gpt-3.5-turbo".to_string(),
        max_tokens: Some(7),
        temperature: Some(0_f32),
        top_p: Some(0_f32),
        n: Some(2),
        stream: Some(false),
        stop: None,
        presence_penalty: None,
        frequency_penalty: None,
        logit_bias: None,
        user: None,
        messages: vec![Message { role: Role::User, content: "Hello!".to_string() }],
    };
    let rs = openai.chat_completion_create(&body);
    let choice = rs.unwrap().choices;
    let message = &choice[0].message.as_ref().unwrap();
    assert!(message.content.contains("Hello"));
}

Use proxy

Load proxy from env

let openai = OpenAI::new(auth, "https://api.openai.com/v1/")
        .use_env_proxy();

Set the proxy manually

let openai = OpenAI::new(auth, "https://api.openai.com/v1/")
        .set_proxy("http://127.0.0.1:1080");

License

This library is distributed under the terms of the MIT license. See LICENSE for details.

openai-api's People

Contributors

Stargazers

Watchers

Forkers

datafuse-extras usamoi tensorchord devinleamy lowband21 sarath3192 akorchyn craigmayhew altiore ayourtch mokemokechicken szabgab sreeragit gqf2008

openai-api's Issues

EmbeddingData's field are private?

Hi there this crate is simple and great! I'm just wondering why EmbeddingData's fields are private here:

#[derive(Debug, Serialize, Deserialize)]
pub struct EmbeddingData {
	object: Option<String>,
	embedding: Option<Vec<f64>>,
	index: i32,
}

I would like to get the embedding vector directly.
PS: The link to the repo on the crate https://crates.io/crates/openai_api_rust is showing a 404, I think the link is different https://github.com/openai-rs/openapi-api

logit_bias is of type Option<HashMap<String, String>> in ChatBody

When a map of type HashMap<String, String> is passed for logit_bias, the following error results:

Error: API error: {"error":{"code":null,"message":"All values in 'logit_bias' must be reals, but found a <class 'str'>","param":"logit_bias","type":"invalid_request_error"}}. Trying again...

And obviously it won't compile if I try to pass any other type.

Add support for new embeddings options/parameters

https://platform.openai.com/docs/api-reference/embeddings/create

There is now an option for controlling the encoding format, and for the new v3 models, the dimensions of the vector. But the EmbeddingsBody doesn't have it

#[derive(Debug, Serialize, Deserialize)]
pub struct EmbeddingsBody {
	/// ID of the model to use. You can use the List models API to see all of your available models,
	/// or see our Model overview for descriptions of them.
	pub model: String,
	/// Input text to get embeddings for, encoded as a string or array of tokens. To get embeddings for multiple inputs in a single request,
	/// pass an array of strings or array of token arrays. Each input must not exceed 8192 tokens in length.
	pub input: Vec<String>,
	/// A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub user: Option<String>,
}

Thanks