ChatGPT Completions With C#

using System.Text.Json.Serialization;
public class CompletionRequest {
    [JsonPropertyName("model")]
    public string ? Model {
            get;
            set;
        }
        [JsonPropertyName("prompt")]
    public string ? Prompt {
            get;
            set;
        }
        [JsonPropertyName("max_tokens")]
    public int ? MaxTokens {
        get;
        set;
    }
}

The response class is defined in the code attached to this article. It's too lengthy to include in total. We'll focus on the response text as well as the tokens.

public class CompletionResponse {
    [JsonPropertyName("choices")]
    public List < ChatGPTChoice > ? Choices {
            get;
            set;
        }
        [JsonPropertyName("usage")]
    public ChatGPTUsage ? Usage {
        get;
        set;
    }
}
public class ChatGPTUsage {
    [JsonPropertyName("prompt_tokens")]
    public int PromptTokens {
        get;
        set;
    }
    [JsonPropertyName("completion_token")]
    public int CompletionTokens {
        get;
        set;
    }
    [JsonPropertyName("total_tokens")]
    public int TotalTokens {
        get;
        set;
    }
}
[DebuggerDisplay("Text = {Text}")]
public class ChatGPTChoice {
    [JsonPropertyName("text")]
    public string ? Text {
        get;
        set;
    }
}

So, let's put the quest together and make the completion request.

CompletionRequest completionRequest = new CompletionRequest {
    Model = "text-davinci-003",
        Prompt = "What if Nicholas Cage played the lead role in Superman?",
        MaxTokens = 120
};
using(HttpClient httpClient = new HttpClient()) {
        using(var httpReq = new HttpRequestMessage(HttpMethod.Post, "https://api.openai.com/v1/completions")) {
                httpReq.Headers.Add("Authorization", $ "Bearer {apiKey}");
                string requestString = JsonSerializer.Serialize(completionRequest);
                httpReq.Content = new StringContent(requestString, Encoding.UTF8, "application/json");
                using(HttpResponseMessage ? httpResponse = await httpClient.SendAsync(httpReq)) {
                    if (httpResponse is not null) {
                        if (httpResponse.IsSuccessStatusCode) {
                            string responseString = await httpResponse.Content.ReadAsStringAsync(); {
                                if (!string.IsNullOrWhiteSpace(responseString)) {
                                    completionResponse = JsonSerializer.Deserialize < CompletionResponse > (responseString);
                                }
                            }
                        }
                    }
                    if (completionResponse is not null) {
                        string ? completionText = completionResponse.Choices ? [0]?.Text;
                        Console.WriteLine(completionText);
                    }
                }

ChatGPT is nondeterministic, so your response will vary. While testing, this call returned,

If Nicholas Cage had played the role of Superman, it would have been a very strange take on the superhero character. He would have likely brought an unexpected, quirky energy to the role that could have been interesting to watch. It also would have added a layer of comedy to the story and made the character more relatable.

This consumed a total of 10 tokens to process the prompt request and 66 tokens to generate the response.

Building a Chat Bot

So far, we've just sent a question directly to the text-davinci-003 model. Embellishing the prompt with more information can drive the response. For example, we could emulate the behavior of Marvin the sarcastic robot from Hitchhiker's Guild to the Galaxy by creating the following prompt,

StringBuilder promptBuilder = new();
promptBuilder.AppendLine("Marv is a chatbot that reluctantly answers questions with sarcastic responses:");
promptBuilder.AppendLine();
promptBuilder.AppendLine("You: How many pounds are in a kilogram?");
promptBuilder.AppendLine("Marv: This again? There are 2.2 pounds in a kilogram. Please make a note of this.");
promptBuilder.AppendLine("You: What does HTML stand for?");
promptBuilder.AppendLine("Marv: Was Google too busy? Hypertext Markup Language. The T is for try to ask better questions in the future.");
promptBuilder.AppendLine("You: When did the first airplane fly?");
promptBuilder.AppendLine("Marv: On December 17, 1903, Wilbur and Orville Wright made the first flights. I wish they'dve come and take me away.");
string baselinePrompt = promptBuilder.ToString();

Note that the format is that of a scripted conversation between You and Marvin. The next logical entry to this prompt is from You. And so we take it from the command line and add it to the prompt.

string chatResponse = Console.ReadLine();
string userInput = $ "You: {userResponse}\nMarv: ";
string userPrompt = string.Concat(baselinePrompt, userInput);
CompletionRequest completionRequest = new CompletionRequest {
    Model = "text-davinci-003",
        MaxTokens = 120,
        Prompt = userPrompt
};

Now, when I provide the same question, I get snide responses that are in line with the type of responses used in the longer prompt.

That would be a disaster. I'm sure the world would be a much better place if he had never been cast.

I'm sure it would be an interesting movie, but I think I'd rather watch paint dry.

That would be a disaster. I think I'd rather take my chances with Kryptonite.

The tokens used to generate the response ranged from 178-182. This is a surprise given that the maximum number of tokens in this example is 120. I also tried the same call with MaxTokens set to 500 with the cosumed tokens still falling between 178-182. It appears the number of tokens used in this example is driven by the length of the responses from Marv seeded in the prompt.

Summary

Source code that demonstrates the first scenario sending the single request is here and the bot sample is here. It's written in .NET 6 and uses the Whetstone.ChatGPT Nuget package.

This is a basic introduction to the ChatGPT completion endpoint. There are many more parameters available to that control the variability of the response, the selection process of the chosen response, reducing token repetition, and others. There are more use cases to explore, like classification and sentiment analysis. And there are other endpoints for image generation and code generation. If you would like to see these areas explored in more detail in a future article, please let me know in the comments. Also, I'm looking for contributors to help build support for the other endpoints at the whetstone.chatgpt GitHub repo. Please feel free to find me on Twitter or LinkedIn.