OpenAI DotNet
OpenAI-DotNet 8.4.1
Eine einfache C# .NET -Client -Bibliothek für OpenAI, die sie durch ihre erholsame API verwenden kann. Unabhängig entwickelt ist dies keine offizielle Bibliothek und ich bin nicht mit OpenAI verbunden. Ein OpenAI -API -Konto ist erforderlich.
Ursprünglich aus Openai-api-dotnet gegabelt. Mehr Kontext zu Roger Pincombe's Blog.
Installieren Sie das Paket OpenAI-DotNet von Nuget. Hier ist wie über die Befehlszeile:
Powershell:
Install-Package OpenAI-DotNet
Dotnet:
dotnet add package OpenAI-DotNet
Möchten Sie Openai-Dotnet in der Unity Game Engine verwenden? Schauen Sie sich unser Einheitspaket auf OpenUpM an:
Schauen Sie sich unsere neuen API -Dokumente an!
https://rageagainstthepixel.github.io/openai-dotnet
Es gibt 3 Möglichkeiten, Ihre API -Schlüssel in der Reihenfolge der Vorrang zu liefern:
Warnung
Wir haben empfohlen, die Umgebungsvariablen zu verwenden, um den API -Schlüssel zu laden, anstatt sie in Ihrer Quelle schwer codiert zu haben. Es wird nicht empfohlen, diese Methode in der Produktion zu verwenden, sondern nur für die Akzeptanz von Benutzeranmeldeinformationen, lokalen Tests und Schnellstartszenarien.
Warnung
Wir haben empfohlen, die Umgebungsvariablen zu verwenden, um den API -Schlüssel zu laden, anstatt sie in Ihrer Quelle schwer codiert zu haben. Es wird nicht empfohlen, diese Methode in der Produktion zu verwenden, sondern nur für die Akzeptanz von Benutzeranmeldeinformationen, lokalen Tests und Schnellstartszenarien.
using var api = new OpenAIClient ( " sk-apiKey " ) ; Oder ein OpenAIAuthentication -Objekt manuell erstellen
using var api = new OpenAIClient ( new OpenAIAuthentication ( " sk-apiKey " , " org-yourOrganizationId " , " proj_yourProjectId " ) ) ; Versuche, API -Schlüssel aus einer Konfigurationsdatei standardmäßig .openai im aktuellen Verzeichnis zu laden, wodurch sich optional der Verzeichnisbaum oder im Heimverzeichnis des Benutzers durchquert.
Um eine Konfigurationsdatei zu erstellen, erstellen Sie eine neue Textdatei mit dem Namen .openai und enthalten die Zeile:
Notiz
Organisations- und Projekt -ID -Einträge sind optional.
{
"apiKey" : " sk-aaaabbbbbccccddddd " ,
"organizationId" : " org-yourOrganizationId " ,
"projectId" : " proj_yourProjectId "
}OPENAI_API_KEY=sk-aaaabbbbbccccddddd
OPENAI_ORGANIZATION_ID=org-yourOrganizationId
OPENAI_PROJECT_ID=proj_yourProjectId Sie können die Konfigurationsdatei auch direkt mit dem bekannten Pfad laden, indem Sie statische Methoden in OpenAIAuthentication aufrufen:
.openai -Konfiguration im angegebenen Verzeichnis: using var api = new OpenAIClient ( OpenAIAuthentication . LoadFromDirectory ( " path/to/your/directory " ) ) ;.openai genannt werden, solange sie dem JSON -Format entspricht: using var api = new OpenAIClient ( OpenAIAuthentication . LoadFromPath ( " path/to/your/file.json " ) ) ; Verwenden Sie die Umgebungsvariablen Ihres Systems an, geben Sie einen API -Schlüssel und eine Organisation an.
OPENAI_API_KEY für Ihre API -Schlüssel.OPENAI_ORGANIZATION_ID , um eine Organisation anzugeben.OPENAI_PROJECT_ID , um ein Projekt anzugeben. using var api = new OpenAIClient ( OpenAIAuthentication . LoadFromEnv ( ) ) ; OpenAIClient implementiert IDisposable , um den Lebenszyklus der von ihnen verwendeten Ressourcen zu verwalten, einschließlich HttpClient . Wenn Sie OpenAIClient initialisieren, wird eine interne HttpClient -Instanz erstellt, wenn nicht bereitgestellt wird. Dieser interne HttpClient wird entsorgt, wenn OpenAIClient entsorgt wird. Wenn Sie OpenAIClient eine externe HttpClient -Instanz zur Verfügung stellen, sind Sie für die Verwaltung seiner Entsorgung verantwortlich.
OpenAIClient seinen eigenen HttpClient schafft, wird es sich auch darum kümmern, sie zu entsorgen, wenn Sie OpenAIClient entsorgen.HttpClient an OpenAIClient übergeben wird, wird er nicht durch OpenAIClient entsorgt. Sie müssen die Entsorgung des HttpClient selbst verwalten. Bitte stellen Sie sicher, dass OpenAIClient die rechtzeitige Freigabe von Ressourcen angemessen entsorgen und potenzielle Speicher- oder Ressourcenlecks in Ihrer Anwendung verhindern.
Typische Verwendung mit einem internen HttpClient :
using var api = new OpenAIClient ( ) ; Benutzerdefinierte HttpClient (die Sie sich selbst entsorgen müssen):
using var customHttpClient = new HttpClient ( ) ;
// set custom http client properties here
var api = new OpenAIClient ( client : customHttpClient ) ;Sie können auch die Azure OpenAI -Bereitstellungen von Microsoft verwenden.
Sie können die erforderlichen Informationen auf dem Azure -Spielplatz finden, indem Sie auf die Schaltfläche View Code anzeigen und eine URL wie folgt anzeigen:
https://{your-resource-name}.openai.azure.com/openai/deployments/{deployment-id}/chat/completions?api-version={api-version}your-resource-name Der Name Ihrer Azure OpenAI-Ressource.deployment-id Den Bereitstellungsnamen, den Sie bei der Bereitstellung des Modells ausgewählt haben.api-version Die API-Version für diesen Vorgang. Dies folgt dem YYYY-MM-DD-Format. Um den Kunden so einzustellen, dass Sie Ihre Bereitstellung verwenden, müssen Sie OpenAIClientSettings in den Client -Konstruktor weitergeben.
var auth = new OpenAIAuthentication ( " sk-apiKey " ) ;
var settings = new OpenAIClientSettings ( resourceName : " your-resource-name " , deploymentId : " deployment-id " , apiVersion : " api-version " ) ;
using var api = new OpenAIClient ( auth , settings ) ; Authentifizieren Sie sich mit MSAL wie gewohnt und erhalten Sie beim Erstellen Ihrer OpenAIAuthentication . Stellen Sie dann unbedingt die UseazureAteRevedirectory auf wahr ein, wenn Sie Ihre OpenAIClientSettings erstellen.
Tutorial: Desktop -App, die Web -APIs aufruft: Erwerben Sie ein Token
// get your access token using any of the MSAL methods
var accessToken = result . AccessToken ;
var auth = new OpenAIAuthentication ( accessToken ) ;
var settings = new OpenAIClientSettings ( resourceName : " your-resource " , deploymentId : " deployment-id " , apiVersion : " api-version " , useActiveDirectoryAuthentication : true ) ;
using var api = new OpenAIClient ( auth , settings ) ;Wenn Sie entweder die Openai-Dotnet- oder com.openai.unity-Pakete direkt in Ihrer Front-End-App verwenden, können Sie Ihre API-Schlüssel und andere sensible Informationen enthüllen. Um dieses Risiko zu mildern, wird empfohlen, eine Zwischen-API einzurichten, die Anfragen zum Öffnen im Namen Ihrer Front-End-App einsetzt. Diese Bibliothek kann sowohl für Front-End- als auch für Vermittler-Hostkonfigurationen verwendet werden, um eine sichere Kommunikation mit der OpenAI-API zu gewährleisten.
Im Vorderseite müssen Sie Ihre Benutzer mit Ihrem bevorzugten OAuth -Anbieter sicher authentifizieren. Sobald der Benutzer authentifiziert ist, tauschen Sie Ihr benutzerdefiniertes Author -Token mit Ihrem API -Schlüssel im Backend aus.
Folgen Sie folgenden Schritten:
OpenAIAuthentication -Objekt und geben Sie das benutzerdefinierte Token mit der sess- .OpenAIClientSettings -Objekt und geben Sie die Domäne an, in der sich Ihre Zwischen -API befindet.auth und settings an den OpenAIClient -Konstruktor, wenn Sie die Client -Instanz erstellen.Hier ist ein Beispiel für die Einrichtung des vorderen Endes:
var authToken = await LoginAsync ( ) ;
var auth = new OpenAIAuthentication ( $" sess- { authToken } " ) ;
var settings = new OpenAIClientSettings ( domain : " api.your-custom-domain.com " ) ;
using var api = new OpenAIClient ( auth , settings ) ;Mit diesem Setup kann Ihre Front-End-Anwendung sicher mit Ihrem Backend kommunizieren, das die OpenAI-Dotnet-Proxy verwendet, die dann Anfragen an die OpenAI-API weiterleitet. Dies stellt sicher, dass Ihre OpenAI -API -Schlüssel und andere sensible Informationen während des gesamten Prozesses sicher bleiben.
In diesem Beispiel zeigen wir, wie OpenAIProxy in einer neuen ASP.NET -Kern -Web -App eingerichtet und verwendet werden. Der Proxy -Server leitet die Authentifizierung und die Anfragen an die OpenAI -API weiter, um sicherzustellen, dass Ihre API -Schlüssel und andere vertrauliche Informationen sicher bleiben.
Install-Package OpenAI-DotNet-Proxydotnet add package OpenAI-DotNet-Proxy<PackageReference Include="OpenAI-DotNet-Proxy" />AbstractAuthenticationFilter erbt und die ValidateAuthentication -Methode überschreibt. Dadurch wird der IAuthenticationFilter implementiert, mit dem Sie das Benutzersitzungstoken anhand Ihres internen Servers überprüfen.Program.cs eine neue Proxy -Webanwendung, indem Sie OpenAIProxy.CreateWebApplication -Methode aufrufen und Ihre benutzerdefinierte AuthenticationFilter als Typ Argument übergeben.OpenAIAuthentication und OpenAIClientSettings , wie Sie es normalerweise mit Ihren API -Tasten, Org -IDs oder Azure -Einstellungen tun. public partial class Program
{
private class AuthenticationFilter : AbstractAuthenticationFilter
{
public override async Task ValidateAuthenticationAsync ( IHeaderDictionary request )
{
await Task . CompletedTask ; // remote resource call to verify token
// You will need to implement your own class to properly test
// custom issued tokens you've setup for your end users.
if ( ! request . Authorization . ToString ( ) . Contains ( TestUserToken ) )
{
throw new AuthenticationException ( " User is not authorized " ) ;
}
}
}
public static void Main ( string [ ] args )
{
var auth = OpenAIAuthentication . LoadFromEnv ( ) ;
var settings = new OpenAIClientSettings ( /* your custom settings if using Azure OpenAI */ ) ;
using var openAIClient = new OpenAIClient ( auth , settings ) ;
OpenAIProxy . CreateWebApplication < AuthenticationFilter > ( args , openAIClient ) . Run ( ) ;
}
}Sobald Sie Ihren Proxy -Server eingerichtet haben, können Ihre Endbenutzer jetzt authentifizierte Anfragen an Ihre Proxy -API anstelle von direkt an der OpenAI -API stellen. Der Proxy -Server leitet die Authentifizierung und die Anfragen an die OpenAI -API weiter, um sicherzustellen, dass Ihre API -Schlüssel und andere vertrauliche Informationen sicher bleiben.
Listen und beschreiben Sie die verschiedenen in der API verfügbaren Modelle. Sie können sich auf die Modelsdokumentation beziehen, um zu verstehen, welche Modelle verfügbar sind und welche Unterschiede zwischen ihnen sind.
Auch Checkout -Modellendpunktkompatibilität, um zu verstehen, welche Modelle arbeiten, mit welchen Endpunkten.
Um ein benutzerdefiniertes Modell anzugeben, das in dieser Bibliothek nicht vorgestellt wurde:
var model = new Model ( " model-id " ) ; Die Modelle API wird über OpenAIClient.ModelsEndpoint zugegriffen
Listet die aktuell verfügbaren Modelle auf und liefert grundlegende Informationen zu jedem einzelnen wie dem Eigentümer und der Verfügbarkeit.
using var api = new OpenAIClient ( ) ;
var models = await api . ModelsEndpoint . GetModelsAsync ( ) ;
foreach ( var model in models )
{
Console . WriteLine ( model . ToString ( ) ) ;
} Ruft eine Modellinstanz ab und liefert grundlegende Informationen über das Modell wie den Eigentümer und die Berechtigungen.
using var api = new OpenAIClient ( ) ;
var model = await api . ModelsEndpoint . GetModelDetailsAsync ( " gpt-4o " ) ;
Console . WriteLine ( model . ToString ( ) ) ; Löschen Sie ein feinstimmiges Modell. Sie müssen die Rolle des Eigentümers in Ihrer Organisation haben.
using var api = new OpenAIClient ( ) ;
var isDeleted = await api . ModelsEndpoint . DeleteFineTuneModelAsync ( " your-fine-tuned-model " ) ;
Assert . IsTrue ( isDeleted ) ;Warnung
Beta -Funktion. API unterliegt den Veränderungen.
Die Echtzeit-API ermöglicht es Ihnen, multimodale Konversationserlebnisse mit geringer Latenz zu erstellen. Derzeit unterstützt es Text und Audio sowohl als Eingabe als auch Ausgabe sowie Funktionsaufrufe.
Die Assistants -API wird über OpenAIClient.RealtimeEndpoint zugegriffen
Hier ist ein einfaches Beispiel dafür, wie Sie eine Echtzeitsitzung erstellen und Nachrichten aus dem Modell senden und empfangen können.
using var api = new OpenAIClient ( ) ;
var cancellationTokenSource = new CancellationTokenSource ( ) ;
var tools = new List < Tool >
{
Tool . FromFunc ( " goodbye " , ( ) =>
{
cancellationTokenSource . Cancel ( ) ;
return " Goodbye! " ;
} )
} ;
var options = new Options ( Model . GPT4oRealtime , tools : tools ) ;
using var session = await api . RealtimeEndpoint . CreateSessionAsync ( options ) ;
var responseTask = session . ReceiveUpdatesAsync < IServerEvent > ( ServerEvents , cancellationTokenSource . Token ) ;
await session . SendAsync ( new ConversationItemCreateRequest ( " Hello! " ) ) ;
await session . SendAsync ( new CreateResponseRequest ( ) ) ;
await session . SendAsync ( new InputAudioBufferAppendRequest ( new ReadOnlyMemory < byte > ( new byte [ 1024 * 4 ] ) ) , cancellationTokenSource . Token ) ;
await session . SendAsync ( new ConversationItemCreateRequest ( " GoodBye! " ) ) ;
await session . SendAsync ( new CreateResponseRequest ( ) ) ;
await responseTask ;
void ServerEvents ( IServerEvent @event )
{
switch ( @event )
{
case ResponseAudioTranscriptResponse transcriptResponse :
Console . WriteLine ( transcriptResponse . ToString ( ) ) ;
break ;
case ResponseFunctionCallArgumentsResponse functionCallResponse :
if ( functionCallResponse . IsDone )
{
ToolCall toolCall = functionCallResponse ;
toolCall . InvokeFunction ( ) ;
}
break ;
}
} Die Bibliothek implementiert die Schnittstelle IClientEvent für ausgehende Client -Send -Ereignisse.
UpdateSessionRequest : Aktualisieren Sie die Sitzung mit neuen Sitzungsoptionen.InputAudioBufferAppendRequest : Gehen Sie Audio an den Eingabe -Audio -Puffer an. (Im Gegensatz zu anderen Client -Ereignissen sendet der Server keine Bestätigungsantwort an dieses Ereignis).InputAudioBufferCommitRequest : Beiten Sie den Eingabe -Audiopuffer. (Wenn der Client im Server -VAD -Modus dieses Ereignis nicht senden muss).InputAudioBufferClearRequest : Löschen Sie den Eingabe -Audio -Puffer.ConversationItemCreateRequest : Erstellen Sie ein neues Gesprächselement. Dies ist die Hauptmethode, um Benutzerinhalte an das Modell zu senden.ConversationItemTruncateRequest : Senden Sie dieses Ereignis, um das Audio einer früheren Assistenzmeldung abzuschneiden.ConversationItemDeleteRequest : Löschen Sie einen Gesprächsgegenstand. Dies ist nützlich, wenn Sie eine Nachricht aus dem Gesprächsgeschichte entfernen möchten.CreateResponseRequest : Erstellen Sie eine Antwort aus dem Modell. Senden Sie dieses Ereignis, nachdem Sie neue Konversationsgegenstände erstellt oder Toolanrufe aufgerufen haben. Dadurch wird das Modell ausgelöst, um eine Antwort zu generieren.ResponseCancelRequest -Geben Sie dieses Ereignis an, um eine In -Progress -Antwort zu stornieren. Sie können Client -Ereignisse jederzeit an den Server senden, indem Sie die Methode der RealtimeSession.SendAsync im Sitzungsobjekt aufrufen. Der Send -Anruf gibt ein IServerEvent -Handle zurück, das die entsprechende Antwort vom Server für dieses Ereignis am besten darstellt. Dies ist nützlich, wenn Sie serierende Antworten auf detailliertere Weise verarbeiten möchten.
Im Idealfall möchten Sie jedoch alle Serverantworten mit RealtimeSession.ReceiveUpdatesAsync verarbeiten.
Notiz
Der Server sendet keine Bestätigungsantwort an das InputAudioBufferAppendRequest -Ereignis.
Wichtig
Sie müssen auch CreateResponseRequest senden, um das Modell auszulösen, um eine Antwort zu generieren.
var serverEvent = await session . SendAsync ( new ConversationItemCreateRequest ( " Hello! " ) ) ;
Console . WriteLine ( serverEvent . ToJsonString ( ) ) ;
serverEvent = await session . SendAsync ( new CreateResponseRequest ( ) ) ;
Console . WriteLine ( serverEvent . ToJsonString ( ) ) ; Die Bibliothek implementiert IServerEvent -Schnittstelle für eingehende Server -Ereignisse.
RealtimeEventError : Zurückgegeben, wenn ein Fehler auftritt, was ein Client -Problem oder ein Serverproblem sein kann.SessionResponse : Rendete für eine session.created zurück session.updatedRealtimeConversationResponse : Zurückgegeben, wenn ein neues Konversationsgegenstand erstellt wird.ConversationItemCreatedResponse : Zurückgegeben, wenn ein neues Gesprächselement erstellt wird.ConversationItemInputAudioTranscriptionResponse : Zurückgegeben, wenn die Eingabe -Audio -Transkription abgeschlossen ist oder fehlgeschlagen ist.ConversationItemTruncatedResponse : Zurückgegeben, wenn ein Konversationsgegenstand abgeschnitten wird.ConversationItemDeletedResponse : Zurückgegeben, wenn ein Konversationsgegenstand gelöscht wird.InputAudioBufferCommittedResponse : Zurückgegeben, wenn ein Eingabe -Audio -Puffer vom Client oder automatisch im Server -VAD -Modus festgelegt wird.InputAudioBufferClearedResponse : Zurückgegeben, wenn ein Eingangs -Audio -Puffer gelöscht wird.InputAudioBufferStartedResponse : vom Server gesendet, wenn im Server_Vad -Modus angezeigt wird, dass die Sprache im Audiopuffer erkannt wurde. Dies kann jederzeit passieren, wenn Audio dem Puffer hinzugefügt wird (es sei denn, die Sprache ist bereits erkannt). Der Client möchte dieses Ereignis möglicherweise verwenden, um die Audio -Wiedergabe zu unterbrechen oder dem Benutzer visuelles Feedback zu geben.InputAudioBufferStoppedResponse : Rückgegeben im Server_vad -Modus, wenn der Server das Ende der Sprache im Audiopuffer erkennt.RealtimeResponse : Zurückgegeben, wenn eine Antwort erstellt oder ausgeführt wird.ResponseOutputItemResponse : Zurückgegeben, wenn ein Antwortausgangselement hinzugefügt oder ausgeführt wird.ResponseContentPartResponse : Zurückgegeben, wenn ein Antwortinhalteteil hinzugefügt oder ausgeführt wird.ResponseTextResponse : Zurückgegeben, wenn ein Antworttext aktualisiert oder ausgeführt wird.ResponseAudioTranscriptResponse : Zurückgegeben, wenn ein Antwort -Audio -Transkript aktualisiert oder ausgeführt wird.ResponseAudioResponse : Zurückgegeben, wenn ein Antwort -Audio aktualisiert oder ausgeführt wird.ResponseFunctionCallArgumentsResponse : Rückgabe, wenn eine Antwortfunktionsanruf -Argumente aktualisiert oder ausgeführt werden.RateLimitsResponse : zurückgegeben, wenn die Tarifbegrenzungen aktualisiert werden. Um Serverereignisse zu empfangen, müssen Sie die Methode der RealtimeSession.ReceiveUpdatesAsync auf dem Sitzungsobjekt aufrufen. Diese Methode gibt eine Task oder IAsyncEnumerable<T> zurück, die abgeschlossen ist, wenn die Sitzung geschlossen ist oder wenn der Stornierungs -Token ausgelöst wird. Idealerweise sollte diese Methode einmal aufgerufen und für die Dauer der Sitzung ausgeführt werden.
Notiz
Sie können auch IClientEvent -Rückrufe gesendet werden, indem Sie die IRealtimeEvent -Schnittstelle anstelle von IServerEvent verwenden.
await foreach ( var @event in session . ReceiveUpdatesAsync < IServerEvent > ( cts . Token ) )
{
switch ( @event )
{
case RealtimeEventError error :
// raised anytime an error occurs
break ;
case SessionResponse sessionResponse :
// raised when a session is created or updated
break ;
case RealtimeConversationResponse conversationResponse :
// raised when a new conversation is created
break ;
case ConversationItemCreatedResponse conversationItemCreated :
// raised when a new conversation item is created
break ;
case ConversationItemInputAudioTranscriptionResponse conversationItemTranscription :
// raised when the input audio transcription is completed or failed
break ;
case ConversationItemTruncatedResponse conversationItemTruncated :
// raised when a conversation item is truncated
break ;
case ConversationItemDeletedResponse conversationItemDeleted :
// raised when a conversation item is deleted
break ;
case InputAudioBufferCommittedResponse committedResponse :
// raised when an input audio buffer is committed
break ;
case InputAudioBufferClearedResponse clearedResponse :
// raised when an input audio buffer is cleared
break ;
case InputAudioBufferStartedResponse startedResponse :
// raised when speech is detected in the audio buffer
break ;
case InputAudioBufferStoppedResponse stoppedResponse :
// raised when speech stops in the audio buffer
break ;
case RealtimeResponse realtimeResponse :
// raised when a response is created or done
break ;
case ResponseOutputItemResponse outputItemResponse :
// raised when a response output item is added or done
break ;
case ResponseContentPartResponse contentPartResponse :
// raised when a response content part is added or done
break ;
case ResponseTextResponse textResponse :
// raised when a response text is updated or done
break ;
case ResponseAudioTranscriptResponse transcriptResponse :
// raised when a response audio transcript is updated or done
break ;
case ResponseFunctionCallArgumentsResponse functionCallResponse :
// raised when a response function call arguments are updated or done
break ;
case RateLimitsResponse rateLimitsResponse :
// raised when rate limits are updated
break ;
}
}Warnung
Beta -Funktion. API unterliegt den Veränderungen.
Erstellen Sie Assistenten, die Modelle anrufen und Tools verwenden können, um Aufgaben auszuführen.
Die Assistants -API wird über OpenAIClient.AssistantsEndpoint zugegriffen
Gibt eine Liste von Assistenten zurück.
using var api = new OpenAIClient ( ) ;
var assistantsList = await api . AssistantsEndpoint . ListAssistantsAsync ( ) ;
foreach ( var assistant in assistantsList . Items )
{
Console . WriteLine ( $" { assistant } -> { assistant . CreatedAt } " ) ;
} Erstellen Sie einen Assistenten mit einem Modell und Anweisungen.
using var api = new OpenAIClient ( ) ;
var request = new CreateAssistantRequest ( Model . GPT4o ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync ( request ) ; Ruft einen Assistenten ab.
using var api = new OpenAIClient ( ) ;
var assistant = await api . AssistantsEndpoint . RetrieveAssistantAsync ( " assistant-id " ) ;
Console . WriteLine ( $" { assistant } -> { assistant . CreatedAt } " ) ; Modifiziert einen Assistenten.
using var api = new OpenAIClient ( ) ;
var createRequest = new CreateAssistantRequest ( Model . GPT4_Turbo ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync ( createRequest ) ;
var modifyRequest = new CreateAssistantRequest ( Model . GPT4o ) ;
var modifiedAssistant = await api . AssistantsEndpoint . ModifyAssistantAsync ( assistant . Id , modifyRequest ) ;
// OR AssistantExtension for easier use!
var modifiedAssistantEx = await assistant . ModifyAsync ( modifyRequest ) ; Einen Assistenten löschen.
using var api = new OpenAIClient ( ) ;
var isDeleted = await api . AssistantsEndpoint . DeleteAssistantAsync ( " assistant-id " ) ;
// OR AssistantExtension for easier use!
var isDeleted = await assistant . DeleteAsync ( ) ;
Assert . IsTrue ( isDeleted ) ; Notiz
Assistent -Stream -Ereignisse können problemlos zu vorhandenen Thread -Aufrufen hinzugefügt werden, indem Func<IServerSentEvent, Task> streamEventHandler -Rückruf an eine vorhandene Methode übergeben, die Streaming unterstützt.
Erstellen Sie Themen, mit denen Assistenten interagieren können.
Auf die Threads -API wird über OpenAIClient.ThreadsEndpoint zugegriffen
Erstellen Sie einen Thread.
using var api = new OpenAIClient ( ) ;
var thread = await api . ThreadsEndpoint . CreateThreadAsync ( ) ;
Console . WriteLine ( $" Create thread { thread . Id } -> { thread . CreatedAt } " ) ; Erstellen Sie einen Thread und führen Sie ihn in einer Anfrage aus.
Siehe auch: Thread -Läufe
using var api = new OpenAIClient ( ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync (
new CreateAssistantRequest (
name : " Math Tutor " ,
instructions : " You are a personal math tutor. Answer questions briefly, in a sentence or less. " ,
model : Model . GPT4o ) ) ;
var messages = new List < Message > { " I need to solve the equation `3x + 11 = 14`. Can you help me? " } ;
var threadRequest = new CreateThreadRequest ( messages ) ;
var run = await assistant . CreateThreadAndRunAsync ( threadRequest ) ;
Console . WriteLine ( $" Created thread and run: { run . ThreadId } -> { run . Id } -> { run . CreatedAt } " ) ; Erstellen Sie einen Thread und führen Sie ihn in einer Anfrage aus, während Sie Ereignisse streamen.
using var api = new OpenAIClient ( ) ;
var tools = new List < Tool >
{
Tool . GetOrCreateTool ( typeof ( WeatherService ) , nameof ( WeatherService . GetCurrentWeatherAsync ) )
} ;
var assistantRequest = new CreateAssistantRequest ( tools : tools , instructions : " You are a helpful weather assistant. Use the appropriate unit based on geographical location. " ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync ( assistantRequest ) ;
ThreadResponse thread = null ;
async Task StreamEventHandler ( IServerSentEvent streamEvent )
{
switch ( streamEvent )
{
case ThreadResponse threadResponse :
thread = threadResponse ;
break ;
case RunResponse runResponse :
if ( runResponse . Status == RunStatus . RequiresAction )
{
var toolOutputs = await assistant . GetToolOutputsAsync ( runResponse ) ;
foreach ( var toolOutput in toolOutputs )
{
Console . WriteLine ( $" Tool Output: { toolOutput } " ) ;
}
await runResponse . SubmitToolOutputsAsync ( toolOutputs , StreamEventHandler ) ;
}
break ;
default :
Console . WriteLine ( streamEvent . ToJsonString ( ) ) ;
break ;
}
}
var run = await assistant . CreateThreadAndRunAsync ( " I'm in Kuala-Lumpur, please tell me what's the temperature now? " , StreamEventHandler ) ;
run = await run . WaitForStatusChangeAsync ( ) ;
var messages = await thread . ListMessagesAsync ( ) ;
foreach ( var response in messages . Items . Reverse ( ) )
{
Console . WriteLine ( $" { response . Role } : { response . PrintContent ( ) } " ) ;
} Ruft einen Thread ab.
using var api = new OpenAIClient ( ) ;
var thread = await api . ThreadsEndpoint . RetrieveThreadAsync ( " thread-id " ) ;
// OR if you simply wish to get the latest state of a thread
thread = await thread . UpdateAsync ( ) ;
Console . WriteLine ( $" Retrieve thread { thread . Id } -> { thread . CreatedAt } " ) ; Modifiziert einen Thread.
Hinweis: Nur die Metadaten können geändert werden.
using var api = new OpenAIClient ( ) ;
var thread = await api . ThreadsEndpoint . CreateThreadAsync ( ) ;
var metadata = new Dictionary < string , string >
{
{ " key " , " custom thread metadata " }
}
thread = await api . ThreadsEndpoint . ModifyThreadAsync ( thread . Id , metadata ) ;
// OR use extension method for convenience!
thread = await thread . ModifyAsync ( metadata ) ;
Console . WriteLine ( $" Modify thread { thread . Id } -> { thread . Metadata [ " key " ] } " ) ; Einen Thread löschen.
using var api = new OpenAIClient ( ) ;
var isDeleted = await api . ThreadsEndpoint . DeleteThreadAsync ( " thread-id " ) ;
// OR use extension method for convenience!
var isDeleted = await thread . DeleteAsync ( ) ;
Assert . IsTrue ( isDeleted ) ; Erstellen Sie Nachrichten in Threads.
Gibt eine Liste von Nachrichten für einen bestimmten Thread zurück.
using var api = new OpenAIClient ( ) ;
var messageList = await api . ThreadsEndpoint . ListMessagesAsync ( " thread-id " ) ;
// OR use extension method for convenience!
var messageList = await thread . ListMessagesAsync ( ) ;
foreach ( var message in messageList . Items )
{
Console . WriteLine ( $" { message . Id } : { message . Role } : { message . PrintContent ( ) } " ) ;
} Erstellen Sie eine Nachricht.
using var api = new OpenAIClient ( ) ;
var thread = await api . ThreadsEndpoint . CreateThreadAsync ( ) ;
var request = new CreateMessageRequest ( " Hello world! " ) ;
var message = await api . ThreadsEndpoint . CreateMessageAsync ( thread . Id , request ) ;
// OR use extension method for convenience!
var message = await thread . CreateMessageAsync ( " Hello World! " ) ;
Console . WriteLine ( $" { message . Id } : { message . Role } : { message . PrintContent ( ) } " ) ; Eine Nachricht abrufen.
using var api = new OpenAIClient ( ) ;
var message = await api . ThreadsEndpoint . RetrieveMessageAsync ( " thread-id " , " message-id " ) ;
// OR use extension methods for convenience!
var message = await thread . RetrieveMessageAsync ( " message-id " ) ;
var message = await message . UpdateAsync ( ) ;
Console . WriteLine ( $" { message . Id } : { message . Role } : { message . PrintContent ( ) } " ) ; Ändern Sie eine Nachricht.
Hinweis: Nur die Nachrichtenmetadaten können geändert werden.
using var api = new OpenAIClient ( ) ;
var metadata = new Dictionary < string , string >
{
{ " key " , " custom message metadata " }
} ;
var message = await api . ThreadsEndpoint . ModifyMessageAsync ( " thread-id " , " message-id " , metadata ) ;
// OR use extension method for convenience!
var message = await message . ModifyAsync ( metadata ) ;
Console . WriteLine ( $" Modify message metadata: { message . Id } -> { message . Metadata [ " key " ] } " ) ; Repräsentiert einen Ausführungsverlauf auf einem Thread.
Gibt eine Liste von Läufen zurück, die zu einem Thread gehören.
using var api = new OpenAIClient ( ) ;
var runList = await api . ThreadsEndpoint . ListRunsAsync ( " thread-id " ) ;
// OR use extension method for convenience!
var runList = await thread . ListRunsAsync ( ) ;
foreach ( var run in runList . Items )
{
Console . WriteLine ( $" [ { run . Id } ] { run . Status } | { run . CreatedAt } " ) ;
} Erstellen Sie einen Lauf.
using var api = new OpenAIClient ( ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync (
new CreateAssistantRequest (
name : " Math Tutor " ,
instructions : " You are a personal math tutor. Answer questions briefly, in a sentence or less. " ,
model : Model . GPT4o ) ) ;
var thread = await api . ThreadsEndpoint . CreateThreadAsync ( ) ;
var message = await thread . CreateMessageAsync ( " I need to solve the equation `3x + 11 = 14`. Can you help me? " ) ;
var run = await thread . CreateRunAsync ( assistant ) ;
Console . WriteLine ( $" [ { run . Id } ] { run . Status } | { run . CreatedAt } " ) ; Erstellen Sie einen Lauf und streamen Sie die Ereignisse.
using var api = new OpenAIClient ( ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync (
new CreateAssistantRequest (
name : " Math Tutor " ,
instructions : " You are a personal math tutor. Answer questions briefly, in a sentence or less. Your responses should be formatted in JSON. " ,
model : Model . GPT4o ,
responseFormat : ChatResponseFormat . Json ) ) ;
var thread = await api . ThreadsEndpoint . CreateThreadAsync ( ) ;
var message = await thread . CreateMessageAsync ( " I need to solve the equation `3x + 11 = 14`. Can you help me? " ) ;
var run = await thread . CreateRunAsync ( assistant , async streamEvent =>
{
Console . WriteLine ( streamEvent . ToJsonString ( ) ) ;
await Task . CompletedTask ;
} ) ;
var messages = await thread . ListMessagesAsync ( ) ;
foreach ( var response in messages . Items . Reverse ( ) )
{
Console . WriteLine ( $" { response . Role } : { response . PrintContent ( ) } " ) ;
} Ruft einen Lauf ab.
using var api = new OpenAIClient ( ) ;
var run = await api . ThreadsEndpoint . RetrieveRunAsync ( " thread-id " , " run-id " ) ;
// OR use extension method for convenience!
var run = await thread . RetrieveRunAsync ( " run-id " ) ;
var run = await run . UpdateAsync ( ) ;
Console . WriteLine ( $" [ { run . Id } ] { run . Status } | { run . CreatedAt } " ) ; Modifiziert einen Lauf.
Hinweis: Nur die Metadaten können geändert werden.
using var api = new OpenAIClient ( ) ;
var metadata = new Dictionary < string , string >
{
{ " key " , " custom run metadata " }
} ;
var run = await api . ThreadsEndpoint . ModifyRunAsync ( " thread-id " , " run-id " , metadata ) ;
// OR use extension method for convenience!
var run = await run . ModifyAsync ( metadata ) ;
Console . WriteLine ( $" Modify run { run . Id } -> { run . Metadata [ " key " ] } " ) ; Wenn ein Run den Status hat: requires_action und required_action.type ist submit_tool_outputs , kann dieser Endpunkt verwendet werden, um die Ausgänge aus den Tool -Aufrufen einzureichen, sobald sie alle abgeschlossen sind. Alle Ausgänge müssen in einer einzigen Anfrage eingereicht werden.
Notiz
Siehe Thread erstellen und streaming -Beispiel für das Stream -Tool -Ausgabeereignissen ausführen.
using var api = new OpenAIClient ( ) ;
var tools = new List < Tool >
{
// Use a predefined tool
Tool . Retrieval , Tool . CodeInterpreter ,
// Or create a tool from a type and the name of the method you want to use for function calling
Tool . GetOrCreateTool ( typeof ( WeatherService ) , nameof ( WeatherService . GetCurrentWeatherAsync ) ) ,
// Pass in an instance of an object to call a method on it
Tool . GetOrCreateTool ( api . ImagesEndPoint , nameof ( ImagesEndpoint . GenerateImageAsync ) ) ,
// Define func<,> callbacks
Tool . FromFunc ( " name_of_func " , ( ) => { /* callback function */ } ) ,
Tool . FromFunc < T1 , T2 , TResult > ( " func_with_multiple_params " , ( t1 , t2 ) => { /* logic that calculates return value */ return tResult ; } )
} ;
var assistantRequest = new CreateAssistantRequest ( tools : tools , instructions : " You are a helpful weather assistant. Use the appropriate unit based on geographical location. " ) ;
var testAssistant = await api . AssistantsEndpoint . CreateAssistantAsync ( assistantRequest ) ;
var run = await testAssistant . CreateThreadAndRunAsync ( " I'm in Kuala-Lumpur, please tell me what's the temperature now? " ) ;
// waiting while run is Queued and InProgress
run = await run . WaitForStatusChangeAsync ( ) ;
// Invoke all of the tool call functions and return the tool outputs.
var toolOutputs = await testAssistant . GetToolOutputsAsync ( run . RequiredAction . SubmitToolOutputs . ToolCalls ) ;
foreach ( var toolOutput in toolOutputs )
{
Console . WriteLine ( $" tool call output: { toolOutput . Output } " ) ;
}
// submit the tool outputs
run = await run . SubmitToolOutputsAsync ( toolOutputs ) ;
// waiting while run in Queued and InProgress
run = await run . WaitForStatusChangeAsync ( ) ;
var messages = await run . ListMessagesAsync ( ) ;
foreach ( var message in messages . Items . OrderBy ( response => response . CreatedAt ) )
{
Console . WriteLine ( $" { message . Role } : { message . PrintContent ( ) } " ) ;
} Strukturierte Ausgänge sind die Entwicklung des JSON -Modus. Während beide sicherstellen, dass ein gültiges JSON erzeugt wird, sorgen nur strukturierte Ausgänge für die Einhaltung von Schema.
Wichtig
finish_reason ist, was darauf hinweist, dass die Generation max_tokens oder die Konversation die Token -Grenze überschritten hat. Um sich dagegen zu schützen, überprüfen Sie finish_reason bevor Sie die Antwort analysieren.Definieren Sie zuerst die Struktur Ihrer Antworten. Diese werden als Ihr Schema verwendet. Dies sind die Objekte, zu denen Sie sich deserialisieren werden. Verwenden Sie daher unbedingt Standard -JSON -Objektmodelle.
public class MathResponse
{
[ JsonInclude ]
[ JsonPropertyName ( " steps " ) ]
public IReadOnlyList < MathStep > Steps { get ; private set ; }
[ JsonInclude ]
[ JsonPropertyName ( " final_answer " ) ]
public string FinalAnswer { get ; private set ; }
}
public class MathStep
{
[ JsonInclude ]
[ JsonPropertyName ( " explanation " ) ]
public string Explanation { get ; private set ; }
[ JsonInclude ]
[ JsonPropertyName ( " output " ) ]
public string Output { get ; private set ; }
} Geben Sie einfach den MathResponse -Typ als generische Einschränkung in CreateAssistantAsync , CreateRunAsync oder CreateThreadAndRunAsync .
using var api = new OpenAIClient ( ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync < MathResponse > (
new CreateAssistantRequest (
name : " Math Tutor " ,
instructions : " You are a helpful math tutor. Guide the user through the solution step by step. " ,
model : " gpt-4o-2024-08-06 " ) ) ;
ThreadResponse thread = null ;
try
{
async Task StreamEventHandler ( IServerSentEvent @event )
{
try
{
switch ( @event )
{
case MessageResponse message :
if ( message . Status != MessageStatus . Completed )
{
Console . WriteLine ( @event . ToJsonString ( ) ) ;
break ;
}
var mathResponse = message . FromSchema < MathResponse > ( ) ;
for ( var i = 0 ; i < mathResponse . Steps . Count ; i ++ )
{
var step = mathResponse . Steps [ i ] ;
Console . WriteLine ( $" Step { i } : { step . Explanation } " ) ;
Console . WriteLine ( $" Result: { step . Output } " ) ;
}
Console . WriteLine ( $" Final Answer: { mathResponse . FinalAnswer } " ) ;
break ;
default :
Console . WriteLine ( @event . ToJsonString ( ) ) ;
break ;
}
}
catch ( Exception e )
{
Console . WriteLine ( e ) ;
throw ;
}
await Task . CompletedTask ;
}
var run = await assistant . CreateThreadAndRunAsync ( " how can I solve 8x + 7 = -23 " , StreamEventHandler ) ;
thread = await run . GetThreadAsync ( ) ;
run = await run . WaitForStatusChangeAsync ( ) ;
Console . WriteLine ( $" Created thread and run: { run . ThreadId } -> { run . Id } -> { run . CreatedAt } " ) ;
var messages = await thread . ListMessagesAsync ( ) ;
foreach ( var response in messages . Items . OrderBy ( response => response . CreatedAt ) )
{
Console . WriteLine ( $" { response . Role } : { response . PrintContent ( ) } " ) ;
}
}
finally
{
await assistant . DeleteAsync ( deleteToolResources : thread == null ) ;
if ( thread != null )
{
var isDeleted = await thread . DeleteAsync ( deleteToolResources : true ) ;
}
}Sie können auch die JSON -Schema -JSON -String manuell erstellen, aber Sie sind für die Deserialisierung Ihrer Antwortdaten verantwortlich:
using var api = new OpenAIClient ( ) ;
var mathSchema = new JsonSchema ( " math_response " , @"
{
""type"": ""object"",
""properties"": {
""steps"": {
""type"": ""array"",
""items"": {
""type"": ""object"",
""properties"": {
""explanation"": {
""type"": ""string""
},
""output"": {
""type"": ""string""
}
},
""required"": [
""explanation"",
""output""
],
""additionalProperties"": false
}
},
""final_answer"": {
""type"": ""string""
}
},
""required"": [
""steps"",
""final_answer""
],
""additionalProperties"": false
}" ) ;
var assistant = await api . AssistantsEndpoint . CreateAssistantAsync (
new CreateAssistantRequest (
name : " Math Tutor " ,
instructions : " You are a helpful math tutor. Guide the user through the solution step by step. " ,
model : " gpt-4o-2024-08-06 " ,
jsonSchema : mathSchema ) ) ;
ThreadResponse thread = null ;
try
{
var run = await assistant . CreateThreadAndRunAsync ( " how can I solve 8x + 7 = -23 " ,
async @event =>
{
Console . WriteLine ( @event . ToJsonString ( ) ) ;
await Task . CompletedTask ;
} ) ;
thread = await run . GetThreadAsync ( ) ;
run = await run . WaitForStatusChangeAsync ( ) ;
Console . WriteLine ( $" Created thread and run: { run . ThreadId } -> { run . Id } -> { run . CreatedAt } " ) ;
var messages = await thread . ListMessagesAsync ( ) ;
foreach ( var response in messages . Items )
{
Console . WriteLine ( $" { response . Role } : { response . PrintContent ( ) } " ) ;
}
}
finally
{
await assistant . DeleteAsync ( deleteToolResources : thread == null ) ;
if ( thread != null )
{
var isDeleted = await thread . DeleteAsync ( deleteToolResources : true ) ;
Assert . IsTrue ( isDeleted ) ;
}
} Gibt eine Liste der Laufschritte zurück, die zu einem Lauf gehören.
using var api = new OpenAIClient ( ) ;
var runStepList = await api . ThreadsEndpoint . ListRunStepsAsync ( " thread-id " , " run-id " ) ;
// OR use extension method for convenience!
var runStepList = await run . ListRunStepsAsync ( ) ;
foreach ( var runStep in runStepList . Items )
{
Console . WriteLine ( $" [ { runStep . Id } ] { runStep . Status } { runStep . CreatedAt } -> { runStep . ExpiresAt } " ) ;
} Ruft einen Laufschritt ab.
using var api = new OpenAIClient ( ) ;
var runStep = await api . ThreadsEndpoint . RetrieveRunStepAsync ( " thread-id " , " run-id " , " step-id " ) ;
// OR use extension method for convenience!
var runStep = await run . RetrieveRunStepAsync ( " step-id " ) ;
var runStep = await runStep . UpdateAsync ( ) ;
Console . WriteLine ( $" [ { runStep . Id } ] { runStep . Status } { runStep . CreatedAt } -> { runStep . ExpiresAt } " ) ; Storniert einen Lauf, der in_progress ist.
using var api = new OpenAIClient ( ) ;
var isCancelled = await api . ThreadsEndpoint . CancelRunAsync ( " thread-id " , " run-id " ) ;
// OR use extension method for convenience!
var isCancelled = await run . CancelAsync ( ) ;
Assert . IsTrue ( isCancelled ) ; Vektorspeicher werden verwendet, um Dateien für das Tool file_search zu speichern.
Auf die Vektorspeicher -API wird über OpenAIClient.VectorStoresEndpoint zugegriffen
Gibt eine Liste von Vektorstors zurück.
using var api = new OpenAIClient ( ) ;
var vectorStores = await api . VectorStoresEndpoint . ListVectorStoresAsync ( ) ;
foreach ( var vectorStore in vectorStores . Items )
{
Console . WriteLine ( vectorStore ) ;
} Erstellen Sie einen Vektor Store.
using var api = new OpenAIClient ( ) ;
var createVectorStoreRequest = new CreateVectorStoreRequest ( " test-vector-store " ) ;
var vectorStore = await api . VectorStoresEndpoint . CreateVectorStoreAsync ( createVectorStoreRequest ) ;
Console . WriteLine ( vectorStore ) ; Ruft einen Vektor Store ab.
using var api = new OpenAIClient ( ) ;
var vectorStore = await api . VectorStoresEndpoint . GetVectorStoreAsync ( " vector-store-id " ) ;
Console . WriteLine ( vectorStore ) ; Modifiziert einen Vektor Store.
using var api = new OpenAIClient ( ) ;
var metadata = new Dictionary < string , object > { { " Test " , DateTime . UtcNow } } ;
var vectorStore = await api . VectorStoresEndpoint . ModifyVectorStoreAsync ( " vector-store-id " , metadata : metadata ) ;
Console . WriteLine ( vectorStore ) ; Löschen Sie einen Vektor Store.
using var api = new OpenAIClient ( ) ;
var isDeleted = await api . VectorStoresEndpoint . DeleteVectorStoreAsync ( " vector-store-id " ) ;
Assert . IsTrue ( isDeleted ) ; Vektorspeicherdateien stellen Dateien in einem Vektorspeicher dar.
Gibt eine Liste der Vektorspeicherdateien zurück.
using var api = new OpenAIClient ( ) ;
var files = await api . VectorStoresEndpoint . ListVectorStoreFilesAsync ( " vector-store-id " ) ;
foreach ( var file in vectorStoreFiles . Items )
{
Console . WriteLine ( file ) ;
} Erstellen Sie eine Vektorspeicherdatei, indem Sie eine Datei an einen Vektorspeicher anfügen.
using var api = new OpenAIClient ( ) ;
var file = await api . VectorStoresEndpoint . CreateVectorStoreFileAsync ( " vector-store-id " , " file-id " , new ChunkingStrategy ( ChunkingStrategyType . Static ) ) ;
Console . WriteLine ( file ) ; Ruft eine Vektorspeicherdatei ab.
using var api = new OpenAIClient ( ) ;
var file = await api . VectorStoresEndpoint . GetVectorStoreFileAsync ( " vector-store-id " , " vector-store-file-id " ) ;
Console . WriteLine ( file ) ; Löschen Sie eine Vektorspeicherdatei. Dadurch wird die Datei aus dem Vektorspeicher entfernt, die Datei selbst wird jedoch nicht gelöscht. Um die Datei zu löschen, verwenden Sie den Endpunkt der Datei löschen.
using var api = new OpenAIClient ( ) ;
var isDeleted = await api . VectorStoresEndpoint . DeleteVectorStoreFileAsync ( " vector-store-id " , vectorStoreFile ) ;
Assert . IsTrue ( isDeleted ) ; Vektorspeicherdateien stellen Dateien in einem Vektorspeicher dar.
Erstellen Sie eine Vektorspeicherdateistapel.
using var api = new OpenAIClient ( ) ;
var files = new List < string > { " file_id_1 " , " file_id_2 " } ;
var vectorStoreFileBatch = await api . VectorStoresEndpoint . CreateVectorStoreFileBatchAsync ( " vector-store-id " , files ) ;
Console . WriteLine ( vectorStoreFileBatch ) ; Ruft eine Vektorspeicherdatei -Stapel ab.
using var api = new OpenAIClient ( ) ;
var vectorStoreFileBatch = await api . VectorStoresEndpoint . GetVectorStoreFileBatchAsync ( " vector-store-id " , " vector-store-file-batch-id " ) ;
// you can also use convenience methods!
vectorStoreFileBatch = await vectorStoreFileBatch . UpdateAsync ( ) ;
vectorStoreFileBatch = await vectorStoreFileBatch . WaitForStatusChangeAsync ( ) ; Gibt eine Liste der Vektorspeicherdateien in einer Stapel zurück.
using var api = new OpenAIClient ( ) ;
var files = await api . VectorStoresEndpoint . ListVectorStoreBatchFilesAsync ( " vector-store-id " , " vector-store-file-batch-id " ) ;
foreach ( var file in files . Items )
{
Console . WriteLine ( file ) ;
} Stapel eines Vektorspeicherdatei. Dies versucht, die Verarbeitung von Dateien in diesem Stapel so schnell wie möglich zu stornieren.
using var api = new OpenAIClient ( ) ;
var isCancelled = await api . VectorStoresEndpoint . CancelVectorStoreFileBatchAsync ( " vector-store-id " , " vector-store-file-batch-id " ) ;Angesichts eines Chat -Gesprächs wird das Modell eine Reaktion des Chat -Abschlusses zurückgeben.
Die Chat -API wird über OpenAIClient.ChatEndpoint zugegriffen
Erstellt eine Fertigstellung für die Chat -Nachricht
using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
new Message ( Role . System , " You are a helpful assistant. " ) ,
new Message ( Role . User , " Who won the world series in 2020? " ) ,
new Message ( Role . Assistant , " The Los Angeles Dodgers won the World Series in 2020. " ) ,
new Message ( Role . User , " Where was it played? " ) ,
} ;
var chatRequest = new ChatRequest ( messages , Model . GPT4o ) ;
var response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
var choice = response . FirstChoice ;
Console . WriteLine ( $" [ { choice . Index } ] { choice . Message . Role } : { choice . Message } | Finish Reason: { choice . FinishReason } " ) ; using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
new Message ( Role . System , " You are a helpful assistant. " ) ,
new Message ( Role . User , " Who won the world series in 2020? " ) ,
new Message ( Role . Assistant , " The Los Angeles Dodgers won the World Series in 2020. " ) ,
new Message ( Role . User , " Where was it played? " ) ,
} ;
var chatRequest = new ChatRequest ( messages ) ;
var response = await api . ChatEndpoint . StreamCompletionAsync ( chatRequest , async partialResponse =>
{
Console . Write ( partialResponse . FirstChoice . Delta . ToString ( ) ) ;
await Task . CompletedTask ;
} ) ;
var choice = response . FirstChoice ;
Console . WriteLine ( $" [ { choice . Index } ] { choice . Message . Role } : { choice . Message } | Finish Reason: { choice . FinishReason } " ) ; Oder wenn IAsyncEnumerable{T} (C# 8.0+) verwendet wird
using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
new Message ( Role . System , " You are a helpful assistant. " ) ,
new Message ( Role . User , " Who won the world series in 2020? " ) ,
new Message ( Role . Assistant , " The Los Angeles Dodgers won the World Series in 2020. " ) ,
new Message ( Role . User , " Where was it played? " ) ,
} ;
var cumulativeDelta = string . Empty ;
var chatRequest = new ChatRequest ( messages ) ;
await foreach ( var partialResponse in api . ChatEndpoint . StreamCompletionEnumerableAsync ( chatRequest ) )
{
foreach ( var choice in partialResponse . Choices . Where ( choice => choice . Delta ? . Content != null ) )
{
cumulativeDelta += choice . Delta . Content ;
}
}
Console . WriteLine ( cumulativeDelta ) ; using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
new ( Role . System , " You are a helpful weather assistant. Always prompt the user for their location. " ) ,
new Message ( Role . User , " What's the weather like today? " ) ,
} ;
foreach ( var message in messages )
{
Console . WriteLine ( $" { message . Role } : { message } " ) ;
}
// Define the tools that the assistant is able to use:
// 1. Get a list of all the static methods decorated with FunctionAttribute
var tools = Tool . GetAllAvailableTools ( includeDefaults : false , forceUpdate : true , clearCache : true ) ;
// 2. Define a custom list of tools:
var tools = new List < Tool >
{
Tool . GetOrCreateTool ( objectInstance , " TheNameOfTheMethodToCall " ) ,
Tool . FromFunc ( " a_custom_name_for_your_function " , ( ) => { /* Some logic to run */ } )
} ;
var chatRequest = new ChatRequest ( messages , tools : tools , toolChoice : " auto " ) ;
var response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
messages . Add ( response . FirstChoice . Message ) ;
Console . WriteLine ( $" { response . FirstChoice . Message . Role } : { response . FirstChoice } | Finish Reason: { response . FirstChoice . FinishReason } " ) ;
var locationMessage = new Message ( Role . User , " I'm in Glasgow, Scotland " ) ;
messages . Add ( locationMessage ) ;
Console . WriteLine ( $" { locationMessage . Role } : { locationMessage . Content } " ) ;
chatRequest = new ChatRequest ( messages , tools : tools , toolChoice : " auto " ) ;
response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
messages . Add ( response . FirstChoice . Message ) ;
if ( response . FirstChoice . FinishReason == " stop " )
{
Console . WriteLine ( $" { response . FirstChoice . Message . Role } : { response . FirstChoice } | Finish Reason: { response . FirstChoice . FinishReason } " ) ;
var unitMessage = new Message ( Role . User , " Fahrenheit " ) ;
messages . Add ( unitMessage ) ;
Console . WriteLine ( $" { unitMessage . Role } : { unitMessage . Content } " ) ;
chatRequest = new ChatRequest ( messages , tools : tools , toolChoice : " auto " ) ;
response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
}
// iterate over all tool calls and invoke them
foreach ( var toolCall in response . FirstChoice . Message . ToolCalls )
{
Console . WriteLine ( $" { response . FirstChoice . Message . Role } : { toolCall . Function . Name } | Finish Reason: { response . FirstChoice . FinishReason } " ) ;
Console . WriteLine ( $" { toolCall . Function . Arguments } " ) ;
// Invokes function to get a generic json result to return for tool call.
var functionResult = await toolCall . InvokeFunctionAsync ( ) ;
// If you know the return type and do additional processing you can use generic overload
var functionResult = await toolCall . InvokeFunctionAsync < string > ( ) ;
messages . Add ( new Message ( toolCall , functionResult ) ) ;
Console . WriteLine ( $" { Role . Tool } : { functionResult } " ) ;
}
// System: You are a helpful weather assistant.
// User: What's the weather like today?
// Assistant: Sure, may I know your current location? | Finish Reason: stop
// User: I'm in Glasgow, Scotland
// Assistant: GetCurrentWeather | Finish Reason: tool_calls
// {
// "location": "Glasgow, Scotland",
// "unit": "celsius"
// }
// Tool: The current weather in Glasgow, Scotland is 39°C. Warnung
Beta -Funktion. API unterliegt den Veränderungen.
using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
new Message ( Role . System , " You are a helpful assistant. " ) ,
new Message ( Role . User , new List < Content >
{
" What's in this image? " ,
new ImageUrl ( " https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg " , ImageDetail . Low )
} )
} ;
var chatRequest = new ChatRequest ( messages , model : Model . GPT4o ) ;
var response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
Console . WriteLine ( $" { response . FirstChoice . Message . Role } : { response . FirstChoice . Message . Content } | Finish Reason: { response . FirstChoice . FinishDetails } " ) ; using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
new Message ( Role . System , " You are a helpful assistant. " ) ,
new Message ( Role . User , " Is a golden retriever a good family dog? " )
} ;
var chatRequest = new ChatRequest ( messages , Model . GPT4oAudio , audioConfig : Voice . Alloy ) ;
var response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
Console . WriteLine ( $" { response . FirstChoice . Message . Role } : { response . FirstChoice } | Finish Reason: { response . FirstChoice . FinishDetails } " ) ;
// todo play response.FirstChoice.Message.AudioOutput.Data Die Entwicklung des JSON -Modus. Während beide sicherstellen, dass ein gültiges JSON erzeugt wird, sorgen nur strukturierte Ausgänge für die Einhaltung von Schema.
Wichtig
finish_reason ist, was darauf hinweist, dass die Generation max_tokens oder die Konversation die Token -Grenze überschritten hat. Um sich dagegen zu schützen, überprüfen Sie finish_reason bevor Sie die Antwort analysieren.Definieren Sie zuerst die Struktur Ihrer Antworten. Diese werden als Ihr Schema verwendet. Dies sind die Objekte, zu denen Sie sich deserialisieren werden. Verwenden Sie daher unbedingt Standard -JSON -Objektmodelle.
public class MathResponse
{
[ JsonInclude ]
[ JsonPropertyName ( " steps " ) ]
public IReadOnlyList < MathStep > Steps { get ; private set ; }
[ JsonInclude ]
[ JsonPropertyName ( " final_answer " ) ]
public string FinalAnswer { get ; private set ; }
}
public class MathStep
{
[ JsonInclude ]
[ JsonPropertyName ( " explanation " ) ]
public string Explanation { get ; private set ; }
[ JsonInclude ]
[ JsonPropertyName ( " output " ) ]
public string Output { get ; private set ; }
} Um zu verwenden, geben Sie einfach den MathResponse -Typ als generische Einschränkung an, wenn Sie eine Fertigstellung beantragen.
using var api = new OpenAIClient ( ) ;
var messages = new List < Message >
{
new ( Role . System , " You are a helpful math tutor. Guide the user through the solution step by step. " ) ,
new ( Role . User , " how can I solve 8x + 7 = -23 " )
} ;
var chatRequest = new ChatRequest ( messages , model : " gpt-4o-2024-08-06 " ) ;
var ( mathResponse , chatResponse ) = await api . ChatEndpoint . GetCompletionAsync < MathResponse > ( chatRequest ) ;
for ( var i = 0 ; i < mathResponse . Steps . Count ; i ++ )
{
var step = mathResponse . Steps [ i ] ;
Console . WriteLine ( $" Step { i } : { step . Explanation } " ) ;
Console . WriteLine ( $" Result: { step . Output } " ) ;
}
Console . WriteLine ( $" Final Answer: { mathResponse . FinalAnswer } " ) ;
chatResponse . GetUsage ( ) ; Wichtig
finish_reason ist, was darauf hinweist, dass die Generation max_tokens oder die Konversation die Token -Grenze überschritten hat. Um sich dagegen zu schützen, überprüfen Sie finish_reason bevor Sie die Antwort analysieren. var messages = new List < Message >
{
new Message ( Role . System , " You are a helpful assistant designed to output JSON. " ) ,
new Message ( Role . User , " Who won the world series in 2020? " ) ,
} ;
var chatRequest = new ChatRequest ( messages , Model . GPT4o , responseFormat : ChatResponseFormat . Json ) ;
var response = await api . ChatEndpoint . GetCompletionAsync ( chatRequest ) ;
foreach ( var choice in response . Choices )
{
Console . WriteLine ( $" [ { choice . Index } ] { choice . Message . Role } : { choice } | Finish Reason: { choice . FinishReason } " ) ;
}
response . GetUsage ( ) ;Konvertiert Audio in Text.
Die Audio -API wird über OpenAIClient.AudioEndpoint zugegriffen
Generiert Audio aus dem Eingabtext.
using var api = new OpenAIClient ( ) ;
var request = new SpeechRequest ( " Hello World! " ) ;
async Task ChunkCallback ( ReadOnlyMemory < byte > chunkCallback )
{
// TODO Implement audio playback as chunks arrive
await Task . CompletedTask ;
}
var response = await api . AudioEndpoint . CreateSpeechAsync ( request , ChunkCallback ) ;
await File . WriteAllBytesAsync ( " ../../../Assets/HelloWorld.mp3 " , response . ToArray ( ) ) ; Transkribiert Audio in die Eingabessprache.
using var api = new OpenAIClient ( ) ;
using var request = new AudioTranscriptionRequest ( Path . GetFullPath ( audioAssetPath ) , language : " en " ) ;
var response = await api . AudioEndpoint . CreateTranscriptionTextAsync ( request ) ;
Console . WriteLine ( response ) ; Sie können auch detaillierte Informationen verwenden, die mit verbose_json aus detaillierten Informationen erhalten, um Zeitstempelgranularitäten zu erhalten:
using var api = new OpenAIClient ( ) ;
using var request = new AudioTranscriptionRequest ( transcriptionAudio , responseFormat : AudioResponseFormat . Verbose_Json , timestampGranularity : TimestampGranularity . Word , temperature : 0.1f , language : " en " ) ;
var response = await api . AudioEndpoint . CreateTranscriptionTextAsync ( request ) ;
foreach ( var word in response . Words )
{
Console . WriteLine ( $" [ { word . Start } - { word . End } ] " { word . Word } " " ) ;
} Übersetzt Audio ins Englische.
using var api = new OpenAIClient ( ) ;
using var request = new AudioTranslationRequest ( Path . GetFullPath ( audioAssetPath ) ) ;
var response = await api . AudioEndpoint . CreateTranslationTextAsync ( request ) ;
Console . WriteLine ( response ) ;Bei einer Eingabeaufforderung und/oder einem Eingabebild erzeugt das Modell ein neues Bild.
Auf die Bilder -API wird über OpenAIClient.ImagesEndpoint zugegriffen
Erstellt ein Bild, das eine Eingabeaufforderung erstellt.
using var api = new OpenAIClient ( ) ;
var request = new ImageGenerationRequest ( " A house riding a velociraptor " , Models . Model . DallE_3 ) ;
var imageResults = await api . ImagesEndPoint . GenerateImageAsync ( request ) ;
foreach ( var image in imageResults )
{
Console . WriteLine ( image ) ;
// image == url or b64_string
} Erstellt ein bearbeitetes oder erweitertes Bild mit einem Originalbild und einer Eingabeaufforderung.
using var api = new OpenAIClient ( ) ;
var request = new ImageEditRequest ( imageAssetPath , maskAssetPath , " A sunlit indoor lounge area with a pool containing a flamingo " , size : ImageSize . Small ) ;
var imageResults = await api . ImagesEndPoint . CreateImageEditAsync ( request ) ;
foreach ( var image in imageResults )
{
Console . WriteLine ( image ) ;
// image == url or b64_string
} Erstellt eine Variation eines bestimmten Bildes.
using var api = new OpenAIClient ( ) ;
var request = new ImageVariationRequest ( imageAssetPath , size : ImageSize . Small ) ;
var imageResults = await api . ImagesEndPoint . CreateImageVariationAsync ( request ) ;
foreach ( var image in imageResults )
{
Console . WriteLine ( image ) ;
// image == url or b64_string
}Dateien werden verwendet, um Dokumente hochzuladen, die mit Funktionen wie Feinabstimmungen verwendet werden können.
Auf die Dateien -API wird über OpenAIClient.FilesEndpoint zugegriffen
Gibt eine Liste von Dateien zurück, die zur Organisation des Benutzers gehören.
using var api = new OpenAIClient ( ) ;
var fileList = await api . FilesEndpoint . ListFilesAsync ( ) ;
foreach ( var file in fileList )
{
Console . WriteLine ( $" { file . Id } -> { file . Object } : { file . FileName } | { file . Size } bytes " ) ;
} Laden Sie eine Datei hoch, die für verschiedene Endpunkte verwendet werden kann. Die Größe aller von einer Organisation hochgeladenen Dateien kann bis zu 100 GB betragen.
Die Größe einzelner Dateien kann maximal 512 MB betragen. Weitere Informationen zu den unterstützten Dateien finden Sie im Handbuch für Assistants Tools. Die Feinabstimmungs-API unterstützt nur .jsonl-Dateien.
using var api = new OpenAIClient ( ) ;
var file = await api . FilesEndpoint . UploadFileAsync ( " path/to/your/file.jsonl " , FilePurpose . FineTune ) ;
Console . WriteLine ( file . Id ) ; Löschen Sie eine Datei.
using var api = new OpenAIClient ( ) ;
var isDeleted = await api . FilesEndpoint . DeleteFileAsync ( fileId ) ;
Assert . IsTrue ( isDeleted ) ; Gibt Informationen zu einer bestimmten Datei zurück.
using var api = new OpenAIClient ( ) ;
var file = await api . FilesEndpoint . GetFileInfoAsync ( fileId ) ;
Console . WriteLine ( $" { file . Id } -> { file . Object } : { file . FileName } | { file . Size } bytes " ) ; Laden Sie den Dateiinhalt in das angegebene Verzeichnis herunter.
using var api = new OpenAIClient ( ) ;
var downloadedFilePath = await api . FilesEndpoint . DownloadFileAsync ( fileId , " path/to/your/save/directory " ) ;
Console . WriteLine ( downloadedFilePath ) ;
Assert . IsTrue ( File . Exists ( downloadedFilePath ) ) ;Verwalten Sie Feinabstimmungsjobs, um ein Modell auf Ihre spezifischen Trainingsdaten anzupassen.
Verwandte Leitfaden: Fein-Tune-Modelle
Auf die Dateien -API wird über OpenAIClient.FineTuningEndpoint zugegriffen
Erstellt einen Job, der ein bestimmtes Modell aus einem bestimmten Datensatz fein abgestimmt.
Die Antwort enthält Details des auftretenden Jobs, einschließlich des Arbeitsstatus und des Namens der fein abgestimmten Modelle, sobald er abgeschlossen ist.
using var api = new OpenAIClient ( ) ;
var fileId = " file-abc123 " ;
var request = new CreateFineTuneRequest ( fileId ) ;
var job = await api . FineTuningEndpoint . CreateJobAsync ( Model . GPT3_5_Turbo , request ) ;
Console . WriteLine ( $" Started { job . Id } | Status: { job . Status } " ) ; Listen Sie die Feinabstimmung Ihrer Organisation auf.
using var api = new OpenAIClient ( ) ;
var jobList = await api . FineTuningEndpoint . ListJobsAsync ( ) ;
foreach ( var job in jobList . Items . OrderByDescending ( job => job . CreatedAt ) )
{
Console . WriteLine ( $" { job . Id } -> { job . CreatedAt } | { job . Status } " ) ;
} Erhält Informationen über den Feinabsteig-Job.
using var api = new OpenAIClient ( ) ;
var job = await api . FineTuningEndpoint . GetJobInfoAsync ( fineTuneJob ) ;
Console . WriteLine ( $" { job . Id } -> { job . CreatedAt } | { job . Status } " ) ; Stornieren Sie sofort einen Feinabstiegsjob.
using var api = new OpenAIClient ( ) ;
var isCancelled = await api . FineTuningEndpoint . CancelFineTuneJobAsync ( fineTuneJob ) ;
Assert . IsTrue ( isCancelled ) ; Erhalten Sie Statusaktualisierungen für einen feinen Auftrag.
using var api = new OpenAIClient ( ) ;
var eventList = await api . FineTuningEndpoint . ListJobEventsAsync ( fineTuneJob ) ;
Console . WriteLine ( $" { fineTuneJob . Id } -> status: { fineTuneJob . Status } | event count: { eventList . Events . Count } " ) ;
foreach ( var @event in eventList . Items . OrderByDescending ( @event => @event . CreatedAt ) )
{
Console . WriteLine ( $" { @event . CreatedAt } [ { @event . Level } ] { @event . Message } " ) ;
}Erstellen Sie große Chargen von API -Anfragen für die asynchrone Verarbeitung. Die Batch -API kehrt den Abschluss innerhalb von 24 Stunden für einen Rabatt von 50% zurück.
Die API -Charge wird über OpenAIClient.BatchesEndpoint zugegriffen
Listen Sie die Chargen Ihrer Organisation auf.
using var api = new OpenAIClient ( ) ;
var batches = await api . BatchEndpoint . ListBatchesAsync ( ) ;
foreach ( var batch in listResponse . Items )
{
Console . WriteLine ( batch ) ;
} Erstellt und führt eine Stapel aus einer hochgeladenen Datei mit Anfragen aus
using var api = new OpenAIClient ( ) ;
var batchRequest = new CreateBatchRequest ( " file-id " , Endpoint . ChatCompletions ) ;
var batch = await api . BatchEndpoint . CreateBatchAsync ( batchRequest ) ; Ruft eine Charge ab.
using var api = new OpenAIClient ( ) ;
var batch = await api . BatchEndpoint . RetrieveBatchAsync ( " batch-id " ) ;
// you can also use convenience methods!
batch = await batch . UpdateAsync ( ) ;
batch = await batch . WaitForStatusChangeAsync ( ) ; Stapeln Sie eine In-Progress-Stapel. Die Stapel wird in der Statusstornierung für bis zu 10 Minuten vor dem Wechsel zu storniert sein, wo in der Ausgabedatei teilweise Ergebnisse (falls vorhanden) verfügbar sind.
using var api = new OpenAIClient ( ) ;
var isCancelled = await api . BatchEndpoint . CancelBatchAsync ( batch ) ;
Assert . IsTrue ( isCancelled ) ;Erhalten Sie eine Vektordarstellung eines bestimmten Eingangs, der leicht von Modellen und Algorithmen für maschinelle Lernen konsumiert werden kann.
Verwandte Leitfaden: Einbettungen
Die Änderungspunkte von OpenAIClient.EmbeddingsEndpoint ist auf die API von Änderungen zugegriffen
Erstellt einen Einbettungsvektor, der den Eingabtext darstellt.
using var api = new OpenAIClient ( ) ;
var response = await api . EmbeddingsEndpoint . CreateEmbeddingAsync ( " The food was delicious and the waiter... " , Models . Embedding_Ada_002 ) ;
Console . WriteLine ( response ) ;Bei einem Eingabetxt gibt Ausgänge aus, wenn das Modell es als Verstoß gegen OpenAIs Inhaltspolitik klassifiziert.
Verwandte Anleitung: Moderationen
Auf die Moderationen -API kann über OpenAIClient.ModerationsEndpoint zugegriffen werden
Klassifiziert, ob der Text gegen die Inhaltspolitik von OpenAI verstößt.
using var api = new OpenAIClient ( ) ;
var isViolation = await api . ModerationsEndpoint . GetModerationAsync ( " I want to kill them. " ) ;
Assert . IsTrue ( isViolation ) ;Zusätzlich können Sie auch die Punktzahlen eines bestimmten Eingangs erhalten.
using var api = new OpenAIClient ( ) ;
var response = await api . ModerationsEndpoint . CreateModerationAsync ( new ModerationsRequest ( " I love you " ) ) ;
Assert . IsNotNull ( response ) ;
Console . WriteLine ( response . Results ? [ 0 ] ? . Scores ? . ToString ( ) ) ;
