async openai

asynchronisé

Bibliothèque de rouille asynchrone pour Openai

_{Logo créé par ce repo lui-même}

Aperçu

async-openai est une bibliothèque de rouille non officielle pour Openai.

• Il est basé sur les spécifications Openai OpenAPI
• Caractéristiques actuelles:
  • Assistants (V2)
  • Audio
  • Lot
  • Chat
  • Complétions (héritage)
  • Incorporer
  • Fichiers
  • Réglage fin
  • Images
  • Modèles
  • Modérations
  • Organisations | Administration
  • Types d'API en temps réel (bêta)
  • Téléchargements
• SSE streaming sur les API disponibles
• Les demandes (sauf le streaming SSE), y compris les soumissions de formulaires, sont réactivées avec un revers exponentiel lorsque le taux est limité.
• Modèle de constructeur ergonomique pour tous les objets de demande.
• Service Microsoft Azure Openai (uniquement pour les API correspondant aux spécifications ouvertes)

Usage

La bibliothèque lit la touche API à partir de la variable d'environnement OPENAI_API_KEY .

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

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

• Visitez le répertoire des exemples sur la façon d'utiliser async-openai .
• Visitez les docs.rs/async-openai pour les documents.

API en temps réel

Seuls les types pour l'API en temps réel sont implémentés et peuvent être activés avec le drapeau de fonctionnalité realtime . Ces types peuvent changer si / quand OpenAI publie des spécifications officielles pour eux.

Exemple de génération d'images

 use async_openai :: {
    types :: { CreateImageRequestArgs , ImageSize , ImageResponseFormat } ,
    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 ( ImageResponseFormat :: 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 ( ( ) )
}

_{Échec pour ReadMe, taille réelle 256x256}

Contributif

Merci d'avoir pris le temps de contribuer et d'améliorer le projet. Je serais heureux de vous avoir!

Toutes les formes de contributions, telles que les nouvelles demandes de fonctionnalités, les corrections de bogues, les problèmes, la documentation, les tests, les commentaires, les exemples, etc. sont les bienvenues.

Un bon point de départ serait d'examiner les problèmes ouverts existants.

Pour maintenir la qualité du projet, un minimum des éléments suivants est un must pour la contribution du code:

• Noms et documentation : tous les noms de structure, les noms de champ et les commentaires DOC proviennent de la spécification OpenAPI. Les objets imbriqués dans SPEC sans noms laissent de la place pour faire le nom approprié.
• Testé : pour les modifications de support des tests et / ou de l'exemple est requis. Des exemples existants, des tests DOC, des tests unitaires et des tests d'intégration doivent être effectués pour fonctionner avec les modifications le cas échéant.
• Portée : Gardez la portée limitée aux API disponibles dans des documents officiels tels que la référence API ou les spécifications OpenAPI. D'autres LLM ou les fournisseurs d'IA proposent des API compatibles OpenAI, mais ils n'ont peut-être pas toujours de parité complète. Dans de tels cas, l'Openai Spec a priorité.
• Cohérence : garder le style de code cohérent dans toutes les "API" que la bibliothèque expose; Cela crée une grande expérience de développeur.

Ce projet adhère au code de conduite de la rouille

Caisses complémentaires

• Openai-Func-enums fournit des macros de procédure qui facilitent l'utilisation de cette bibliothèque avec la fonction d'appel à outils d'Openai API. Il fournit également des macros dérivés que vous pouvez ajouter aux sous-communs d'application CLAP existantes pour l'utilisation du langage naturel des outils de ligne de commande. Il prend également en charge les appels d'outils parallèles d'OpenAI et vous permet de choisir entre exécuter plusieurs appels d'outils simultanément ou posséder leurs propres threads OS.
• Async-openai-wasm fournit un soutien de WASM.

Licence

Ce projet est autorisé sous licence MIT.