OpenAIKit
Patch
Un SDK Swift que mantiene la comunidad para la API Operai.
Informe de error · Función de solicitud
OpenAikit es un SDK Swift impulsado por la comunidad diseñado para proporcionar a los desarrolladores Swift una forma perfecta, eficiente y rápida de interactuar con el punto final de reposo de OpenAI. Nuestro objetivo es reducir la barrera para los desarrolladores rápidos, permitiéndoles integrar el poder de OpenAi en sus aplicaciones sin profundizar en las complejidades de los servicios RESTful.
Con la creciente demanda de características con IA en aplicaciones modernas, es crucial que los desarrolladores tengan acceso a herramientas que simplifican el proceso de integración. Si bien Operai ofrece un increíble conjunto de capacidades, había una clara necesidad de un SDK rápido dedicado que se alinee con las prácticas idiomáticas del lenguaje y las expectativas de la comunidad de desarrolladores de Swift.
Imaginamos una herramienta que no solo proporciona acceso en bruto a las funcionalidades de OpenAI, sino que también mejora la experiencia del desarrollador con una API clara e intuitiva. Nuestro objetivo final es fomentar la innovación al proporcionar a la comunidad rápida las herramientas adecuadas para integrar las capacidades de IA en sus aplicaciones sin esfuerzo.
| Plataforma | Versión mínima de Swift | Instalación | Estado |
|---|---|---|---|
| iOS 13.0+ / macOS 10.15+ / tvos 13.0+ / watchos 6.0+ / visionos 1.0+ | 5.7 | Administrador de paquetes Swift | Totalmente probado |
El Swift Package Manager permite a los desarrolladores integrar fácilmente los paquetes en sus proyectos y paquetes XCode; y también está completamente integrado en el compilador swift .
https://github.com/OpenDive/OpenAIKit.git Una vez que tenga su paquete Swift configurado, agregue el enlace GIT dentro del valor dependencies de su archivo Package.swift .
dependencies: [
. package ( url : " https://github.com/OpenDive/OpenAIKit.git " , . upToNextMajor ( from : " 2.0.1 " ) )
] Para obtener una clave API, vaya a su página de API Keys en la página de su cuenta aquí.
️ ? IMPORTANTE: ¡No almacene las teclas API de OpenAI directamente en código! ?️ Cuando se trabaja con la API de Openai, es esencial por razones de seguridad no incorporar sus claves API directamente dentro de la base de código de su aplicación. Incrustar las claves directamente en su código fuente puede exponerlas a usuarios no autorizados y actores maliciosos, lo que lleva a un mal uso potencial.
Las mejores prácticas:
- Variables de entorno: almacene sus claves API en las variables de entorno y acceda a ellas en su código. De esta manera, no están codificados en su aplicación y se pueden administrar de forma segura.
- Gestión de secretos: use una herramienta o servicio de gestión de secretos seguros para almacenar y recuperar sus claves API. Herramientas como AWS Secrets Manager, Hashicorp Vault, Firebase, CloudKit o Azure Key Vault están diseñados para almacenar, administrar y recuperar datos confidenciales. De esta manera, el usuario no tiene acceso en el dispositivo a las claves.
- .Gitignore: si almacena sus claves API en un archivo de configuración, siempre asegúrese de que este archivo se agregue a
.gitignoreo un mecanismo similar para evitar que se comprometa accidentalmente con un sistema de control de fuente.- Gire regularmente las teclas: gire sus teclas API periódicamente para mitigar el impacto potencial de una fuga.
Recuerde, la seguridad es de suma importancia. ¡Siempre priorice el manejo seguro de información confidencial como las teclas API!
Para obtener más información, consulte este artículo sobre la gestión de clave API para desarrolladores de Swift.
Sumérjase en la próxima evolución de la generación de imágenes con AI con Dall-E 2 (y próximamente, Dall-E 3), traída a usted por OpenAI. Sobre la base del legado de su predecesor, Dall-E 2 ofrece capacidades mejoradas para materializar imágenes intrincadas a partir de indicaciones textuales, creando un puente perfecto entre el lenguaje y las imágenes. Los desarrolladores pueden aprovechar esta innovadora tecnología para enriquecer las experiencias de los usuarios, crear contenido dinámico e inspirar nuevas vías de creatividad. Revolucione sus aplicaciones y proyectos integrando el poder de vanguardia de Dall-E 2.
OpenAI proporciona tres puntos finales para interactuar con Dall -E 2: - createImage es el punto final principal que permite la generación directa de imágenes a partir de un mensaje de texto. Aquí hay un ejemplo sobre cómo usar el punto final, junto con la salida de correlación:
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 | Mascarilla | Editar |
- createImageVariation permite al desarrollador crear variaciones de una imagen de entrada dada. Aquí hay un ejemplo sobre cómo usar el punto final, junto con la salida de correlación:
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 | Variación |
ChatGPT, basado en la arquitectura GPT-4 de OpenAI, es un modelo de IA conversacional de vanguardia. Proporciona a los desarrolladores una herramienta robusta para integrar las capacidades avanzadas de procesamiento del lenguaje natural en las aplicaciones. El uso de ChatGPT puede mejorar las interacciones del usuario, mejorar la eficiencia y ofrecer soluciones impulsadas por IA en varios casos de uso. Incorpore la fuerza de GPT-4 en sus proyectos para obtener resultados tangibles.
Hay un solo punto final para esta característica, sin embargo, este SDK divide el punto final en dos funciones con tres características separadas en total: - generateChatCompletion permite al desarrollador generar completaciones de chat utilizando los modelos proporcionados desde OpenAI; o los modelos finosos de propiedad del desarrollador. Aquí hay un ejemplo sobre cómo usar el punto final, junto con la salida de correlación:
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
)
)
)
El desarrollador también puede usar llamadas de funciones para ejecutar varias funciones (es decir, obtener información meteorológica, cargar archivos, etc.). Aquí hay un ejemplo sobre cómo usar el parámetro, la respuesta correspondiente y el uso del ejemplo con una función local.
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 permite que el desarrollo transmitir datos de finalización de chat desde el punto final. Aquí hay un ejemplo sobre cómo usar el punto final, junto con la salida de correlación:
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 es el modelo AI de voz a texto de OpenAi, diseñado para una transcripción precisa de contenido hablado. Al convertir el audio en texto, ofrece a los desarrolladores una herramienta directa para tareas como servicios de transcripción, comandos de voz, traducciones de lenguaje vocal o indexación de audio. La implementación de Whisper puede ayudar a simplificar los procesos, hacer que las aplicaciones sean más accesibles y aprovechar los datos de voz de manera eficiente.
Existen los dos puntos finales principales que usan el modelo Whisper: - createTranscription es el punto final principal que permite a los desarrolladores transcribir el audio hablado al texto. Aquí hay un ejemplo sobre cómo usar el punto final y el elemento devuelto correspondiente:
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 es el segundo punto final que permite a los desarrolladores traducir cualquier audio no inglés en texto de inglés transcrito. Aquí hay un ejemplo sobre cómo usar el punto final y el elemento devuelto correspondiente:
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.
Las integridades utilizan los modelos GPT de OpenAI para generar densas representaciones vectoriales para el texto. Estas incrustaciones capturan información semántica, lo que permite a los desarrolladores realizar tareas como la búsqueda de similitud, la agrupación o el ajuste fino en tareas específicas. Al integrar las integridades de GPT en aplicaciones, los desarrolladores pueden mejorar el análisis de texto y las capacidades de recuperación, lo que lleva a un procesamiento y información de datos más efectivos.
Aquí hay un ejemplo sobre cómo usarlo y la salida esperada para el punto final:
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
)
)
El punto final de modelos permite a los desarrolladores obtener los modelos actualmente disponibles de OpenAI, junto con sus propios modelos ajustados.
Hay dos puntos finales disponibles para su uso con esta característica:
listModels obtiene la lista completa de modelos que ava al desarrollador. Aquí hay un uso de ejemplo, junto con la salida correspondiente: 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 RECUESTA un solo modelo, dada la ID del modelo de entrada. Aquí hay un uso de ejemplo, junto con la salida correspondiente: 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"
)
A partir del 6 de julio de 2023, OpenAI ha anunciado la deprecación de los modelos más antiguos en la API de finalización, que se jubilará a principios de 2024. Se recomienda hacer la transición a la API de finalización de chat que proporciona una interfaz rápida más estructurada y capacidades de conversación múltiple. La API de finalización de chat ha demostrado manejar una gran mayoría de los casos de uso anteriores y las nuevas necesidades de conversación con una mayor flexibilidad y especificidad, mejorando significativamente la experiencia del desarrollador. Para obtener más detalles, consulte el anuncio oficial.
A partir de 2.x, los modelos de finalización de chat usan enums para etiquetar cada modelo disponible para el uso principal de modelos predeterminados. Aquí hay un ejemplo sobre cómo migrar al usar el inicializador anterior para ChatParameter al inicializador para 2.x:
// 1.x implementation
let chatParameters = ChatParameters ( model : " gpt4 " , messages : chat )
// ✅ 2.x implementation
let chatParameters = ChatParameters ( model : . gpt4 , messages : chat ) Si necesita una cadena personalizada para modelos ajustados, use el parámetro customModel :
// ✅ 2.x implementation for custom model IDs
let chatParameters = ChatParameters ( customModel : " INSERT-MODEL-ID " , message : chat ) (TBD)
Damos la bienvenida a cualquiera que contribuya al proyecto a través de problemas de publicación, si se encuentran con cualquier error / falla mientras usa OpenAikit; Y también con la creación de problemas de extracción que agregan características adicionales a OpenAikit.
OpenAikit se lanza bajo la licencia MIT, y cualquier uso del punto final REST de OpenAI estará bajo las políticas de uso establecidas por ellos.
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.
