OpenAIKit
Patch
Um SWIFT SDK mantido comunitário para a API Openai.
Relatório Bug · Recurso de solicitação
O OpenAikit é um SDK SWIFT, orientado à comunidade, projetado para fornecer aos desenvolvedores Swift uma maneira perfeita, eficiente e rápida de interagir com o terminal de descanso do OpenAI. Nosso objetivo é diminuir a barreira para os desenvolvedores SWIFT, permitindo que eles integrem o poder do OpenAI em seus aplicativos sem se aprofundar nos meandros dos serviços repousantes.
Com a crescente demanda por recursos movidos a IA em aplicações modernas, é crucial que os desenvolvedores tenham acesso a ferramentas que simplificam o processo de integração. Enquanto o OpenAI oferece um conjunto incrível de capacidades, havia uma clara necessidade de um SDK SWIFT dedicado que se alinha às práticas idiomáticas do idioma e com as expectativas da comunidade de desenvolvedores SWIFT.
Prevemos uma ferramenta que não apenas fornece acesso bruto às funcionalidades do OpenAI, mas também aprimora a experiência do desenvolvedor com uma API clara e intuitiva. Nosso objetivo final é promover a inovação, fornecendo à comunidade SWIFT as ferramentas certas para integrar os recursos de IA em seus aplicativos sem esforço.
| Plataforma | Versão Swift mínima | Instalação | Status |
|---|---|---|---|
| iOS 13.0+ / macOS 10.15+ / tvOS 13.0+ / watchOS 6.0+ / Visionos 1.0+ | 5.7 | Gerente de pacotes Swift | Totalmente testado |
O Swift Package Manager permite que os desenvolvedores integrem facilmente pacotes em seus projetos e pacotes Xcode; e também está totalmente integrado ao compilador swift .
https://github.com/OpenDive/OpenAIKit.git Depois de configurar seu pacote SWIFT, adicione o link Git no valor de dependencies do seu arquivo Package.swift .
dependencies: [
. package ( url : " https://github.com/OpenDive/OpenAIKit.git " , . upToNextMajor ( from : " 2.0.1 " ) )
] Para obter uma chave da API, vá para sua página API Keys na página da sua conta aqui.
️ ? IMPORTANTE: Não armazene as teclas API OpenAI diretamente no código! ?️ Ao trabalhar com a API do OpenAI, é essencial para razões de segurança não incorporar suas teclas de API diretamente na base de código do seu aplicativo. A incorporação de chaves diretamente no seu código -fonte pode expô -las a usuários não autorizados e atores maliciosos, levando a potencial uso indevido.
Melhores práticas:
- Variáveis de ambiente: armazene suas teclas de API em variáveis de ambiente e acesse -as em seu código. Dessa forma, eles não são codificados em seu aplicativo e podem ser gerenciados com segurança.
- Gerenciamento de segredos: use uma ferramenta ou serviço de gerenciamento de segredos seguros para armazenar e recuperar suas chaves da API. Ferramentas como o AWS Secrets Manager, Hashicorp Vault, Firebase, CloudKit ou Azure Key Vault foram projetadas para armazenar, gerenciar e recuperar dados confidenciais. Dessa forma, o usuário não tem acesso no dispositivo às chaves.
- .gitignore: Se você armazenar suas teclas de API em um arquivo de configuração, sempre verifique se esse arquivo é adicionado ao
.gitignoreou a um mecanismo semelhante para impedir que ele seja acidentalmente comprometido com um sistema de controle de origem.- Gire regularmente as teclas: gire as teclas da API periodicamente para mitigar o impacto potencial de um vazamento.
Lembre -se, a segurança é de extrema importância. Sempre priorize o manuseio seguro de informações confidenciais, como as chaves da API!
Para obter mais informações, consulte este artigo sobre gerenciamento de chaves da API para desenvolvedores SWIFT.
Mergulhe na próxima evolução da geração de imagens movidas a IA com Dall-e 2 (e em breve, Dall-e 3), trazido a você pelo Openai. Com base no legado de seu antecessor, o Dall-E 2 oferece recursos aprimorados para materializar visuais intrincados a partir de instruções textuais, criando uma ponte perfeita entre linguagem e imagens. Os desenvolvedores podem aproveitar essa tecnologia inovadora para enriquecer as experiências do usuário, criar conteúdo dinâmico e inspirar novos caminhos de criatividade. Revolucione seus aplicativos e projetos, integrando o poder de ponta do Dall-E 2.
Existem três pontos de extremidade fornecidos pelo OpenAI para interagir com o Dall -e 2: - createImage é o principal terminal que permite a geração de imagem direta de um prompt de texto. Aqui está um exemplo de como usar o terminal, juntamente com a saída correlacionada:
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 | Máscara | Editar |
- createImageVariation permite que o desenvolvedor crie variações de uma determinada imagem de entrada. Aqui está um exemplo de como usar o terminal, juntamente com a saída correlacionada:
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 | Variação |
O ChatGPT, construído na arquitetura GPT-4 da OpenAI, é um modelo de IA de conversação de ponta. Ele fornece aos desenvolvedores uma ferramenta robusta para integrar recursos avançados de processamento de linguagem natural em aplicativos. O uso do ChatGPT pode aprimorar as interações do usuário, melhorar a eficiência e oferecer soluções orientadas a IA em vários casos de uso. Incorpore a força do GPT-4 em seus projetos para obter resultados tangíveis.
Há um único ponto final para esse recurso, no entanto, este SDK divide o terminal em duas funções com três recursos separados no total: - generateChatCompletion permite que o desenvolvedor gere conclusões de bate -papo usando os modelos fornecidos do OpenAI; ou os modelos finos ajustados do desenvolvedor. Aqui está um exemplo de como usar o terminal, juntamente com a saída correlacionada:
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
)
)
)
O desenvolvedor também pode usar chamadas de função para executar várias funções (ou seja, buscar informações climáticas, fazer upload de arquivos etc.). Aqui está um exemplo de como usar o parâmetro, a resposta correspondente e o uso de exemplo com uma função 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 o desenvolvimento de dados de conclusão de bate -papo do ponto de extremidade. Aqui está um exemplo de como usar o terminal, juntamente com a saída correlacionada:
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 é o modelo de IA de fala para texto do OpenAI, projetado para uma transcrição precisa do conteúdo falado. Ao converter áudio em texto, oferece aos desenvolvedores uma ferramenta direta para tarefas como serviços de transcrição, comandos de voz, traduções de idiomas vocais ou indexação de áudio. A implementação do Whisper pode ajudar a simplificar os processos, tornar os aplicativos mais acessíveis e aproveitar os dados de voz com eficiência.
Existem os dois pontos finais principais que usam o modelo Whisper: - createTranscription é o principal ponto final que permite aos desenvolvedores transcrever o áudio falado para o texto. Aqui está um exemplo de como usar o endpoint e o item retornado correspondente:
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 é o segundo ponto final que permite aos desenvolvedores traduzir qualquer áudio não inglês em texto em inglês transcrito. Aqui está um exemplo de como usar o endpoint e o item retornado correspondente:
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.
As incorporações utilizam os modelos GPT da OpenAI para gerar representações vetoriais densas para o texto. Essas incorporações capturam informações semânticas, permitindo que os desenvolvedores executem tarefas como pesquisa de similaridade, clustering ou ajuste fino em tarefas específicas. Ao integrar incorporações GPT em aplicativos, os desenvolvedores podem aprimorar a análise de texto e os recursos de recuperação, levando a um processamento e insights de dados mais eficazes.
Aqui está um exemplo de como usá -lo e a saída esperada para o terminal:
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
)
)
O ponto de extremidade dos modelos permite que os desenvolvedores busquem os modelos atualmente disponíveis do OpenAI, juntamente com seus próprios modelos ajustados.
Existem dois terminais disponíveis para uso com este recurso:
listModels busca toda a lista de modelos AVAIALBE para o desenvolvedor. Aqui está um exemplo de uso, juntamente com a saída correspondente: 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 busca um único modelo, dado o ID do modelo de entrada. Aqui está um exemplo de uso, juntamente com a saída correspondente: 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"
)
Em 6 de julho de 2023, o OpenAI anunciou a depreciação dos modelos mais antigos na API de conclusão, que deve se aposentar no início de 2024. É altamente recomendável fazer a transição para a API de conclusão de bate-papo, que fornece uma interface rápida mais estruturada e recursos de conversação multirurna. A API de conclusão de bate -papo provou lidar com uma grande maioria dos casos de uso anteriores e novas necessidades de conversação com maior flexibilidade e especificidade, aumentando significativamente a experiência do desenvolvedor. Para mais detalhes, consulte o anúncio oficial.
A partir do 2.x, os modelos de conclusão de bate -papo usam enum para rotular cada modelo disponível para o principal uso dos modelos padrão. Aqui está um exemplo de como migrar de usar o inicializador mais antigo para ChatParameter para o Inicializador para 2.x:
// 1.x implementation
let chatParameters = ChatParameters ( model : " gpt4 " , messages : chat )
// ✅ 2.x implementation
let chatParameters = ChatParameters ( model : . gpt4 , messages : chat ) Se você precisar de uma string personalizada para modelos de ajuste fino, use o parâmetro customModel :
// ✅ 2.x implementation for custom model IDs
let chatParameters = ChatParameters ( customModel : " INSERT-MODEL-ID " , message : chat ) (TBD)
Congratulamo -nos com qualquer um que contribua para o projeto através de problemas de publicação, se encontrarem bugs / falhas enquanto usam o OpenAikit; e também com a criação de problemas de tração que adicionam recursos adicionais ao OpenAikit.
O OpenAikit é liberado sob a licença do MIT, e qualquer uso do endpoint de repouso do OpenAI estará sob as políticas de uso definidas por eles.
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.
