OpenAIKit
Patch
Ein in der Gemeinde gepflegter Swift SDK für die OpenAI-API.
Melden Sie Fehler an · Anfrage -Feature
Openaikit ist ein von der Gemeinde betriebenes Swift SDK, das Swift-Entwicklern eine nahtlose, effiziente und schicke Möglichkeit bietet, mit dem OpenAI-REST-Endpunkt zu interagieren. Unser Ziel ist es, die Barriere für schnelle Entwickler zu senken und sie zu ermöglichen, die Kraft von OpenAI in ihre Apps zu integrieren, ohne tief in die Feinheiten erholsamer Dienste einzubeziehen.
Angesichts der zunehmenden Nachfrage nach KI-angetriebenen Funktionen in modernen Anwendungen ist es für Entwickler von entscheidender Bedeutung, Zugriff auf Tools zu haben, die den Integrationsprozess vereinfachen. Während OpenAI eine unglaubliche Reihe von Fähigkeiten bietet, bestand ein klarer Bedarf an einem speziellen Swift -SDK, das mit den idiomatischen Praktiken der Sprache und den Erwartungen der Swift -Entwicklergemeinschaft übereinstimmt.
Wir haben uns ein Tool vorgestellt, das nicht nur Rohzugriff auf OpenAI -Funktionen bietet, sondern auch die Entwicklererfahrung mit einer klaren und intuitiven API verbessert. Unser ultimatives Ziel ist es, Innovationen zu fördern, indem Sie der Swift -Community die richtigen Tools zur Verfügung stellen, um KI -Funktionen mühelos in ihre Anwendungen in die Integration von ihren Anwendungen zu integrieren.
| Plattform | Minimale Swift -Version | Installation | Status |
|---|---|---|---|
| iOS 13.0+ / macos 10.15+ / tvos 13.0+ / watchos 6.0+ / VisionOS 1.0+ | 5.7 | Swift Package Manager | Vollständig getestet |
Mit dem Swift -Paket -Manager können Entwickler Pakete problemlos in ihre Xcode -Projekte und -Pakete integrieren. und ist auch vollständig in den swift -Compiler integriert.
https://github.com/OpenDive/OpenAIKit.git hinzu Sobald Sie Ihr Swift -Paket eingerichtet haben, fügen Sie den Git -Link in den dependencies Ihres Package.swift -Datei hinzu.
dependencies: [
. package ( url : " https://github.com/OpenDive/OpenAIKit.git " , . upToNextMajor ( from : " 2.0.1 " ) )
] Um eine API -Taste zu erhalten, gehen Sie hier zu Ihrer API Keys auf Ihrer Kontoseite.
Euen ? Wichtig: Speichern Sie keine OpenAI -API -Schlüssel direkt im Code! ?Euen Bei der Arbeit mit OpenAIs API ist es aus Sicherheitsgründen wichtig, Ihre API -Schlüssel nicht direkt in die Codebasis Ihrer Anwendung einzubetten. Das Einbetten von Schlüssel direkt in Ihren Quellcode kann sie nicht autorisierten Benutzern und böswilligen Akteuren aussetzen, was zu potenziellem Missbrauch führt.
Best Practices:
- Umgebungsvariablen: Speichern Sie Ihre API -Schlüssel in Umgebungsvariablen und greifen Sie in Ihrem Code auf sie zu. Auf diese Weise sind sie nicht hart in Ihre Bewerbung und können sicher verwaltet werden.
- Secrets Management: Verwenden Sie ein sicheres Tool oder Service für das Geheimnis des Geheimnisses, um Ihre API -Schlüssel zu speichern und abzurufen. Tools wie AWS Secrets Manager, Hashicorp Vault, Firebase, CloudKit oder Azure Key Vault sind so konzipiert, dass sie sensible Daten speichern, verwalten und abrufen. Auf diese Weise hat der Benutzer keinen Zugriff auf die Tasten auf dem Gerät.
- .gitignore: Wenn Sie Ihre API -Schlüssel in einer Konfigurationsdatei speichern, stellen Sie immer sicher, dass diese Datei zu
.gitignoreoder einem ähnlichen Mechanismus hinzugefügt wird, damit sie verhindern, dass sie versehentlich an ein Quell -Steuerungssystem verpflichtet werden.- Drehen Sie regelmäßig Schlüssel: Drehen Sie Ihre API -Schlüssel regelmäßig, um die möglichen Auswirkungen eines Lecks zu mildern.
Denken Sie daran, Sicherheit ist von größter Bedeutung. Priorisieren Sie immer die sichere Handhabung sensibler Informationen wie API -Schlüssel!
Weitere Informationen finden Sie in diesem Artikel über API -Schlüsselmanagement für Swift -Entwickler.
Tauchen Sie in die nächste Entwicklung der KI-angetriebenen Bildgenerierung mit Dall-e 2 (und bald, Dall-e 3), die Sie von Openai zu Ihnen gebracht haben. Aufbauend auf dem Erbe seines Vorgängers bietet Dall-E 2 verbesserte Fähigkeiten, um komplizierte Visuals aus textlichen Eingabeaufforderungen zu materialisieren und eine nahtlose Brücke zwischen Sprache und Bildern zu erzeugen. Entwickler können diese bahnbrechende Technologie nutzen, um Benutzererlebnisse zu bereichern, dynamische Inhalte zu erstellen und neue Wege der Kreativität zu inspirieren. Revolutionieren Sie Ihre Anwendungen und Projekte, indem Sie die modernste Kraft von Dall-e 2 integrieren.
OpenAI sind drei Endpunkte zur Interaktion mit Dall -E 2: - createImage ist der Hauptendpunkt, der die direkte Bilderzeugung aus einer Textaufforderung ermöglicht. Hier ist ein Beispiel, wie der Endpunkt zusammen mit der korrelierenden Ausgabe verwendet wird:
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 | Maske | Bearbeiten |
- createImageVariation kann der Entwickler Variationen eines bestimmten Eingabebildes erstellen. Hier ist ein Beispiel, wie der Endpunkt zusammen mit der korrelierenden Ausgabe verwendet wird:
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, basiert auf der GPT-4-Architektur von Openai, ist ein modernes KI-Modell. Es bietet Entwicklern ein robustes Werkzeug zur Integration erweiterter Verarbeitungsfunktionen für natürliche Sprache in Anwendungen. Die Verwendung von ChatGPT kann die Benutzerinteraktionen verbessern, die Effizienz verbessern und KI-gesteuerte Lösungen in verschiedenen Anwendungsfällen anbieten. Integrieren Sie die Stärke von GPT-4 in Ihre Projekte, um greifbare Ergebnisse zu erzielen.
Für diese Funktion gibt es einen einzelnen Endpunkt. Dieser SDK spaltet den Endpunkt jedoch in zwei Funktionen mit drei separaten Funktionen insgesamt auf: - generateChatCompletion ermöglicht es dem Entwickler, Chat -Abschlüsse mit den bereitgestellten Modellen von OpenAI zu generieren. oder die feinen Modelle des Entwicklers. Hier ist ein Beispiel, wie der Endpunkt zusammen mit der korrelierenden Ausgabe verwendet wird:
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
)
)
)
Der Entwickler ist auch in der Lage, Funktionsaufrufe zu verwenden, um verschiedene Funktionen auszuführen (z. B. Wetterinformationen, Hochladen von Dateien usw.). Hier ist ein Beispiel zur Verwendung des Parameters, der entsprechenden Antwort und der Beispielverwendung mit einer lokalen Funktion.
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 ermöglicht es dem Developr, Chat -Abschlussdaten vom Endpunkt zu streamen. Hier ist ein Beispiel, wie der Endpunkt zusammen mit der korrelierenden Ausgabe verwendet wird:
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 ist das Rede-to-Text-KI-Modell von OpenAI, das für eine genaue Transkription von gesprochenen Inhalten entwickelt wurde. Durch die Konvertierung von Audio in Text bietet es Entwicklern ein einfaches Tool für Aufgaben wie Transkriptionsdienste, Sprachbefehle, Übersetzungen für Stimmsprache oder Audio -Indexierung. Das Implementieren von Flüster kann dazu beitragen, Prozesse zu optimieren, Anwendungen zugänglicher zu machen und Sprachdaten effizient zu nutzen.
Es gibt die beiden Hauptendpunkte, die das Whisper -Modell verwenden: - createTranscription ist der Hauptendpunkt, mit dem Entwickler gesprochene Audio in Text transkribieren können. Hier ist ein Beispiel zur Verwendung des Endpunkts und des entsprechenden zurückgegebenen Elements:
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 ist der zweite Endpunkt, mit dem Entwickler nicht englisch in transkribierten englischen Text umsetzen können. Hier ist ein Beispiel zur Verwendung des Endpunkts und des entsprechenden zurückgegebenen Elements:
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.
Einbettungen nutzen die GPT -Modelle von OpenAI, um dichte Vektordarstellungen für Text zu generieren. Diese Einbettungen erfassen semantische Informationen, mit denen Entwickler Aufgaben wie die Suche nach Ähnlichkeit, das Clustering oder die Feinabstimmung mit bestimmten Aufgaben ausführen können. Durch die Integration von GPT -Einbettungen in Anwendungen können Entwickler die Textanalyse- und Abruffunktionen verbessern, was zu einer effektiveren Datenverarbeitung und Erkenntnisse führt.
Hier ist ein Beispiel, wie man es verwendet, und die erwartete Ausgabe für den Endpunkt:
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
)
)
Mit dem Modelsendpunkt können Entwickler die aktuell verfügbaren Modelle von OpenAI zusammen mit ihren eigenen fein abgestimmten Modellen abrufen.
Für die Verwendung mit dieser Funktion stehen zwei Endpunkte zur Verfügung:
listModels hält den Entwickler die gesamte Liste der Modelle ab. Hier ist eine Beispielnutzung zusammen mit der entsprechenden Ausgabe: 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 holt ein einzelnes Modell angesichts der ID des Eingabemodells. Hier ist eine Beispielnutzung zusammen mit der entsprechenden Ausgabe: 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"
)
Bis zum 6. Juli 2023 hat OpenAI die Abschreibung der älteren Modelle in der API von Completions angekündigt, die zu Beginn von 2024 in den Ruhestand treten sollen. Es wird dringend empfohlen, zur API der Chat-Vervollständigung zu wechseln, die eine strukturiertere Funktion mit promptem Schnittstellen und mehreren Gesprächen bietet. Die API der Chat -Abschlüsse hat sich erwiesen, um eine überwiegende Mehrheit der früheren Anwendungsfälle und die neuen Konversationsbedürfnisse mit höherer Flexibilität und Spezifität zu bewältigen und die Entwicklererfahrung erheblich zu verbessern. Weitere Informationen finden Sie in der offiziellen Ankündigung.
Ab 2.x verwenden Modelle CHAT -Abschlussmodelle Enums, um jedes verfügbare Modell für die Hauptverwendung von Standardmodellen zu kennzeichnen. Hier finden Sie ein Beispiel, wie Sie von der Verwendung des älteren Initialisierers für ChatParameter zum Initialisierer für 2.x migrieren.
// 1.x implementation
let chatParameters = ChatParameters ( model : " gpt4 " , messages : chat )
// ✅ 2.x implementation
let chatParameters = ChatParameters ( model : . gpt4 , messages : chat ) Wenn Sie eine benutzerdefinierte Zeichenfolge für fein abgestimmte Modelle benötigen, verwenden Sie den customModel -Parameter:
// ✅ 2.x implementation for custom model IDs
let chatParameters = ChatParameters ( customModel : " INSERT-MODEL-ID " , message : chat ) (TBD)
Wir begrüßen jeden, der durch die Veröffentlichung von Problemen zum Projekt beitragen, wenn er bei der Verwendung von Openaikit auf Fehler / Pannen begegnet wird. Auch beim Erstellen von Pull -Problemen, die Openaikit zusätzliche Funktionen hinzufügen.
Openaikit wird im Rahmen der MIT -Lizenz veröffentlicht, und jede Verwendung von OpenAs Restendpunkt unter den von ihnen festgelegten Verwendungsrichtlinien.
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.
