Téléchargement Easy open ai - Téléchargement Easy open ai

Ouverture facile de l'IA

Ce référentiel contient la bibliothèque maintenue par la communauté pour l'API OpenAI en Java, le moyen le plus simple d'utiliser GPT 3/4 dans vos applications.

Aperçu

Cette bibliothèque Java (bibliothèque maintenue par la communauté) offre un moyen pratique d'interagir avec l'API d'OpenAI pour la modération et la complétion du chat. La bibliothèque encapsule les détails nécessaires, facilitant l'intégration des puissants modèles d'OpenAI dans vos applications Java. Ce projet n'est pas maintenu par OPENAI, c'est une bibliothèque non officielle.

Table des matières

Dépendances

Instance unique

API de complétion de chat
API de modération
API Easy Vision ou API Vision (original fourni par OpenAI)
API vocale
API de transcription facile ou API de transcription (original fourni par OpenAI)
API de génération d'images également appelée API DALL-E

Asynchrone

API de complétion de chat asynchrone
API de modération asynchrone

Multi-asynchrone

API de complétion de chat asynchrone multithread
API de modération asynchrone multithread

Multi-Asynchrone-MultiKey

EMMC EasyOpenAI Multithread MultiKey ChatCompletionAPI

Lignes directrices de contribution

Veuillez vous référer à CONTRIBUTING.md

Directives de course

Tous les "OPENAI_KEYS" doivent être lus via la fonction readKeys() définie ici, cette fonction vous permet de lire plusieurs clés en même temps, et pour les tâches multithread, il est conseillé d'utiliser plusieurs clés pour éviter la limitation de débit. Pour exécuter cette fonction, vous devez avoir keys.txt dans le dossier racine de votre projet (n'hésitez pas à le modifier).

Utilisation - syntaxe

API de complétion de chat

Pour utiliser l'API Chat Completion, procédez comme suit :

 Message message = Message . builder ()
       . role ( "user" )
       . content ( "what is the capital of Cambodia?" )
       . build ();

List < Message > messages = new ArrayList <>();
messages . add ( message );

ChatCompletionRequest request = ChatCompletionRequest . builder ()
       . model ( "gpt-3.5-turbo" )
       . messages ( messages )
       . build ();

ChatCompletionResponse response = new EasyopenaiService ( new DAOImpl ()). chatCompletion ( "OPENAI_KEY" , request );

Cliquez ici pour accéder à l'exemple de code.

API de modération

Demande unique, réponse unique

Pour utiliser l'API de modération, procédez comme suit :

 ModerationAPIRequest request = ModerationAPIRequest . builder ()
        . model ( "text-moderation-latest" )
        . input ( "hello from the other side kill me now" )
        . build ();

ModerationAPIResponse res = new EasyopenaiService ( new DAOImpl ()). getmoderation ( "OPENAI_KEY" , request );

Cliquez ici pour accéder à l'exemple de code.

API Easy Vision

L'API Vision peut être utilisée comme ceci, n'hésitez pas à ajouter un nombre N d'images dans la liste des images.

 VisionApiResponse responseobj = new EasyVisionService (). VisionAPI ( "OPENAI_KEY" , new EasyVisionRequest ()
       . setModel ( "gpt-4-vision-preview" )
       . setPrompt ( "What are the difference between these images?" )
       . setImageUrls ( new ArrayList < String >() {{
           add ( "https://images.pexels.com/photos/268533/pexels-photo-268533.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=1" );
           add ( "https://images.pexels.com/photos/36717/amazing-animal-beautiful-beautifull.jpg?auto=compress&cs=tinysrgb&w=1260&h=750&dpr=1" );
       }}));

. setMaxtokens ( 1000 ) //Optional - for more tokens, defaults to 300

Cliquez ici pour accéder à l'exemple de code.

API Vision

Pour utiliser l'API Vision, procédez comme suit :

Initialisez l'objet EasyopenaiService avec une instance de DAOImpl :

 EasyopenaiService obj = new EasyopenaiService ( new DAOImpl ());

Créez un objet VisionApiRequest :

 VisionApiRequest request = new VisionApiRequest ();

Créez un objet ImageUrl avec l'URL et les détails de l'image :

 ImageUrl url = new ImageUrl ();
url . setUrl ( "https://images.pexels.com/photos/18907092/pexels-photo-18907092/free-photo-of-a-photo-of-the-golden-gate-bridge-in-the-sky.jpeg" );
url . setDetail ( "low" );

Créez une liste d'objets de contenu pour représenter les messages :

 Content content1 = new Content ();
content1 . setText ( "What’s in this image?" );
content1 . setType ( "text" );

Content content2 = new Content ();
content2 . setImageUrl ( url );
content2 . setType ( "image_url" );

ArrayList < Content > listofContent = new ArrayList <>();
listofContent . add ( content1 );
listofContent . add ( content2 );

Créez un objet MessageList avec le rôle ("user") et la liste de contenu :

 MessageList messageList = new MessageList ();
messageList . setRole ( "user" );
messageList . setContent ( listofContent );

Créez une liste d'objets MessageList :

 ArrayList < MessageList > listofMessage = new ArrayList <>();
listofMessage . add ( messageList );

Définissez diverses propriétés de l'objet VisionApiRequest :

 request . setModel ( "gpt-4-vision-preview" );
request . setMaxTokens ( 300 );
request . setMessages ( listofMessage );

Effectuez l'appel API et imprimez la réponse :

 VisionApiResponse res = obj . visionAPI ( OPENAI_KEY , request );
System . out . println ( "Vision API Response is:" + res );

Cliquez ici pour accéder à l'exemple de code.

API vocale

L'API vocale peut être utilisée comme ceci, n'hésitez pas à la modifier.

 SpeechRequest request = SpeechRequest . builder ()
       . model ( "tts-1" )
       . input ( "Easy OpenAI is best solution." )
       . voice ( "alloy" )
       . build ();

ResponseBody response = new EasyopenaiService ( new DAOImpl ()). createSpeech ( "OPENAI_KEY" , request );

Cliquez ici pour accéder à l'exemple de code.

API de transcription facile

L'API de transcription peut être utilisée comme ceci, n'hésitez pas à la modifier.

 EasyTranscriptionRequest request  =  EasyTranscriptionRequest . builder ()
      . filepath ( "/Users/namankhurpia/Desktop/audio.mp3" )
      . model ( "whisper-1" )
      . build ();

ResponseBody response = new EasyTranscriptionService (). EasyTranscription ( "OPENAI_KEY" , request );

Cliquez ici pour accéder à l'exemple de code.

API de transcription

API de transcription originale par OpenAI

L'API de transcription peut être utilisée comme ceci, n'hésitez pas à la modifier.

 File audioFile = new File ( "/Users/namankhurpia/Desktop/audio.mp3" );
MultipartBody . Part filePart = MultipartBody . Part . createFormData (
       "file" ,
       audioFile . getName (),
       RequestBody . create ( MediaType . parse ( "audio/*" ), audioFile )
);

RequestBody model = RequestBody . create ( MediaType . parse ( "text/plain" ), "whisper-1" );
RequestBody language = RequestBody . create ( MediaType . parse ( "text/plain" ), "" );
RequestBody prompt = RequestBody . create ( MediaType . parse ( "text/plain" ), "" );
RequestBody response_format = RequestBody . create ( MediaType . parse ( "text/plain" ), "" );
RequestBody temperature = RequestBody . create ( MediaType . parse ( "text/plain" ), "" );

ResponseBody response = new EasyopenaiService ( new DAOImpl ()). createTranscriptions ( "OPENAI_KEY" , filePart , model , language , prompt , response_format , temperature );

Cliquez ici pour accéder à l'exemple de code.

API de génération d'images

L'API de génération d'images peut être utilisée comme ceci, n'hésitez pas à la modifier.

 ImageRequest imageRequest  = ImageRequest . builder ()
       . prompt ( "Generate a cute dog playing with frizbee" )
       . model ( "dall-e-2" )
       . build ();

ImageResponse response = new EasyopenaiService ( new DAOImpl ()). createImage ( "OPENAI_KEY" , imageRequest );

Cliquez ici pour accéder à l'exemple de code.

API de complétion de chat asynchrone

Pour utiliser l'API Chat Completion de manière asynchrone, procédez comme suit :

Initialisez l'objet EasyopenaiAsyncService avec une instance de AsyncDAOImpl :

 EasyopenaiAsyncService obj = new EasyopenaiAsyncService ( new AsyncDAOImpl ());

Créez une liste d'objets ChatMessage pour représenter la conversation :

 ChatMessage message = new ChatMessage ();
message . setRole ( "user" );
message . setContent ( "what is the capital of Cambodia?" );

List < ChatMessage > messages = new ArrayList <>();
messages . add ( message );

Créez un objet ChatCompletionRequest :

 ChatCompletionRequest request = new ChatCompletionRequest ();
request . setModel ( "gpt-3.5-turbo" );
request . setMessages ( messages ); // old conversations as well

Effectuez l'appel d'API asynchrone :

 ChatCompletionResponse res = obj . getAsyncChatCompletion ( OPENAI_KEY , request );

Cliquez ici pour accéder à l'exemple de code.

API de modération asynchrone

Pour utiliser l'API de modération de manière asynchrone, procédez comme suit :

Créez un objet ModerationAPIRequest :

 ModerationAPIRequest request = new ModerationAPIRequest ();
request . setInput ( "kill me now" );
request . setModel ( "text-moderation-latest" );

Initialisez l'objet EasyopenaiAsyncService avec une instance de AsyncDAOImpl :

 EasyopenaiAsyncService obj = new EasyopenaiAsyncService ( new AsyncDAOImpl ());

Effectuez l'appel d'API asynchrone :

 ModerationAPIResponse res = obj . getASyncModeration ( OPENAI_KEY , request );

Cliquez ici pour accéder à l'exemple de code.

API de complétion de chat asynchrone multithread

Pour les appels multithreads et simultanés avec l'API Chat Completion, procédez comme suit :

Créez un objet ChatCompletionRequestList :

 ChatCompletionRequestList list = new ChatCompletionRequestList ( new ArrayList < ChatCompletionRequest >());

Ajoutez plusieurs objets ChatCompletionRequest à la liste :

 // Example request 1
ChatCompletionRequest requestchat = new ChatCompletionRequest ();
requestchat . setModel ( "gpt-3.5-turbo" );
ChatMessage message = new ChatMessage ();
message . setRole ( "user" );
message . setContent ( "what is the capital of India?" );
List < ChatMessage > messages = new ArrayList <>();
messages . add ( message );
requestchat . setMessages ( messages );
list . add ( requestchat );

// Add more requests as needed (requestchat2, requestchat3, requestchat4, etc.)

Effectuez l'appel d'API multi-asynchrone :

 EasyopenaiConcurrentService concurrentCalls = new EasyopenaiConcurrentService ();
ChatCompletionResponseList responseList = concurrentCalls . CallMultipleChatCompletionAPI ( OPENAI_KEY , list );
System . out . println ( responseList );

Cliquez ici pour accéder à l'exemple de code.

API de modération asynchrone multithread

Pour les appels multithreads et simultanés avec l'API de modération, procédez comme suit :

Créez un objet ModerationRequestList :

 ModerationRequestList requestList = new ModerationRequestList ( new ArrayList < ModerationAPIRequest >());

Ajoutez plusieurs objets ModerationAPIRequest à la liste :

 // Example request 1
ModerationAPIRequest request = new ModerationAPIRequest ();
request . setInput ( "kill me now" );
request . setModel ( "text-moderation-latest" );
requestList . add ( request );

// Add more requests as needed (request2, request3, request4, etc.)

Effectuez l'appel d'API multi-asynchrone :

 EasyopenaiConcurrentService concurrentCalls = new EasyopenaiConcurrentService ();
ModerationResponseList responseList = concurrentCalls . CallMultipleModerationAPI ( OPENAI_KEY , requestList );
System . out . println ( responseList );

Cliquez ici pour accéder à l'exemple de code.

EMMC EasyOpenAI Multithread MultiKey ChatCompletionAPI

Cela vous permet de passer plusieurs appels de fin de chat avec plusieurs touches. Tous les appels d'API sont exécutés en parallèle mais la réponse est activement collectée et renvoyée lorsque tous les threads sont terminés.

La classe CompleteableFuture a été utilisée pour l’implémentation. Veuillez vous référer au fichier EasyopenaiConcurrentService.java pour voir la source.

Exemple d'utilisation-

 public static void CallMultipleChatCompletionAPI_multikey_Test ()
{
     //this function read multiple keys from keys.txt file 
     ArrayList < String > keyList = readKeys ();
     
     EasyopenaiConcurrentService concurrentCalls = new EasyopenaiConcurrentService ();
   
     ChatCompletionRequestList list = new ChatCompletionRequestList ( new ArrayList < ChatCompletionRequest >());
   
     //First thread for 
     ChatCompletionRequest requestchat = new ChatCompletionRequest ();
     requestchat . setModel ( "gpt-3.5-turbo" );
     Message message = new Message ();
     message . setRole ( "user" );
     message . setContent ( "what is the capital of India?" );
     List < Message > messages = new ArrayList <>();
     messages . add ( message );
     requestchat . setMessages ( messages );
     list . add ( requestchat );
   
   
     ChatCompletionRequest requestchat2 = new ChatCompletionRequest ();
     requestchat2 . setModel ( "gpt-3.5-turbo" );
     Message message2 = new Message ();
     message2 . setRole ( "user" );
     message2 . setContent ( "what is the capital of combodia?" );
     List < Message > messages2 = new ArrayList <>();
     messages2 . add ( message2 );
     requestchat2 . setMessages ( messages2 );
     list . add ( requestchat2 );
   
   
     ChatCompletionRequest requestchat3 = new ChatCompletionRequest ();
     requestchat3 . setModel ( "gpt-3.5-turbo" );
     Message message3 = new Message ();
     message3 . setRole ( "user" );
     message3 . setContent ( "what is the capital of new zealand?" );
     List < Message > messages3 = new ArrayList <>();
     messages3 . add ( message3 );
     requestchat3 . setMessages ( messages3 );
     list . add ( requestchat3 );
   
   
     ChatCompletionRequest requestchat4 = new ChatCompletionRequest ();
     requestchat4 . setModel ( "gpt-3.5-turbo" );
     Message message4 = new Message ();
     message4 . setRole ( "user" );
     message4 . setContent ( "what is the capital of hawaii? and what is 2+2?" );
     List < Message > messages4 = new ArrayList <>();
     messages4 . add ( message4 );
     requestchat4 . setMessages ( messages4 );
     list . add ( requestchat4 );
   
   
   
     ChatCompletionResponseList responseList = concurrentCalls . CallMultipleChatCompletionAPI ( keyList , list );
     System . out . println ( "response is" + responseList );
}

Dépendances

Assurez-vous que les dépendances requises sont installées avant d'utiliser le wrapper de l'API OpenAI.

Maven

< dependency >
    < groupId >io.github.namankhurpia</ groupId >
    < artifactId >easyopenai</ artifactId >
    < version >x.x.x</ version >
</ dependency >

Groovy - Gradle

 implementation group: 'io.github.namankhurpia', name: 'easyopenai', version: 'x.x.x'

Gradle Java-

 implementation 'io.github.namankhurpia:easyopenai:x.x.x'

Gradle Kotlin-

 implementation("io.github.namankhurpia:easyopenai:x.x.x")

SBT-

 libraryDependencies += "io.github.namankhurpia" % "easyopenai" % "x.x.x"

Lierre-

 <dependency org="io.github.namankhurpia" name="easyopenai" rev="x.x.x"/>

Raisin-

 @Grapes(
@Grab(group='io.github.namankhurpia', module='easyopenai', version='x.x.x')
)

Leiningen

 [io.github.namankhurpia/easyopenai "x.x.x"]

Constructeur

 'io.github.namankhurpia:easyopenai:jar:x.x.x'

Développer