openai java
Assistant API
️ AVIS: Ce projet n'est plus maintenu et a été archivé au 6 juin 2024. Merci à tous ceux qui ont contribué et soutenu ce projet. Bien que le référentiel restera disponible dans son état actuel, aucune autre mise à jour ou support ne sera fourni. N'hésitez pas à se nourrir et à modifier le code au besoin.
️ OpenAI a obsolète toutes les API basées sur le moteur. Voir les points de terminaison obsolètes ci-dessous pour plus d'informations.
Bibliothèques Java pour utiliser les API GPT d'Openai. Prend en charge GPT-3, Chatgpt et GPT-4.
Comprend les artefacts suivants:
api : demande / réponse POJOS pour les API GPT.client : un client de modernisation de base pour les points de terminaison GPT, comprend le module apiservice : une classe de service de base qui crée et appelle le client. C'est le moyen le plus simple de commencer.ainsi qu'un exemple de projet utilisant le service.
implementation 'com.theokanning.openai-gpt3-java:<api|client|service>:<version>'
< dependency >
< groupId >com.theokanning.openai-gpt3-java</ groupId >
< artifactId >{api|client|service}</ artifactId >
< version >version</ version >
</ dependency > Si vous souhaitez créer votre propre client, importez simplement les Pojos à partir du module api . Votre client devra utiliser Snake Case pour travailler avec l'API OpenAI.
Si vous utilisez Retrofit, vous pouvez importer le module client et utiliser l'Openaiapi.
Vous devrez ajouter votre jeton AUTH en tant qu'en-tête (voir AuthenticationInterceptor) et définir votre usine de convertisseur pour utiliser Snake Case et inclure uniquement des champs non nuls.
Si vous recherchez la solution la plus rapide, importez le module service et utilisez OpenAiService.
️ L'OpenAiService dans le module client est obsolète, veuillez passer à la nouvelle version dans le module de service.
OpenAiService service = new OpenAiService ( "your_token" );
CompletionRequest completionRequest = CompletionRequest . builder ()
. prompt ( "Somebody once told me the world is gonna roll me" )
. model ( "babbage-002" ")
. echo ( true )
. build ();
service . createCompletion ( completionRequest ). getChoices (). forEach ( System . out :: println );Si vous avez besoin de personnaliser OpenAiService, créez votre propre client Retrofit et transmettez-le au constructeur. Par exemple, procédez comme suit pour ajouter la journalisation de la demande (après avoir ajouté la dépendance de la bogdle):
ObjectMapper mapper = defaultObjectMapper ();
OkHttpClient client = defaultClient ( token , timeout )
. newBuilder ()
. interceptor ( HttpLoggingInterceptor ())
. build ();
Retrofit retrofit = defaultRetrofit ( client , mapper );
OpenAiApi api = retrofit . create ( OpenAiApi . class );
OpenAiService service = new OpenAiService ( api );Pour utiliser un proxy, modifiez le client OKHTTP comme indiqué ci-dessous:
ObjectMapper mapper = defaultObjectMapper ();
Proxy proxy = new Proxy ( Proxy . Type . HTTP , new InetSocketAddress ( host , port ));
OkHttpClient client = defaultClient ( token , timeout )
. newBuilder ()
. proxy ( proxy )
. build ();
Retrofit retrofit = defaultRetrofit ( client , mapper );
OpenAiApi api = retrofit . create ( OpenAiApi . class );
OpenAiService service = new OpenAiService ( api );Vous pouvez créer vos fonctions et définir facilement leurs exécuteurs en utilisant la classe ChatFunction, ainsi que l'une de vos classes personnalisées qui serviront à définir leurs paramètres disponibles. Vous pouvez également traiter les fonctions avec facilité, à l'aide d'un exécuteur testamentaire appelé FunctionExecutor.
Nous déclarons d'abord nos paramètres de fonction:
public class Weather {
@ JsonPropertyDescription ( "City and state, for example: León, Guanajuato" )
public String location ;
@ JsonPropertyDescription ( "The temperature unit, can be 'celsius' or 'fahrenheit'" )
@ JsonProperty ( required = true )
public WeatherUnit unit ;
}
public enum WeatherUnit {
CELSIUS , FAHRENHEIT ;
}
public static class WeatherResponse {
public String location ;
public WeatherUnit unit ;
public int temperature ;
public String description ;
// constructor
}Ensuite, nous déclarons la fonction elle-même et l'associons à un exécuteur testamentaire, dans cet exemple, nous ferons simuler une réponse d'une API:
ChatFunction . builder ()
. name ( "get_weather" )
. description ( "Get the current weather of a location" )
. executor ( Weather . class , w -> new WeatherResponse ( w . location , w . unit , new Random (). nextInt ( 50 ), "sunny" ))
. build ()Ensuite, nous utilisons l'objet FunctionExEcutor du module «Service» pour aider à l'exécution et à la transformation en un objet prêt pour la conversation:
List < ChatFunction > functionList = // list with functions
FunctionExecutor functionExecutor = new FunctionExecutor ( functionList );
List < ChatMessage > messages = new ArrayList <>();
ChatMessage userMessage = new ChatMessage ( ChatMessageRole . USER . value (), "Tell me the weather in Barcelona." );
messages . add ( userMessage );
ChatCompletionRequest chatCompletionRequest = ChatCompletionRequest
. builder ()
. model ( "gpt-3.5-turbo-0613" )
. messages ( messages )
. functions ( functionExecutor . getFunctions ())
. functionCall ( new ChatCompletionRequestFunctionCall ( "auto" ))
. maxTokens ( 256 )
. build ();
ChatMessage responseMessage = service . createChatCompletion ( chatCompletionRequest ). getChoices (). get ( 0 ). getMessage ();
ChatFunctionCall functionCall = responseMessage . getFunctionCall (); // might be null, but in this case it is certainly a call to our 'get_weather' function.
ChatMessage functionResponseMessage = functionExecutor . executeAndConvertToMessageHandlingExceptions ( functionCall );
messages . add ( response );Remarque: La classe
FunctionExecutorfait partie du module «Service».
Vous pouvez également créer votre propre exécuteur de fonction. L'objet de retour de ChatFunctionCall.getArguments() est un jsonNode pour la simplicité et devrait être en mesure de vous aider.
Pour un aspect plus approfondi, reportez-vous à un exemple conversationnel qui utilise des fonctions dans: openaiapifonctionsexample.java. Ou pour un exemple utilisant des fonctions et du flux: OpenaiapifonctionwithStreamExample.java
Si vous souhaitez arrêter votre processus immédiatement après les réponses en streaming, appelez OpenAiService.shutdownExecutor() .
Ce n'est pas nécessaire pour les appels non streaming.
Tout l'exemple du projet nécessite est votre jeton API OpenAI
export OPENAI_TOKEN= " sk-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX "Vous pouvez essayer toutes les capacités de ce projet en utilisant:
./gradlew runExampleOneEt vous pouvez également essayer la nouvelle capacité d'utilisation des fonctions:
./gradlew runExampleTwoOu fonctions avec le mode «Stream» activé:
./gradlew runExampleThree Oui! GPT-4 utilise l'API ChatCompletion et vous pouvez voir les dernières options de modèle ici.
GPT-4 est actuellement dans une version bêta limitée (au 4/1/23), alors assurez-vous d'avoir accès avant d'essayer de l'utiliser.
Absolument! Il est très facile d'utiliser vos propres fonctions sans se soucier de faire le sale boulot. Comme mentionné ci-dessus, vous pouvez vous référer à Openaiapifunctionsexample.java ou openaiapifunctionwithstreamExample.java projets pour un exemple.
Assurez-vous qu'Openai est disponible dans votre pays.
De nombreux projets utilisent OpenAiService et pour les soutenir mieux, je l'ai gardé extrêmement simple.
Vous pouvez créer votre propre instance Openaiapi pour personnaliser les en-têtes, les délais d'expiration, les URL de base, etc.
Si vous souhaitez des fonctionnalités telles que RETRY LOGIC et ASYNC CAMPS, vous devrez faire une instance OpenAiApi et l'appeler directement au lieu d'utiliser OpenAiService
OpenAI a obsolète des points de terminaison basés sur le moteur en faveur des points de terminaison basés sur un modèle. Par exemple, au lieu d'utiliser v1/engines/{engine_id}/completions , passez à v1/completions et spécifiez le modèle dans le CompletionRequest . Le code comprend des instructions de mise à niveau pour tous les points de terminaison obsolètes.
Je ne supprimerai pas les anciens points de terminaison de cette bibliothèque jusqu'à ce qu'Openai les ferme.
Publié sous la licence MIT
