chat-with-gpt VS agency

you can use https://www.chatwithgpt.ai/ , I like this + it's open source.

https://github.com/cogentapps/chat-with-gpt/blob/main/app/sr...

Do you have api access? I use this repo called chat with chatgpt https://github.com/cogentapps/chat-with-gpt It literally is chatgpt website same look feel and conversation history, but you can adjust the creativeness (called temperature) the system prompt and what version you want to use.

We've been using https://github.com/cogentapps/chat-with-gpt for a while, and overall happy with it, but its development is mostly dead.

There are apps available that will take care of all this for you: https://github.com/cogentapps/chat-with-gpt is a popular one, if you need help to get it up and running just ask GPT-4 with 'browse with bing' to take a look and lead you by the hand

So far I've tried https://github.com/ztjhz/BetterChatGPT and https://github.com/cogentapps/chat-with-gpt but I'm wondering if there is anything out there more robust? A Mac desktop client would be preferred if anyone knows? I tried MacGPT but the main functionality I am looking for is an ability to sort, search and potentially tag my conversations. Any leads would be appreciated! Much thanks!

Tokenizers seem to be a massive pain in the neck if you are just calling into an API to use your model. The algorithm itself is non-trivial, and they need pretty sizable data to function: the vocabulary and the merges, which just sit there, using memory. I'm writing https://github.com/ryszard/agency in Go, and while there's a good library for the OpenAI tokenization, if you want a tokenizer for the HF models the best I found was a library calling HF's Rust implementation, which makes it horrible for distribution.

However, at some point I realized that I needed not really the tokens, but the token count, as my most important use was implementing a Token Buffer Memory (trim messages from the beginning in such a way that you never exceed a context size number of tokens). And in order to do that I don't need it to be exactly right, just mostly right, if I am ok with slightly suboptimal efficiency (keeping slightly less tokens than the model supports). So, I took files from Project Gutenberg, and compared the ratio of tokens I get using a proper tokenizer and just calling `strings.Split`, and it seems to be remarkably stable for a given model and language (multiply the length of the result of splitting on spaces by 1.55 for OpenAI and 1.7 for Claude, which leaves a tiny safety margin).

I'm not throwing shade at this project – just being able to call the tokenizer would've saved me a lot of time. But I hope that if I'm wrong about the estimates bring good enough some good person will point out the error of my ways :)

How I wish this post had appeared a few days earlier... I am writing on my own library for some agent experiments (in go, to make my life more interesting I guess), and knowing the number of tokens is important to implement a token buffer memory (as you approach the model's context window size, you prune enough messages from the beginning of the conversation that the whole thing keeps some given size, in tokens). While there's a nice native library in go for OpenAI models (https://github.com/tiktoken-go/tokenizer), the only library I found for Hugging Face models (and Claude, they published their tokenizer spec in the same JSON format) calls into HF's Rust implementation, which makes it challenging as a dependency in Go. What is more, any tokenizer needs to keep some representation of its vocabulary in memory. So, in the end I removed the true tokenizers, and ended up using an approximate version (just split it in on spaces and multiply by a factor I determined experimentally for the models I use using the real tokenizer, with a little extra for safety). If it turns out someone needs the real thing they can always provide their own token counter). I was actually rather happy with this result: I have less dependencies, and use less memory. But to get there I needed to do a deep dive too understand BPE tokenizers :)

(The library, if anyone is interested: https://github.com/ryszard/agency.)

I completely agree about langchain being brittle; what I really hate is that it's really hard to make sense about what is going on by reading the code. I was similarly frustrated and rolled my own thing on go (shameless plug): https://github.com/ryszard/agency