openai scala client
Version 1.1.0
Il s'agit d'un client asynchrone Scala sans fioritures pour l'API OpenAI prenant en charge tous les points de terminaison et paramètres disponibles , y compris le streaming , la nouvelle complétion de chat , la vision et les routines vocales (telles que définies ici), fournies dans un seul service pratique appelé OpenAservice. Les appels pris en charge sont:
Notez que pour être cohérent avec la dénomination de l'API OpenAI, les noms de fonction de service correspondent exactement aux titres / descriptions des points de terminaison de l'API avec CamelCase. De plus, nous avons visé la LIB à être autonome avec le moins de dépendances possible, nous avons fini par utiliser seulement deux libs play-ahc-ws-standalone et play-ws-standalone-json (au niveau supérieur). De plus, si une injection de dépendance est requise, nous utilisons également scala-guice Lib.
Pas le temps de lire un long tutoriel? Bien sûr, nous vous entendons! Consultez les exemples pour voir comment utiliser la LIB dans la pratique.
En plus de l'API OpenAI, cette bibliothèque prend également en charge les fournisseurs compatibles API (voir des exemples) tels que:
Pour des informations générales, lisez un article sur la lib / client sur Medium.
Essayez également notre base de données Scala Client pour Vector Pinecone ou utilisez les deux clients ensemble! Ce projet de démonstration montre comment générer et stocker des incorporations OpenAI (avec le modèle de text-embedding-ada-002 ) dans PineCone et les interroger par la suite. Le combo Openai + Pinecone est couramment utilisé pour les agents d'IA autonomes, tels que Babyagi et Autogpt.
✔️ IMPORTANT : Il s'agit d'une bibliothèque «entretenue par la communauté» et, en tant que telle, n'a aucun rapport avec Openai Company.
Les versions Scala actuellement prises en charge sont 2.12, 2.13 et 3 .
Pour installer la bibliothèque, ajoutez la dépendance suivante à votre build.sbt
"io.cequence" %% "openai-scala-client" % "1.1.0"
ou à pom.xml (si vous utilisez maven)
<dependency>
<groupId>io.cequence</groupId>
<artifactId>openai-scala-client_2.12</artifactId>
<version>1.1.0</version>
</dependency>
Si vous voulez une prise en charge de streaming, utilisez "io.cequence" %% "openai-scala-client-stream" % "1.1.0" à la place.
OPENAI_SCALA_CLIENT_API_KEY et éventuellement également OPENAI_SCALA_CLIENT_ORG_ID (si vous en avez un)I. Obtention d'OpenAiservice
Vous devez d'abord fournir un contexte d'exécution implicite ainsi que matérialiser Akka, par exemple, comme
implicit val ec = ExecutionContext .global
implicit val materializer = Materializer ( ActorSystem ())Ensuite, vous pouvez obtenir un service de l'une des manières suivantes.
Config variables env. val service = OpenAIServiceFactory () val config = ConfigFactory .load( " path_to_my_custom_config " )
val service = OpenAIServiceFactory (config) val service = OpenAIServiceFactory (
apiKey = " your_api_key " ,
orgId = Some ( " your_org_id " ) // if you have one
) val service = OpenAIServiceFactory .forAzureWithApiKey(
resourceName = " your-resource-name " ,
deploymentId = " your-deployment-id " , // usually model name such as "gpt-35-turbo"
apiVersion = " 2023-05-15 " , // newest version
apiKey = " your_api_key "
)OpenAICoreService minimal support listModels , createCompletion , createChatCompletion et createEmbeddings Calling - Fourni par exemple par le service FastChat fonctionnant sur le port 8000 val service = OpenAICoreServiceFactory ( " http://localhost:8000/v1/ " )OpenAIChatCompletionService fournissant uniquement createChatCompletion val service = OpenAIChatCompletionServiceFactory .forAzureAI(
endpoint = sys.env( " AZURE_AI_COHERE_R_PLUS_ENDPOINT " ),
region = sys.env( " AZURE_AI_COHERE_R_PLUS_REGION " ),
accessToken = sys.env( " AZURE_AI_COHERE_R_PLUS_ACCESS_KEY " )
)openai-scala-anthropic-client Lib et ANTHROPIC_API_KEY val service = AnthropicServiceFactory .asOpenAI()openai-scala-google-vertexai-client Lib et VERTEXAI_LOCATION + VERTEXAI_PROJECT_ID val service = VertexAIServiceFactory .asOpenAI()GROQ_API_KEY" val service = OpenAIChatCompletionServiceFactory ( ChatProviderSettings .groq)
// or with streaming
val service = OpenAIChatCompletionServiceFactory .withStreaming( ChatProviderSettings .groq)GROK_API_KEY" val service = OpenAIChatCompletionServiceFactory ( ChatProviderSettings .grok)
// or with streaming
val service = OpenAIChatCompletionServiceFactory .withStreaming( ChatProviderSettings .grok)FIREWORKS_API_KEY" val service = OpenAIChatCompletionServiceFactory ( ChatProviderSettings .fireworks)
// or with streaming
val service = OpenAIChatCompletionServiceFactory .withStreaming( ChatProviderSettings .fireworks)OCTOAI_TOKEN val service = OpenAIChatCompletionServiceFactory ( ChatProviderSettings .octoML)
// or with streaming
val service = OpenAIChatCompletionServiceFactory .withStreaming( ChatProviderSettings .octoML)TOGETHERAI_API_KEY val service = OpenAIChatCompletionServiceFactory ( ChatProviderSettings .togetherAI)
// or with streaming
val service = OpenAIChatCompletionServiceFactory .withStreaming( ChatProviderSettings .togetherAI)CEREBRAS_API_KEY val service = OpenAIChatCompletionServiceFactory ( ChatProviderSettings .cerebras)
// or with streaming
val service = OpenAIChatCompletionServiceFactory .withStreaming( ChatProviderSettings .cerebras)MISTRAL_API_KEY val service = OpenAIChatCompletionServiceFactory ( ChatProviderSettings .mistral)
// or with streaming
val service = OpenAIChatCompletionServiceFactory .withStreaming( ChatProviderSettings .mistral) val service = OpenAIChatCompletionServiceFactory (
coreUrl = " http://localhost:11434/v1/ "
)ou avec le streaming
val service = OpenAIChatCompletionServiceFactory .withStreaming(
coreUrl = " http://localhost:11434/v1/ "
)createCompletionStreamed et createChatCompletionStreamed fournis par OpenAStreamEdServiceExtra (nécessite une lib openai-scala-client-stream ) import io . cequence . openaiscala . service . StreamedServiceTypes . OpenAIStreamedService
import io . cequence . openaiscala . service . OpenAIStreamedServiceImplicits . _
val service : OpenAIStreamedService = OpenAIServiceFactory .withStreaming()De même pour un service de complétion de chat
import io . cequence . openaiscala . service . OpenAIStreamedServiceImplicits . _
val service = OpenAIChatCompletionServiceFactory .withStreaming(
coreUrl = " https://api.fireworks.ai/inference/v1/ " ,
authHeaders = Seq (( " Authorization " , s " Bearer ${sys.env( " FIREWORKS_API_KEY " )} " ))
)ou seulement si le streaming est requis
val service : OpenAIChatCompletionStreamedServiceExtra =
OpenAIChatCompletionStreamedServiceFactory (
coreUrl = " https://api.fireworks.ai/inference/v1/ " ,
authHeaders = Seq (( " Authorization " , s " Bearer ${sys.env( " FIREWORKS_API_KEY " )} " ))
)openai-scala-guice ) class MyClass @ Inject () ( openAIService : OpenAIService ) {...}Ii Fonctions d'appel
La documentation complète de chaque appel avec ses entrées et paramètres respectifs est fournie dans OpenAiservice. Étant donné que tous les appels sont asynchrones, ils renvoient des réponses enveloppées à Future .
Il existe un nouveau projet Openai-Scala-Client-Examples où vous pouvez trouver de nombreux exemples prêts à l'emploi!
service.listModels.map(models =>
models.foreach(println)
) service.retrieveModel( ModelId .text_davinci_003).map(model =>
println(model.getOrElse( " N/A " ))
) val text = """ Extract the name and mailing address from this email:
|Dear Kelly,
|It was great to talk to you at the seminar. I thought Jane's talk was quite good.
|Thank you for the book. Here's my address 2111 Ash Lane, Crestview CA 92002
|Best,
|Maya
""" .stripMargin
service.createCompletion(text).map(completion =>
println(completion.choices.head.text)
) val text = """ Extract the name and mailing address from this email:
|Dear Kelly,
|It was great to talk to you at the seminar. I thought Jane's talk was quite good.
|Thank you for the book. Here's my address 2111 Ash Lane, Crestview CA 92002
|Best,
|Maya
""" .stripMargin
service.createCompletion(
text,
settings = CreateCompletionSettings (
model = ModelId .gpt_4o,
max_tokens = Some ( 1500 ),
temperature = Some ( 0.9 ),
presence_penalty = Some ( 0.2 ),
frequency_penalty = Some ( 0.2 )
)
).map(completion =>
println(completion.choices.head.text)
) val source = service.createCompletionStreamed(
prompt = " Write me a Shakespeare poem about two cats playing baseball in Russia using at least 2 pages " ,
settings = CreateCompletionSettings (
model = ModelId .text_davinci_003,
max_tokens = Some ( 1500 ),
temperature = Some ( 0.9 ),
presence_penalty = Some ( 0.2 ),
frequency_penalty = Some ( 0.2 )
)
)
source.map(completion =>
println(completion.choices.head.text)
).runWith( Sink .ignore) Pour que cela fonctionne, vous devez utiliser OpenAIServiceStreamedFactory à partir de la lib openai-scala-client-stream .
val createChatCompletionSettings = CreateChatCompletionSettings (
model = ModelId .gpt_4o
)
val messages = Seq (
SystemMessage ( " You are a helpful assistant. " ),
UserMessage ( " Who won the world series in 2020? " ),
AssistantMessage ( " The Los Angeles Dodgers won the World Series in 2020. " ),
UserMessage ( " Where was it played? " ),
)
service.createChatCompletion(
messages = messages,
settings = createChatCompletionSettings
).map { chatCompletion =>
println(chatCompletion.choices.head.message.content)
} val messages = Seq (
SystemMessage ( " You are a helpful assistant. " ),
UserMessage ( " What's the weather like in San Francisco, Tokyo, and Paris? " )
)
// as a param type we can use "number", "string", "boolean", "object", "array", and "null"
val tools = Seq (
FunctionSpec (
name = " get_current_weather " ,
description = Some ( " Get the current weather in a given location " ),
parameters = Map (
" type " - > " object " ,
" properties " - > Map (
" location " - > Map (
" type " - > " string " ,
" description " - > " The city and state, e.g. San Francisco, CA "
),
" unit " - > Map (
" type " - > " string " ,
" enum " - > Seq ( " celsius " , " fahrenheit " )
)
),
" required " - > Seq ( " location " )
)
)
)
// if we want to force the model to use the above function as a response
// we can do so by passing: responseToolChoice = Some("get_current_weather")`
service.createChatToolCompletion(
messages = messages,
tools = tools,
responseToolChoice = None , // means "auto"
settings = CreateChatCompletionSettings ( ModelId .gpt_3_5_turbo_1106)
).map { response =>
val chatFunCompletionMessage = response.choices.head.message
val toolCalls = chatFunCompletionMessage.tool_calls.collect {
case (id, x : FunctionCallSpec ) => (id, x)
}
println(
" tool call ids : " + toolCalls.map(_._1).mkString( " , " )
)
println(
" function/tool call names : " + toolCalls.map(_._2.name).mkString( " , " )
)
println(
" function/tool call arguments : " + toolCalls.map(_._2.arguments).mkString( " , " )
)
} val messages = Seq (
SystemMessage ( " Give me the most populous capital cities in JSON format. " ),
UserMessage ( " List only african countries " )
)
val capitalsSchema = JsonSchema . Object (
properties = Map (
" countries " - > JsonSchema . Array (
items = JsonSchema . Object (
properties = Map (
" country " - > JsonSchema . String (
description = Some ( " The name of the country " )
),
" capital " - > JsonSchema . String (
description = Some ( " The capital city of the country " )
)
),
required = Seq ( " country " , " capital " )
)
)
),
required = Seq ( " countries " )
)
val jsonSchemaDef = JsonSchemaDef (
name = " capitals_response " ,
strict = true ,
structure = schema
)
service
.createChatCompletion(
messages = messages,
settings = DefaultSettings .createJsonChatCompletion(jsonSchemaDef)
)
.map { response =>
val json = Json .parse(messageContent(response))
println( Json .prettyPrint(json))
}createChatCompletions ou createChatFunCompletions , cela vous aide à sélectionner un modèle approprié et à réduire les coûts. Il s'agit d'une fonctionnalité expérimentale et cela peut ne pas fonctionner pour tous les modèles. Nécessite une lib openai-scala-count-tokens .Un exemple comment compter les jetons de message:
import io . cequence . openaiscala . service . OpenAICountTokensHelper
import io . cequence . openaiscala . domain .{ AssistantMessage , BaseMessage , FunctionSpec , ModelId , SystemMessage , UserMessage }
class MyCompletionService extends OpenAICountTokensHelper {
def exec = {
val model = ModelId .gpt_4_turbo_2024_04_09
// messages to be sent to OpenAI
val messages : Seq [ BaseMessage ] = Seq (
SystemMessage ( " You are a helpful assistant. " ),
UserMessage ( " Who won the world series in 2020? " ),
AssistantMessage ( " The Los Angeles Dodgers won the World Series in 2020. " ),
UserMessage ( " Where was it played? " ),
)
val tokenCount = countMessageTokens(model, messages)
}
}Un exemple comment compter les jetons de message lorsqu'une fonction est impliquée:
import io . cequence . openaiscala . service . OpenAICountTokensHelper
import io . cequence . openaiscala . domain .{ BaseMessage , FunctionSpec , ModelId , SystemMessage , UserMessage }
class MyCompletionService extends OpenAICountTokensHelper {
def exec = {
val model = ModelId .gpt_4_turbo_2024_04_09
// messages to be sent to OpenAI
val messages : Seq [ BaseMessage ] =
Seq (
SystemMessage ( " You are a helpful assistant. " ),
UserMessage ( " What's the weather like in San Francisco, Tokyo, and Paris? " )
)
// function to be called
val function : FunctionSpec = FunctionSpec (
name = " getWeather " ,
parameters = Map (
" type " - > " object " ,
" properties " - > Map (
" location " - > Map (
" type " - > " string " ,
" description " - > " The city to get the weather for "
),
" unit " - > Map ( " type " - > " string " , " enum " - > List ( " celsius " , " fahrenheit " ))
)
)
)
val tokenCount = countFunMessageTokens(model, messages, Seq (function), Some (function.name))
}
} ✔️ IMPORTANT : Une fois que vous avez terminé l'utilisation du service, vous devez le fermer en appelant service.close . Sinon, les ressources / threads sous-jacents ne seront pas publiés.
Iii. Utilisation des adaptateurs
Les adaptateurs des services OpenAI (complétion de chat, noyau ou complet) sont fournis par OpenAiServiceAdapters. Les adaptateurs sont utilisés pour distribuer la charge entre plusieurs services, réessayer sur les erreurs transitoires, l'itinéraire ou fournir des fonctionnalités supplémentaires. Voir des exemples pour plus de détails.
Notez que les adaptateurs peuvent être arbitrairement combinés / empilés.
val adapters = OpenAIServiceAdapters .forFullService
val service1 = OpenAIServiceFactory ( " your-api-key1 " )
val service2 = OpenAIServiceFactory ( " your-api-key2 " )
val service = adapters.roundRobin(service1, service2) val adapters = OpenAIServiceAdapters .forFullService
val service1 = OpenAIServiceFactory ( " your-api-key1 " )
val service2 = OpenAIServiceFactory ( " your-api-key2 " )
val service = adapters.randomOrder(service1, service2) val adapters = OpenAIServiceAdapters .forFullService
val rawService = OpenAIServiceFactory ()
val service = adapters.log(
rawService,
" openAIService " ,
logger.log
) val adapters = OpenAIServiceAdapters .forFullService
implicit val retrySettings : RetrySettings = RetrySettings (maxRetries = 10 ).constantInterval( 10 .seconds)
val service = adapters.retry(
OpenAIServiceFactory (),
Some (println(_)) // simple logging
) class MyCompletionService @ Inject () (
val actorSystem : ActorSystem ,
implicit val ec : ExecutionContext ,
implicit val scheduler : Scheduler
)( val apiKey : String )
extends RetryHelpers {
val service : OpenAIService = OpenAIServiceFactory (apiKey)
implicit val retrySettings : RetrySettings =
RetrySettings (interval = 10 .seconds)
def ask ( prompt : String ) : Future [ String ] =
for {
completion < - service
.createChatCompletion(
List ( MessageSpec ( ChatRole . User , prompt))
)
.retryOnFailure
} yield completion.choices.head.message.content
} val adapters = OpenAIServiceAdapters .forFullService
// OctoAI
val octoMLService = OpenAIChatCompletionServiceFactory (
coreUrl = " https://text.octoai.run/v1/ " ,
authHeaders = Seq (( " Authorization " , s " Bearer ${sys.env( " OCTOAI_TOKEN " )} " ))
)
// Anthropic
val anthropicService = AnthropicServiceFactory .asOpenAI()
// OpenAI
val openAIService = OpenAIServiceFactory ()
val service : OpenAIService =
adapters.chatCompletionRouter(
// OpenAI service is default so no need to specify its models here
serviceModels = Map (
octoMLService - > Seq ( NonOpenAIModelId .mixtral_8x22b_instruct),
anthropicService - > Seq (
NonOpenAIModelId .claude_2_1,
NonOpenAIModelId .claude_3_opus_20240229,
NonOpenAIModelId .claude_3_haiku_20240307
)
),
openAIService
) val adapters = OpenAIServiceAdapters .forCoreService
val service = adapters.chatToCompletion(
OpenAICoreServiceFactory (
coreUrl = " https://api.fireworks.ai/inference/v1/ " ,
authHeaders = Seq (( " Authorization " , s " Bearer ${sys.env( " FIREWORKS_API_KEY " )} " ))
)
)Wen Scala 3?
Février 2023. Vous avez raison; Nous avons choisi le mois le plus court pour le faire :) Fait!
J'ai eu une exception de temps mort. Comment puis-je modifier le paramètre de délai d'expiration?
Vous pouvez le faire soit en passant les timeouts Param à OpenAIServiceFactory ou, si vous utilisez votre propre fichier de configuration, vous pouvez simplement l'ajouter là-bas comme:
openai-scala-client {
timeouts {
requestTimeoutSec = 200
readTimeoutSec = 200
connectTimeoutSec = 5
pooledConnectionIdleTimeoutSec = 60
}
}
J'ai une exception comme com.typesafe.config.ConfigException$UnresolvedSubstitution: openai-scala-client.conf @ jar:file:.../io/cequence/openai-scala-client_2.13/0.0.1/openai-scala-client_2.13-0.0.1.jar!/openai-scala-client.conf: 4: Could not resolve substitution to a value: ${OPENAI_SCALA_CLIENT_API_KEY} . Que dois-je faire?
Définissez l'env. variable OPENAI_SCALA_CLIENT_API_KEY . Si vous n'avez pas un registre ici.
Tout a l'air cool. Je veux discuter avec vous de votre recherche et développement?
Il suffit de nous envoyer un e-mail à [email protected].
Cette bibliothèque est disponible et publiée sous forme d'open source aux termes de la licence MIT.
Ce projet est open-source et accueille toute contribution ou rétroaction (ici).
Le développement de cette bibliothèque a été soutenu par - CEQUENCE.IO - The future of contracting
Créé et entretenu par Peter Banda.
