(Delphi ActiveX) Streaming AI with Manual AI Tool Function Calling

See more AI Examples

Note: This example requires Chilkat v11.4.0 or greater.

For more information, see https://www.chilkatsoft.com/ai_tool_function_caling_briefly_explained.asp

Chilkat for Delphi Downloads Chilkat ActiveX DLL for Delphi Chilkat non-ActiveX DLL for Delphi * The examples here use the ActiveX DLL.

uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Chilkat_TLB;

...

procedure TForm1.Button1Click(Sender: TObject);
var
success: Integer;
jsonTools: TChilkatJsonObject;
toolIdx: Integer;
ai: TChilkatAi;
conversation_name: WideString;
sysMessage: WideString;
devMessage: WideString;
sbEventName: TChilkatStringBuilder;
sbDelta: TChilkatStringBuilder;
sbFullResponse: TChilkatStringBuilder;
maxWaitMs: Integer;
jsonFn: TChilkatJsonObject;
finished: Integer;
numAsks: Integer;
madeFunctionCalls: Integer;
streamingDone: Integer;
result: Integer;
numFnCalls: Integer;
fn_idx: Integer;
sbFnName: TChilkatStringBuilder;
callId: WideString;
zodiac_sign: WideString;
applicationFnCallResult: WideString;

begin
success := 0;

// Create the following JSON to define tool functions available for the AI to use.
// Note: You'll use the following JSON format regardless of the AI provider, whether
// it be ChatGPT, Gemini, Claude, Grok, etc.  Chilkat automatically converts to the required
// format needed for a given AI provider.

// In this example, the application is providing a single function the AI may choose to call.

// {
//   "tools": [
//     {
//       "name": "get_horoscope",
//       "description": "Get today's horoscope for an astrological sign.",
//       "parameters": {
//         "properties": {
//           "sign": {
//             "type": "string",
//             "description": "An astrological sign like Taurus or Aquarius"
//           }
//         }
//       }
//     }
//   ]
// }

jsonTools := TChilkatJsonObject.Create(Self);

toolIdx := 0;

jsonTools.I := toolIdx;
jsonTools.UpdateString('tools[i].name','get_horoscope');
jsonTools.UpdateString('tools[i].description','Get today''s horoscope for an astrological sign.');
jsonTools.UpdateString('tools[i].parameters.properties.sign.type','string');
jsonTools.UpdateString('tools[i].parameters.properties.sign.description','An astrological sign like Taurus or Aquarius');
// More tools can be added as desired..

jsonTools.EmitCompact := 0;
Memo1.Lines.Add(jsonTools.Emit());

ai := TChilkatAi.Create(Self);

// Register the tools that will be made available to the AI.
ai.RegisterManualTools(jsonTools.ControlInterface);

// The provider can be "openai", "google", "claude", "grok", "mistral", "custom", etc.
ai.Provider := 'openai';
// Use your provider's API key.
ai.ApiKey := 'MY_API_KEY';
// Choose a model.
ai.Model := 'gpt-5-mini';

// Tool function calling must always occur within a conversation.
conversation_name := 'convo_astrology';
sysMessage := 'You are a helpful astrologer';
devMessage := 'Respond only with markdown.';
ai.NewConvo(conversation_name,sysMessage,devMessage);

// Provide inputs
ai.InputAddText('What is my horoscope? I am an Aquarius.');

// Get the response in streaming mode.
ai.Streaming := 1;

// In streaming mode, if we receive an AI event that is a request for tool use,
// we'll need to make the call to the JavaScript and then continue with a followup Ask,
// until the final response is received.

sbEventName := TChilkatStringBuilder.Create(Self);
sbDelta := TChilkatStringBuilder.Create(Self);
sbFullResponse := TChilkatStringBuilder.Create(Self);

// When PollAi returns with an event, it's highly unlikely the
// call to NextAiEvent does not immediately return.  Setting a max
// timeout is just a precaution..
maxWaitMs := 5000;

jsonFn := TChilkatJsonObject.Create(Self);

finished := 0;
numAsks := 0;
// Set a max # of followup Asks to prevent any unexpected infinite looping.
while not finished and (numAsks < 10) do
  begin

    // Send the request to the AI model.
    success := ai.Ask('text');
    if (success = 0) then
      begin
        Memo1.Lines.Add(ai.LastErrorText);
        Exit;
      end;

    madeFunctionCalls := 0;
    streamingDone := 0;

    while not streamingDone do
      begin
        result := ai.PollAi(0);
        if (result < 0) then
          begin
            Memo1.Lines.Add(ai.LastErrorText);
            Memo1.Lines.Add('Failed.');
            Exit;
          end;
        if (result > 0) then
          begin
            // We have an event..
            success := ai.NextAiEvent(maxWaitMs,sbEventName.ControlInterface,sbDelta.ControlInterface);
            if (success = 0) then
              begin
                Memo1.Lines.Add(ai.LastErrorText);
                Exit;
              end;

            // Is this an event where the AI is requesting a function call?
            if (sbEventName.ContentsEqual('function_call',1)) then
              begin
                jsonFn.LoadSb(sbDelta.ControlInterface);

                // Note: Chilkat will convert responses from all AI providers to this format:

                // {
                //   "function_call": [
                //     {
                //       "name": "get_horoscope",
                //       "call_id": "call_RYmeysYQFocFc7Z2ofkv61dW",
                //       "arguments": "{\"sign\":\"Aquarius\"}",
                //       "args": {
                //         "sign": "Aquarius"
                //       }
                //     }
                //   ]
                // }

                numFnCalls := jsonFn.SizeOfArray('function_call');
                fn_idx := 0;
                while (fn_idx < numFnCalls) do
                  begin
                    jsonFn.I := fn_idx;

                    sbFnName := TChilkatStringBuilder.Create(Self);
                    jsonFn.StringOfSb('function_call[i].name',sbFnName.ControlInterface);
                    callId := jsonFn.StringOf('function_call[i].call_id');

                    if (sbFnName.ContentsEqual('get_horoscope',1) = 1) then
                      begin

                        // The get_horoscope function (as defined above) has one argument named "sign".
                        zodiac_sign := jsonFn.StringOf('function_call[i].args.sign');
                        Memo1.Lines.Add('zodiac_sign = ' + zodiac_sign);

                        // Insert application code here to call your app's get_horoscope function, passing the zodiac_sign to it..

                        // For this example, we'll pretend the app's get_horoscope function returned the following:
                        applicationFnCallResult := 'Aquarius: Next Tuesday you will befriend a baby otter.';

                        // Provide the tool call result as an input for the followup Ask.
                        ai.InputAddFnResult(callId,applicationFnCallResult);

                        madeFunctionCalls := 1;
                      end;
                    // Your application would add code to check for and handle each possible function call.

                    fn_idx := fn_idx + 1;
                  end;

              end
            else
              begin
                if (not sbEventName.ContentsEqual('empty',1)) then
                  begin
                    sbFullResponse.AppendSb(sbDelta.ControlInterface);

                    if (sbEventName.ContentsEqual('null_terminator',1)) then
                      begin
                        streamingDone := 1;
                      end;
                  end;
              end;

          end
        else
          begin
            // No event arrived, so wait a short time rather than spin in a loop..
            ai.SleepMs(100);
          end;

      end;

    if (not madeFunctionCalls) then
      begin
        finished := 1;
      end;

    numAsks := numAsks + 1;
  end;

Memo1.Lines.Add('Full Response:');
Memo1.Lines.Add(sbFullResponse.GetAsString());
end;