OpenAIKit
Patch
Un SDK Swift entretenu dans la communauté pour l'API OpenAI.
RAPPORT BUG · Fonction de demande
Openaikit est un SDK Swift axé sur la communauté conçu pour fournir aux développeurs Swift une manière transparente, efficace et époustouflante d'interagir avec le point de terminaison d'Openai. Notre objectif est de réduire la barrière pour les développeurs Swift, leur permettant d'intégrer la puissance d'OpenAI dans leurs applications sans approfondir les subtilités des services Restful.
Avec la demande croissante de fonctionnalités alimentées par l'IA dans les applications modernes, il est crucial que les développeurs aient accès à des outils qui simplifient le processus d'intégration. Alors qu'Openai offre une incroyable suite de capacités, il y avait un besoin clair pour un SDK Swift dédié qui s'aligne sur les pratiques idiomatiques de la langue et les attentes de la communauté des développeurs Swift.
Nous avons imaginé un outil qui non seulement fournit un accès brut aux fonctionnalités OpenAI, mais améliore également l'expérience du développeur avec une API claire et intuitive. Notre objectif ultime est de favoriser l'innovation en fournissant à la communauté rapide les bons outils pour intégrer les capacités d'IA dans leurs applications sans effort.
| Plate-forme | Version rapide | Installation | Statut |
|---|---|---|---|
| iOS 13.0+ / macOs 10.15+ / tvos 13.0+ / watchos 6.0+ / visionos 1.0+ | 5.7 | Swift Package Manager | Entièrement testé |
Le Swift Package Manager permet aux développeurs d'intégrer facilement des packages dans leurs projets et packages Xcode; et est également entièrement intégré dans le compilateur swift .
https://github.com/OpenDive/OpenAIKit.git Une fois que vous avez configuré votre package SWIFT, ajoutez le lien GIT dans la valeur dependencies de votre fichier Package.swift .
dependencies: [
. package ( url : " https://github.com/OpenDive/OpenAIKit.git " , . upToNextMajor ( from : " 2.0.1 " ) )
] Pour obtenir une clé API, accédez à votre page API Keys sur votre page de compte ici.
️ ? IMPORTANT: Ne stockez pas les clés API OpenAI directement dans le code! ?️ Lorsque vous travaillez avec l'API d'OpenAI, il est essentiel pour des raisons de sécurité de ne pas intégrer vos clés API directement dans la base de code de votre application. L'intégration des clés directement dans votre code source peut les exposer aux utilisateurs non autorisés et aux acteurs malveillants, conduisant à une mauvaise utilisation potentielle.
Meilleures pratiques:
- Variables d'environnement: stockez vos clés API dans les variables environnementales et accédez-y dans votre code. De cette façon, ils ne sont pas codés en dur dans votre application et peuvent être gérés en toute sécurité.
- Secrets Management: Utilisez un outil ou un service de gestion des secrets sécurisés pour stocker et récupérer vos clés API. Des outils comme AWS Secrets Manager, Hashicorp Vault, Firebase, CloudKit ou Azure Key Vault sont conçus pour stocker, gérer et récupérer des données sensibles. De cette façon, l'utilisateur n'a pas d'accès à disposition aux clés.
- .gitignore: Si vous stockez vos clés API dans un fichier de configuration, assurez-vous toujours que ce fichier est ajouté à
.gitignoreou à un mécanisme similaire pour empêcher qu'il ne soit accidentellement engagé dans un système de contrôle source.- Tournez régulièrement les touches: tournez périodiquement vos clés d'API pour atténuer l'impact potentiel d'une fuite.
N'oubliez pas que la sécurité est de la plus haute importance. Priorisez toujours la manipulation sûre des informations sensibles comme les clés de l'API!
Pour plus d'informations, consultez cet article sur la gestion des clés de l'API pour les développeurs Swift.
Plongez dans la prochaine évolution de la génération d'images propulsée par l'AI avec Dall-E 2 (et à venir bientôt, Dall-E 3), apportée par Openai. S'appuyant sur l'héritage de son prédécesseur, Dall-E 2 offre des capacités améliorées pour matérialiser des visuels complexes à partir d'invites textuelles, créant un pont transparent entre la langue et l'imagerie. Les développeurs peuvent exploiter cette technologie révolutionnaire pour enrichir les expériences des utilisateurs, fabriquer un contenu dynamique et inspirer de nouvelles avenues de créativité. Révolutionnez vos applications et projets en intégrant la puissance de pointe de Dall-E 2.
Il y a trois points de terminaison fournis par OpenAI pour interagir avec Dall-E 2: - createImage est le point de terminaison principal qui permet une génération d'image directe à partir d'une invite de texte. Voici un exemple sur la façon d'utiliser le point de terminaison, ainsi que la sortie corrélative:
do {
let imageParam = ImageParameters (
// A text description of the desired image(s).
prompt : " An armchair in the shape of an avocado " ,
// The size of the generated images.
resolution : . large ,
// The format in which the generated images are returned.
responseFormat : . base64Json
)
let result = try await openAi . createImage (
parameters : imageParam
)
let b64Image = result . data [ 0 ] . image
let image = try openAi . decodeBase64Image ( b64Image )
} catch {
// Insert your own error handling method here.
} 
do {
let imageEditParam = try ImageEditParameters (
// The image to edit.
image : image ,
// An additional image whose fully transparent areas indicate where image should be edited.
mask : mask ,
// A text description of the desired image(s).
prompt : " The Mona Lisa wearing a beret, in the style of Leonardo DaVinci " ,
// The size of the generated images.
resolution : . large ,
// The format in which the generated images are returned.
responseFormat : . base64Json
)
let imageResponse = try await openAI . generateImageEdits (
parameters : imageEditParam
)
let image = try openAI . decodeBase64Image ( imageResponse . data [ 0 ] . image )
} catch {
// Insert your own error handling method here.
}  |  |  |
|---|---|---|
| Original | Masque | Modifier |
- createImageVariation permet au développeur de créer des variations d'une image d'entrée donnée. Voici un exemple sur la façon d'utiliser le point de terminaison, ainsi que la sortie corrélative:
do {
let imageVariationParam = try ImageVariationParameters (
// The image to use as the basis for the variation(s).
image : image ,
// The size of the generated images.
resolution : . large ,
// The format in which the generated images are returned.
responseFormat : . base64Json
)
let variationResponse = try await openAI . generateImageVariations (
parameters : imageVariationParam
)
self . image = try openAI . decodeBase64Image (
variationResponse . data [ 0 ] . image
)
} catch {
// Insert your own error handling method here.
}  |  |
|---|---|
| Original | Variation |
Chatgpt, construit sur l'architecture GPT-4 d'OpenAI, est un modèle d'IA conversationnel de pointe. Il fournit aux développeurs un outil robuste pour intégrer les capacités avancées de traitement du langage naturel dans les applications. L'utilisation de ChatGpt peut améliorer les interactions des utilisateurs, améliorer l'efficacité et offrir des solutions axées sur l'IA dans divers cas d'utilisation. Incorporez la force de GPT-4 dans vos projets pour les résultats tangibles.
Il existe un seul point de terminaison pour cette fonctionnalité, cependant, ce SDK divisait le point de terminaison en deux fonctions avec trois fonctionnalités distinctes au total: - generateChatCompletion permet au développeur de générer des compléments de chat en utilisant les modèles fournis d'OpenAI; ou les modèles finaux bien réglés par le développeur. Voici un exemple sur la façon d'utiliser le point de terminaison, ainsi que la sortie corrélative:
do {
let chat : [ ChatMessage ] = [
ChatMessage ( role : . system , content : " You are a helpful assistant. " ) ,
ChatMessage ( role : . user , content : " Who won the world series in 2020? " ) ,
ChatMessage ( role : . assistant , content : " The Los Angeles Dodgers won the World Series in 2020. " ) ,
ChatMessage ( role : . user , content : " Where was it played? " )
]
let chatParameters = ChatParameters (
model : . gpt4 , // ID of the model to use.
messages : chat // A list of messages comprising the conversation so far.
)
let chatCompletion = try await openAI . generateChatCompletion (
parameters : chatParameters
)
if let message = chatCompletion . choices [ 0 ] . message {
let content = message . content
}
} catch {
// Insert your own error handling method here.
} ChatResponse(
id: "chatcmpl-88eG5VruffcNHPNVGBKGVAV5HGk4j",
object: OpenAIKit.OpenAIObject.chatCompletion,
created: 1697072069,
choices: [
OpenAIKit.ChatChoice(
message: Optional(
OpenAIKit.ChatMessage(
id: "250FDA2D-2F38-4E6F-B97E-DAD74FED1FB6",
role: OpenAIKit.ChatRole.assistant,
content: Optional(
"The 2020 World Series was played at Globe Life Field in Arlington, Texas."
),
functionCall: nil
)
),
delta: nil,
index: 0,
logprobs: nil,
finishReason: Optional("stop")
)
],
usage: Optional(
OpenAIKit.Usage(
promptTokens: 53,
completionTokens: 17,
totalTokens: 70
)
)
)
Le développeur est également en mesure d'utiliser des appels de fonction pour exécuter diverses fonctions (c'est-à-dire, récupérer les informations météorologiques, télécharger des fichiers, etc.). Voici un exemple sur la façon d'utiliser le paramètre, la réponse correspondante et l'utilisation de l'exemple avec une fonction locale.
do {
let functions : [ Function ] = [
Function (
name : " getCurrentWeather " ,
description : " Get the current weather in a given location " ,
parameters : Parameters (
type : " object " ,
properties : [
" location " : ParameterDetail (
type : " string " ,
description : " The city and state, e.g. San Francisco, CA "
) ,
" unit " : ParameterDetail (
type : " string " , enumValues : [ " fahrenheit " , " celsius " ]
)
] ,
required : [ " location " ]
)
)
]
let messages : [ ChatMessage ] = [
ChatMessage ( role : . user , content : " What's the weather like in Boston? " )
]
let chatParameters = ChatParameters (
model : . gpt4 , // ID of the model to use.
messages : messages , // A list of messages comprising the conversation so far.
functionCall : " auto " , // Controls how the model calls functions.
functions : functions // A list of functions the model may generate JSON inputs for.
)
let chatCompletion = try await openAI . generateChatCompletion (
parameters : chatParameters
)
} catch {
// Insert your own error handling method here.
} ChatResponse(
id: "chatcmpl-88eVjsHEPtDDiSEuCexsqO8iuhnfG",
object: OpenAIKit.OpenAIObject.chatCompletion,
created: 1697073039,
choices: [
OpenAIKit.ChatChoice(
message: Optional(
OpenAIKit.ChatMessage(
id: "DCE5EECB-9521-481D-9E75-C7FF9390E4CF",
role: OpenAIKit.ChatRole.assistant,
content: nil,
functionCall: Optional(
OpenAIKit.FunctionCall(
arguments: "{n"location": "Boston, MA"n}",
name: "getCurrentWeather"
)
)
)
),
delta: nil,
index: 0,
logprobs: nil,
finishReason: Optional("function_call")
)
],
usage: Optional(OpenAIKit.Usage(promptTokens: 81, completionTokens: 16, totalTokens: 97))
)
func getCurrentWeather ( location : String , unit : TemperatureUnit = . fahrenheit ) -> WeatherInfo {
return WeatherInfo ( location : location , temperature : " 72 " , unit : unit , forecast : [ " sunny " , " windy " ] )
}
if let message = chatCompletion . choices [ 0 ] . message , let functionCall = message . functionCall {
let jsonString = functionCall . arguments
if let data = jsonString . data ( using : . utf8 ) {
do {
if
let json = try JSONSerialization . jsonObject ( with : data , options : [ ] ) as? [ String : Any ] ,
let location = json [ " location " ] as? String
{
self . weatherInfo = self . getCurrentWeather ( location : location )
}
} catch {
// Insert your own error handling method here.
}
}
} - generateChatCompletionStreaming permet au développement de diffuser des données de complétion de chat à partir du point de terminaison. Voici un exemple sur la façon d'utiliser le point de terminaison, ainsi que la sortie corrélative:
do {
let chat : [ ChatMessage ] = [
ChatMessage ( role : . system , content : " You are a helpful assistant. " ) ,
ChatMessage ( role : . user , content : " Who won the world series in 2020? " ) ,
ChatMessage ( role : . assistant , content : " The Los Angeles Dodgers won the World Series in 2020. " ) ,
ChatMessage ( role : . user , content : " Where was it played? " )
]
let chatParameters = ChatParameters ( model : . chatGPTTurbo , messages : chat )
let stream = try openAI . generateChatCompletionStreaming (
parameters : chatParameters
)
} catch {
// Insert your own error handling method here.
} ChatResponse(
id: "chatcmpl-88enklY0vmc4fNkM1mJQCkzW6hcST",
object: OpenAIKit.OpenAIObject.chatCompletionChunk,
created: 1697074156,
choices: [
OpenAIKit.ChatChoice(
message: nil,
delta: Optional(
OpenAIKit.ChatDelta(
role: Optional(OpenAIKit.ChatRole.assistant),
content: Optional("")
)
),
index: 0,
logprobs: nil,
finishReason: nil
)
],
usage: nil
)
ChatResponse(
id: "chatcmpl-88enklY0vmc4fNkM1mJQCkzW6hcST",
object: OpenAIKit.OpenAIObject.chatCompletionChunk,
created: 1697074156,
choices: [
OpenAIKit.ChatChoice(
message: nil,
delta: Optional(
OpenAIKit.ChatDelta(
role: nil,
content: Optional("The")
)
),
index: 0,
logprobs: nil,
finishReason: nil
)
],
usage: nil
)
// ...
ChatResponse(
id: "chatcmpl-88enklY0vmc4fNkM1mJQCkzW6hcST",
object: OpenAIKit.OpenAIObject.chatCompletionChunk,
created: 1697074156,
choices: [
OpenAIKit.ChatChoice(
message: nil,
delta: Optional(
OpenAIKit.ChatDelta(
role: nil,
content: Optional(".")
)
),
index: 0,
logprobs: nil,
finishReason: nil
)
],
usage: nil
)
ChatResponse(
id: "chatcmpl-88enklY0vmc4fNkM1mJQCkzW6hcST",
object: OpenAIKit.OpenAIObject.chatCompletionChunk,
created: 1697074156,
choices: [
OpenAIKit.ChatChoice(
message: nil,
delta: Optional(
OpenAIKit.ChatDelta(
role: nil,
content: nil
)
),
index: 0,
logprobs: nil,
finishReason: Optional("stop")
)
],
usage: nil
)
Whisper est le modèle d'IA de la parole d'Openai, conçu pour une transcription précise du contenu parlé. En convertissant l'audio en texte, il offre aux développeurs un outil simple pour des tâches telles que les services de transcription, les commandes vocales, les traductions de langage vocal ou l'indexation audio. La mise en œuvre de Whisper peut aider à rationaliser les processus, à rendre les applications plus accessibles et à tirer parti des données vocales efficacement.
Il y a les deux principaux points de terminaison qui utilisent le modèle Whisper: - createTranscription est le principal point de terminaison qui permet aux développeurs de transcrire l'audio parlé en texte. Voici un exemple sur la façon d'utiliser le point de terminaison et l'élément retourné correspondant:
do {
let audioParameters = TranscriptionParameters ( file : audio )
let transcriptionCompletion = try await openAI . createTranscription ( parameters : audioParameters )
} catch {
// Insert your own error handling method here.
} Arousing from the most profound of slumbers, we break the gossamer web of some dream. Yet in a second afterward, so frail may that web have been, we remember not that we have dreamed. In the return to life
from the swoon there are two stages, first, that of the sense of mental or spiritual, secondly, that of the sense of physical existence. It seems probable that if, upon reaching the second stage, we could
recall the impressions of the first, we should find these impressions eloquent in memories of the gulf beyond. And that gulf is what? How at least shall we distinguish its shadows from those of the tomb?
- createTranslation est le deuxième point de terminaison qui permet aux développeurs de traduire tout audio non anglais en texte anglais transcrit. Voici un exemple sur la façon d'utiliser le point de terminaison et l'élément retourné correspondant:
do {
let audioParameters = TranscriptionParameters ( file : audio )
let transcriptionCompletion = try await openAI . createTranslation ( parameters : audioParameters )
} catch {
// Insert your own error handling method here.
} In the night, when I was out of my mind, and I, pained, numb and tired, thought about the beauty and goodness of a long-forgotten lesson, and my head began to shake, I suddenly heard something tick that scared
me out of my sleep. Who could it be in that weather? A visitor is knocking, I thought, at my room in that weather. That's all it is, and nothing more.
Les intégres utilisent les modèles GPT d'OpenAI pour générer des représentations vectorielles denses pour le texte. Ces intégres capturent des informations sémantiques, permettant aux développeurs d'effectuer des tâches telles que la recherche de similitude, le regroupement ou le réglage fin sur des tâches spécifiques. En intégrant les incorporations GPT dans les applications, les développeurs peuvent améliorer l'analyse du texte et la récupération des capacités, conduisant à un traitement et à des informations plus efficaces.
Voici un exemple sur la façon de l'utiliser et la sortie attendue pour le point de terminaison:
do {
let embeddingsParam = EmbeddingsParameters ( model : " text-similarity-ada-002 " , input : input )
self . embeddingsResponse = try await openAI . createEmbeddings ( parameters : embeddingsParam )
} catch {
// Insert your own error handling method here.
} OpenAIKit.EmbeddingsResponse(
object: OpenAIKit.OpenAIObject.list,
data: [
OpenAIKit.EmbeddingsData(
object: OpenAIKit.OpenAIObject.embedding,
embedding: [
0.0028667077,
0.018867997,
-0.030135695,
// ...
-0.004177677,
-0.015615467,
-0.008131327
],
index: 0
)
],
model: "text-similarity-ada:002",
usage: OpenAIKit.EmbeddingsUsage(
promptTokens: 8,
totalTokens: 8
)
)
Le point de terminaison des modèles permet aux développeurs de récupérer les modèles actuellement disponibles d'OpenAI, ainsi que leurs propres modèles affinés.
Il y a deux points de terminaison disponibles pour une utilisation avec cette fonction:
listModels récupère la liste complète des modèles Avaialbe au développeur. Voici un exemple d'utilisation, ainsi que la sortie correspondante: do {
let modelsResponse = try await openAi . listModels ( )
} catch {
// Insert your own error handling method here.
} ListModelResponse(
object: OpenAIKit.OpenAIObject.list,
data: [
OpenAIKit.Model(
id: "text-search-babbage-doc-001",
object: OpenAIKit.OpenAIObject.model,
created: 1651172509,
ownedBy: "openai-dev"
),
OpenAIKit.Model(
id: "curie-search-query",
object: OpenAIKit.OpenAIObject.model,
created: 1651172509,
ownedBy: "openai-dev"
),
OpenAIKit.Model(
id: "text-search-babbage-query-001",
object: OpenAIKit.OpenAIObject.model,
created: 1651172509,
ownedBy: "openai-dev"
),
OpenAIKit.Model(
id: "babbage",
object: OpenAIKit.OpenAIObject.model,
created: 1649358449,
ownedBy: "openai"
),
OpenAIKit.Model(
id: "gpt-3.5-turbo-instruct-0914",
object: OpenAIKit.OpenAIObject.model,
created: 1694122472,
ownedBy: "system"
)
// ...
]
)
retrieveModels récupère un seul modèle, étant donné l'ID du modèle d'entrée. Voici un exemple d'utilisation, ainsi que la sortie correspondante: do {
let model = try await openAI . retrieveModel ( modelId : " text-davinci-001 " )
} catch {
// Insert your own error handling method here.
} OpenAIKit.Model(
id: "text-davinci-001",
object: OpenAIKit.OpenAIObject.model,
created: 1649364042,
ownedBy: "openai"
)
Depuis le 6 juillet 2023, OpenAI a annoncé la dépréciation des anciens modèles de l'API Complétion, qui devraient prendre sa retraite au début de 2024. Il est fortement recommandé de passer à l'API de complétion de chat qui offre une interface rapide plus structurée et des capacités de conversation multipur. L'API de CHAT Completions s'est avérée gérer une grande majorité des cas d'utilisation antérieurs et de nouveaux besoins conversationnels avec une plus grande flexibilité et spécificité, améliorant considérablement l'expérience du développeur. Pour plus de détails, reportez-vous à l'annonce officielle.
En tant que 2.x, les modèles de complétion de chat utilisent des énumérations pour étiqueter chaque modèle disponible pour l'utilisation principale des modèles par défaut. Voici un exemple sur la façon de migrer de l'utilisation de l'ancien initialiseur pour ChatParameter vers l'initialiseur pour 2.x:
// 1.x implementation
let chatParameters = ChatParameters ( model : " gpt4 " , messages : chat )
// ✅ 2.x implementation
let chatParameters = ChatParameters ( model : . gpt4 , messages : chat ) Si vous avez besoin d'une chaîne personnalisée pour les modèles affinés, utilisez le paramètre customModel :
// ✅ 2.x implementation for custom model IDs
let chatParameters = ChatParameters ( customModel : " INSERT-MODEL-ID " , message : chat ) (TBD)
Nous nous réjouissons de quiconque à contribuer au projet par le biais de problèmes de publication, s'il rencontre des bugs / pépins lors de l'utilisation d'Openaikit; Et également avec la création de problèmes de traction qui ajoutent toutes les fonctionnalités supplémentaires à Openaikit.
Openaikit est publié sous la licence MIT, et toute utilisation du point de terminaison de repos d'Openai sera sous les politiques d'utilisation définies par eux.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
