async-openai

Async Rust library for OpenAI

_{Logo created by this repo itself}

Overview

async-openai is an unofficial Rust library for OpenAI REST API.

It's based on OpenAI OpenAPI spec
Current features:
- Audio
- Chat (including SSE streaming)
- Completions (including SSE streaming)
- Edits
- Embeddings
- Files
- Fine-Tuning (including SSE streaming)
- Images
- Microsoft Azure Endpoints / AD Authentication (see issue)
- Models
- Moderations
Non-streaming requests are retried with exponential backoff when rate limited by the API server.
Ergonomic Rust library with builder pattern for all request objects.

Being a young project there could be rough edges.

Usage

The library reads API key from the environment variable OPENAI_API_KEY.

# On macOS/Linux
export OPENAI_API_KEY='sk-...'

# On Windows Powershell
$Env:OPENAI_API_KEY='sk-...'

Visit examples directory on how to use async-openai.
Visit docs.rs/async-openai for docs.

Image Generation Example

use async_openai::{
    types::{CreateImageRequestArgs, ImageSize, ResponseFormat},
    Client,
};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // create client, reads OPENAI_API_KEY environment variable for API key.
    let client = Client::new();

    let request = CreateImageRequestArgs::default()
        .prompt("cats on sofa and carpet in living room")
        .n(2)
        .response_format(ResponseFormat::Url)
        .size(ImageSize::S256x256)
        .user("async-openai")
        .build()?;

    let response = client.images().create(request).await?;

    // Download and save images to ./data directory.
    // Each url is downloaded and saved in dedicated Tokio task.
    // Directory is created if it doesn't exist.
    let paths = response.save("./data").await?;

    paths
        .iter()
        .for_each(|path| println!("Image file path: {}", path.display()));

    Ok(())
}

_{Scaled up for README, actual size 256x256}

Contributing

Thank you for your time to contribute and improve the project, I'd be happy to have you!

A good starting point would be an open issue.

License