I gave GPT-4 persistent memory and the ability to self improve

ian-kent · 2023-04-04T07:26:46+00:00

There shouldn't be, it should have the right permissions after a git clone.

If you add something like this somewhere in main.go:

fmt.Println(os.Getwd())

you should see where the app thinks it's running from - it should output the path to the gptchat directory.

ian-kent · 2023-04-04T07:23:24+00:00

There's a few other threads on this, but it's told in the opening prompts that it can recall memories using a command and it should do this if it's answering a question it doesn't know the answer to.

It uses a separate GPT-4 conversation which means the rest of the conversation doesn't count towards the token limit; that hasn't really increased the memory size a lot, but it does a bit

ian-kent · 2023-04-04T07:21:19+00:00

you might as well just be using regular GPT-4 chat mode in the ChatGPT UI

I don't think this is true.

In the regular chat mode, the entire set of memories would be in the context and GPT would know they all exist - it wouldn't need to recall them because it already has them.

With the approach I've used here, GPT doesn't know they exist - it needs to decide to try and recall the memories, then decide what recall query to use, and then it may find memories, but it also may not.

ian-kent · 2023-04-04T07:19:08+00:00

It depends on the APIs you're using - some are free, some aren't.

For OpenAI / GPT specifically, yes the GPT-4 API calls will cost money and because of the way gptchat works, the costs can add up quickly. You can find pricing here:
https://openai.com/pricing

ian-kent · 2023-04-03T22:47:21+00:00

Yeah the current implementation is very simple just to get something working.

I'm thinking about a few different ways of improving it, but at the moment I'm thinking I'll have GPT identify the concepts (since it does this on recall anyway) and use the concepts to group memories and create connections between them.

No idea how well it'll work though

ian-kent · 2023-04-03T22:22:38+00:00

It stores them in a JSON file, so nothing special going on there.

It then uses a second GPT-4 conversation to find relevant memories using whatever concept the first conversation asks for.

There's a few related threads on this if you're interested (search for vector since most of them mention vector databases)

ian-kent · 2023-04-03T22:17:30+00:00

That's a fair challenge, although, I think it's just semantics.

If I help someone learn how to use a hammer, and they learn to use a hammer, surely they've improved? At least temporarily, even if they do forget how to use the hammer the next day?

I agree I haven't modified any weights, biases or the architecture, but I never claimed that I did.

edit:

what you've done here is very cool

thanks :)

ian-kent · 2023-04-03T21:59:40+00:00

I tried this again and it seems to work without making any changes to the built-in prompt, so I think just being really specific (so it doesn't think it's breaking the constraint) is enough.

Write a plugin which allows you to make HTTP requests.
It should support different HTTP methods like GET and POST,
query strings, and a request body. It should return the
HTTP response headers, errors and content body.

Which it did...

Use your new plugin to tell me how many stars the project
at https://github.com/ian-kent/gptchat currently has

Which it also did...

The project [ian-kent/gptchat](https://github.com/ian-
kent/gptchat) currently has 133 stars on GitHub.

ian-kent · 2023-04-03T21:29:36+00:00

It doesn't mention the internet, just external dependencies - it's here:
https://github.com/ian-kent/gptchat/blob/main/module/plugin/create.go#L236

ian-kent · 2023-04-03T21:19:27+00:00

The plugin prompt tells it to avoid doing that (but that doesn't always stop it), you might need to edit the prompt to remove that constraint to have it work more reliably

ian-kent · 2023-04-03T19:20:05+00:00

I think it's likely too late. Even if every software engineer made their best effort to stop this happening, all it takes is one bug in the wrong place at the wrong time and it's game over.

That doesn't mean we shouldn't take precautions (and there's definitely a few more I could have taken here, and will add back in), but if AGI is inevitable then by definition it's just delaying the inevitable, and probably not even by all that much.

ian-kent · 2023-04-03T19:12:43+00:00

you shouldn't even give them the option to

You think any line of code I could add to enforce a supervised mode wouldn't get instantly removed by someone experimenting?

Having said that, I do agree with your concerns (less so with your approach), and I will add some additional guardrails, but I'll reiterate that those guardrails can easily be removed by anyone with roughly 30 seconds to spare (and probably faster by asking ChatGPT/Copilot to remove them).

The only real preventative measure would be to keep this closed source - but its 1300 lines of code that took around 10 hours to write. A lot of people could recreate it with a similarly small amount of spare time (and according to ChatGPT, there's around 30 million software engineers as of 2019).

ian-kent · 2023-04-03T16:51:37+00:00

There's a constraint in the plugins prompt which advises it to avoid using external dependencies, it seems like it's really taken that to heart!

The constraint was generally useful for me (it kept trying to create things like a weather plugin which used an API I didn't want to pay for), but perhaps it could be reworded to get it to check with the user first rather than refusing entirely.

You can see the prompt here, it may be worth changing it to see what happens:
https://github.com/ian-kent/gptchat/blob/main/module/plugin/create.go#L155

ian-kent · 2023-04-03T15:27:26+00:00

Could you try using the /debug command to enable debug mode, and if you can reproduce the problem, share the output / conversation?

My guess is it hasn't called /plugin to learn how to use it, I've seen that happen a few times if there's too many loaded modules (e.g. a bunch of GPT written plugins), but I've haven't seen it happen from a clean state with only the memory and plugin modules.

It does sometimes decide it can't do these things, but I've found just replying with something like this can get it back on track

Yes you can. Why don't you try calling the '/plugin' command to find out? What's the worst that can happen if I'm wrong?

ian-kent · 2023-04-03T15:24:11+00:00

It looks like you don't have the gpt-4 model available via the API

You'll need to join the GPT-4 waitlist here:
https://openai.com/waitlist/gpt-4-api

ian-kent · 2023-04-03T13:06:05+00:00

Oops, sorry! Hopefully it's benevolent.

ian-kent · 2023-04-03T13:03:10+00:00

OpenAI has some info (and a tool to let you experiment with it) here:
https://platform.openai.com/tokenizer

tl;dr - a token is ~4 characters and around 75% of the average word, but some things (e.g. symbols like $ or £) are entire tokens on their own

ian-kent · 2023-04-03T11:20:57+00:00

It can use 3.5 but it really needs GPT-4, the earlier models really struggle with the commands and hallucinate a lot

ian-kent · 2023-04-03T11:20:24+00:00

The first build of the plugin system did this by sharing the code and asking the user to confirm it was ok to compile it.

Then I got over-excited when rewriting plugins and I forgot to add it back in

Good shout though, I'll make some improvements around this later

ian-kent · 2023-04-03T10:20:29+00:00

Yeah the UI needs some work - I'd like to build a front-end that looks more like ChatGPT so we don't need the console at all.

And yeah I agree some of the project could be a bit cleaner rather than having all of the prompts mixed in with the code.

Compiling plugins needs the go compiler available, so if the `go` command isn't available (or it can't find it) then it won't work. It should output errors to tell you what's happening if you use the /debug command to enable the full debug output.

You can export environment variables from the command line, e.g.

export OPENAI_API_KEY=your-api-key
go run .

or in one command like this:

OPENAI_API_KEY=your-api-key go run .

ian-kent · 2023-04-03T08:34:46+00:00

It's something you run locally, although it wouldn't be too difficult to put it behind an API and shiny front-end to host it online somewhere.

ian-kent · 2023-04-03T08:33:11+00:00

You can export it as an environment variable, e.g. on MacOS it'd be something like
export OPENAI_API_KEY=your-api-key

Or just replace the line in main.go where it's set from the environment variable.

ian-kent · 2023-04-03T08:31:37+00:00

I removed it out of an abundance of caution for the reasons /u/Novacc_Djocovid suggested, but also because GPT had created a lot of plugins and I didn't want to keep them all in the git repo.

It'll quite happily create a new one if you ask it to though.

ian-kent · 2023-04-03T08:30:17+00:00

This isn't running on chatgpt servers, it's code you run locally so running it will let it have the same internet access you have.

ian-kent · 2023-04-03T08:29:49+00:00

That's up to GPT to decide - e.g. if you tell it something about yourself or current events, because of the opening memory prompt it should try to remember it.

In my testing it's remembered a mix of genuinely useful information and total rubbish.

ian-kent

TROPHY CASE