DelphiOpenAI

If you are using a compatible third-party API (like GigaChat) that requires specific authentication steps or headers before making a request, implement the IAPIPrepare interface and assign it to the Prepare property of your client instance.

var client := TOpenAI.Create('https://gigachat.devices.sberbank.ru/api/v1', '');
client.Prepare := TApiPrepareGigaChat.Create(
  '<client_id>',
  '<auth_key>');
var response := client.Chat.Create(...);

You can install the library using one of two methods:

1. GetIt: Install directly from the IDE using the GetIt package manager.
2. Manual: Add the root folder of the repository to your IDE library path or your project's source path.

# No specific CLI command, use GetIt in Delphi IDE

To use the library, you must first obtain an API token from your OpenAI organization. The TOpenAI class (or TOpenAIComponent) serves as the entry point. Configuration is handled via anonymous functions to manage the various optional parameters.

Note: You can use either the component-based approach or the interface-based approach.

uses OpenAI;

// Component approach
var OpenAI := TOpenAIComponent.Create(Self, API_TOKEN);

// Interface approach
var OpenAI: IOpenAI := TOpenAI.Create(API_TOKEN);

To receive responses in real-time as they are generated, use Chat.CreateStream. This method accepts two anonymous functions: one for configuring the request and one for handling the incoming stream of data (chunks).

OpenAI.Chat.CreateStream(
  procedure(Params: TChatParams)
  begin
    Params.Messages([TchatMessageBuild.User(Buf.Text)]);
    Params.MaxTokens(1024);
    Params.Stream;
  end,
  procedure(Chat: TChat; IsDone: Boolean; var Cancel: Boolean)
  begin
    if (not IsDone) and Assigned(Chat) then
      Writeln(Chat.Choices[0].Delta.Content)
    else if IsDone then
      Writeln('DONE!');
    Writeln('-------');
    Sleep(100);
  end);

Use Image.Create to generate images from a text prompt. You can specify the ResponseFormat (e.g., 'url').

var Images := OpenAI.Image.Create(
  procedure(Params: TImageCreateParams)
  begin
    Params.Prompt(MemoPrompt.Text);
    Params.ResponseFormat('url');
  end);
try
  for var Image in Images.Data do
    Image1.Bitmap.LoadFromUrl(Image.Url);
finally
  Images.Free;
end;

The Completion.Create method allows you to generate text completions based on a prompt. Parameters like Prompt and MaxTokens are configured within an anonymous function.

var Completions := OpenAI.Completion.Create(
  procedure(Params: TCompletionParams)
  begin
    Params.Prompt(MemoPrompt.Text);
    Params.MaxTokens(2048);
  end);
try
  for var Choice in Completions.Choices do
    MemoChat.Lines.Add(Choice.Index.ToString + ' ' + Choice.Text);
finally
  Completions.Free;
end;

Use the Model.List() method to retrieve a list of available models from the API. Remember to free the returned object to prevent memory leaks.

var Models := OpenAI.Model.List();
try
  for var Model in Models.Data do
    MemoChat.Lines.Add(Model.Id);
finally
  Models.Free;
end;

If you need to route your API requests through a proxy, configure the OpenAI.API.ProxySettings property using a TProxySettings instance.

OpenAI.API.ProxySettings := TProxySettings.Create(
    ProxyHost,
    ProxyPort,
    ProxyUserName,
    ProxyPassword);

For models supporting vision (e.g., gpt-4-vision-preview), you can pass a combination of text and images in the messages. Use TMessageContent.CreateText and TMessageContent.CreateImage (which accepts a Base64 string) to build the content array.

var Chat := OpenAI.Chat.Create(
  procedure(Params: TChatParams)
  begin
    Params.Model('gpt-4-vision-preview');

    var Content: TArray<TMessageContent>;
    Content := Content + [TMessageContent.CreateText(Text)];
    Content := Content + [TMessageContent.CreateImage(FileToBase64('file path'))];

    Params.Messages([TChatMessageBuild.User(Content)]);
    Params.MaxTokens(1024);
  end);
try
  for var Choice in Chat.Choices do
    MemoChat.Lines.Add(Choice.Message.Content);
finally
  Chat.Free;
end;

The Chat.Create method is used for conversational models (like GPT-3.5/4). You define the conversation history using Messages and set parameters like MaxTokens via an anonymous function.

var Chat := OpenAI.Chat.Create(
  procedure(Params: TChatParams)
  begin
    Params.Messages([TChatMessageBuild.Create(TMessageRole.User, Text)]);
    Params.MaxTokens(1024);
  end);
try
  for var Choice in Chat.Choices do
    MemoChat.Lines.Add(Choice.Message.Content);
finally
  Chat.Free;
end;

The library uses a hierarchy of exceptions to handle API errors. You should wrap your requests in try...except blocks to catch specific error types like rate limits or authentication issues.

Common Exception Types:

• OpenAIException (Base class)
• OpenAIExceptionAPI (Wrapper errors)
• OpenAIExceptionInvalidRequestError
• OpenAIExceptionRateLimitError
• OpenAIExceptionAuthenticationError
• OpenAIExceptionPermissionError
• OpenAIExceptionTryAgain
• OpenAIExceptionInvalidResponse (Parse errors)

try
  var Images := OpenAI.Image.Create(...);
except
  on E: OpenAIExceptionRateLimitError do
    ShowError('OpenAI Limit Error: ' + E.Message);
  on E: OpenAIException do
    ShowError('OpenAI Error: ' + E.Message);  
end;