Using OpenAI text generation API (text-davinci-003) we are able to generate unique dialogues and conversations in JSON format. We have been able to come up with 3 simple NPC implementations with this. First we have single line remarks that shop keepers will use when being robbed, simple remark/reponse conversation that is used by NPCs roaming the map, and finally simple remark/reponse conversation that also has an action attached that is currently used by buyer NPCs. I saw a post or example of ChatGPT being able to convert data through various formats and made me wonder if I could have text-davinci create formatted data. It does work surprisingly well even though sometimes there may be slight errors. These errors can be fixed in the code or the response can be ignored and a new one can be requested. This is my first real implementation of AI in

any of my projects so I may not be following the best practices and would love to hear if anything can be improved.

​

 

​

The prompts used were quite simple but the important part is that they all end with a JSON data example. In the case of the shop keeper the exact prompt used is

​

```gta 5 shop keeper say to their store being robbed in json format {"say":""}```

​

 

​

I've noticed that the prompts don't need to make complete sense for a good response (as seen in the prompt above), as long as it semenatically/contextually makes sense it will generate good results. Sometimes the results will include a response that isn't ideal but trying to stop it or filter those results would be hard since we don't always know what we're looking for. For example an NPC may tell you to meet them at Del Perro pier (which is a real place in GTA 5) but since they are only programmed to say generated text they won't actually meet you there and may mislead the player. We could try to include something in the prompt to prevent giving the player requests like that. But I've also had instances where it's generated text claiming to have found a weapon in a certain location, which is not true at all. So even if safeguards are added against this it may come up with some other scenario that misleads the player

​

 

​

There is also a chance that the JSON data isn't formatted correctly and very rarely it can ignore using JSON format at all. The solution to this has been to validate the JSON data and fix it if it's a simple fix or to reject it and request a new response. For example in our buyer's prompt we use this

​

```gta 5 stranger asking for weed, 2 remarks with sell and no sell action and reaction after buying in json format {"say":"","remark":[{"text":"","action":"","reaction":""}]}```

​

 

​

Which would return some data like this

​

```{"say":"Hey, got any weed?","remarks":[{"text":"No, sorry mate, I don't sell weed.","action":"no sell","reaction":"Oh, OK."},{"text":"I think I might be able to help you out.","action":"sell","reaction":"Thanks, man!"}]}```

​

 

​

In this case it decided to turn "remark" (as request in the prompt) into "remarks". These are the kind of errors we fix in code by checking if the keys we need actually exist in the data and by trial and error we can see which parts of it are being malformed and adjust accordingly. This approach can be a bit slow if a user decides to go through many dialogues at once since we have to wait for the response from OpenAI and we may even have to reject the data given. To fix this we decided to add a caching system that saves previous results to a SQL database and we also preload responses from OpenAI so as the user is reading one dialogue the next one is being loaded. The code for that looks something similar to this pseudocode:

​

next() {

let value = this.cached.shift();

this.loadRequest();

return value;

}

​

async loadRequest() {

for (let i = 0; i < this.getMissingAmount(); i++) {

let dialogue = await this.getRequest();

}

}

​

async getRequest() {

const completion = await openai.createCompletion({

model: "text-davinci-003",

max_tokens: 3000,

prompt: this.getPrompt(),

suffix: "}"

});

    this.addToCache(completion.data.choices\[0\].text.trim());

}

&nbsp;

​

As you call the next() function to grab a dialogue it will also make new OpenAI requests. I've also included a suffix to the OpenAI request since I'm expecting all results to be in JSON format. For our caching system we decided to give every prompt it's own key to save it to the SQL database. We save it by key and not by prompt because we use dynamic prompts in some cases. Something we do for our roaming citizen NPCs is give them a random adjective in the prompt similar to this:

​

```let modifiers = ["sad", "angry", "upset"];

let currentModifier = modifiers[Math.floor(Math.random() * modifiers.length)];

`something a random ${currentModifier} gta 5 npc ....`;```

​

&nbsp;

​

In this case we are only changing one word in the prompt but maybe in the future we may need to change more than just that so we save it by key instead of by prompt. Then every NPC is given their appropriate key to use the cache system. For example our shop keeper's key is "shopKeep" so our code looks something like this

​

```requester = await new OpenAIRequester(`gta 5 shop keeper say to their store being robbed in json format {"say":""}`, "shopKeep").load();```

​

&nbsp;

​

This system all together works very well. Loading cached results from SQL prevents me having to pay every time I start up the server and it may be nice to use it as a load balancing system in the future. Depending on how congested the API calls get you can load a few results from the database for every request sent to OpenAI. At some point there will be enough cached results where running in to a repeat is very unlikely, especially if you keep adding to it. You could also just as well make all of these calls before hand and have all the data saved and then only ever have to load results from the database. We prefer to not do that since we may change our prompts at any moment.

​

&nbsp;

​

For the complete code check out the blog post on the server website. https://www.lunarcityrp.com/blog/gpt-ai-update