All of the proofs of privacy rely on us getting the math right. All of the privacy from unplugging your internet cable is there by default.
(cf Saul Bellow asking “who is the Tolstoy of the Zulus”, and Ralph Wiley in the Atlantic saying that Tolstoy is the Tolstoy of the Zulus.)
https://leebutterman.com/2026/05/01/visualizing-tiny-llms-in-parameter-golf.html
The two from parameter golf (one I trained, one was the baseline) are just 16MB each! They produce barely plausible English
For this project, where you have 120GB of customer data, and thirty requests a second for ~8k objects (0.25MB/s object reads), you’d seem to be able to 100x the throughput vertically scaling on one machine with a file system and an SSD and never thinking about object storage. Would love to see why the complexity
> Instead of taking a stab in the dark, Leanstral rolled up its sleeves. It successfully built test code to recreate the failing environment and diagnosed the underlying issue with definitional equality. The model correctly identified that because def creates a rigid definition requiring explicit unfolding, it was actively blocking the rw tactic from seeing the underlying structure it needed to match.
Buy the book! https://qntm.org/vhitaos
Source about aviation: primary (I am at an airport now) and also there are no flights going into or out of JFK right now https://www.jfkairport.com/flight-tracker?view=VIEW_DEPARTUR...
Apache Arrow is trying to do something similar, using Flatbuffer to serialize with zero-copy and zero-parse semantics, and an index structure built on top of that.
Would love to see comparisons with Arrow
A Pi has 4 cores and 16GB of memory these days, so, running Qwen3 4B on a pi is pretty comfortable: https://leebutterman.com/2025/11/01/prompt-optimization-on-a...
https://leebutterman.com/2025/11/01/prompt-optimization-on-a-raspberry-pi.html
GEPA was very efficient at optimizing my LLM task description, and DSPy was effective at turning a soup of a prompt into something programmable with inputs and outputs
(For example, a recent half baked idea there is a perpetually burning flag. https://www.halfbakery.com/idea/Perpetually_20Burning_20Flag... )
Once you have everything else set up, you can migrate to a server hosted on your own internet connection. Running your own data center is one of the more tricky parts of the equation, compared to almost-free web hosting for a 10MB site.
You're also just renting a domain name.
That is what's known in FAISS as a "flat" index, just one thing after another. And obviously you can query by primary key to the key-value store that is git, and do atomic updates as you'd expect. In SQL land this is an unindexed column, you can do primary key lookups on the table, or you can look through every row in order to find what you want.
If you don't need fast query times, this could work great! You could also use SQL (maybe an AWS Aurora Postgres/MySQL table?) and stuff the fact and its embedding into a table, and get declarative relational queries (find me the closest 10 statements users A-J have made to embedding [0.1, 0.2, -0.1, ...] within the past day). Lots of SQL databases are getting embedding search (Postgres, sqlite, and more) so that will allow your embedding search to happen in a few milliseconds instead of a few seconds.
It could be worth sketching out how to use SQLite for your application, instead of using files on disk: SQLite was designed to be a better alternative to opening a file (what happens if power goes out while you are writing a file? what happens if you want to update two people's records, and not get caught mid-update by another web app process?) and is very well supported by many language ecosystems.
Then, to take full advantage of vector embedding engines: what happens if my embedding is 1024 dimensions and each one is a 32 bit floating point value? Do I need to save all of that precision? Is 16-bit okay? 8-bit floats? What about reducing the dimensionality? Is it good enough accuracy and recall if I represent each dimension with an index to a palette of the best 256 floats for that dimension? What about representing each pair of dimensions with an index to a palette of the best 256 pairs of floats for those two dimensions? What about, instead of looking through every embedding one by one, we know that people talk about one of three different topics, and we have three different indices for each of those major topics, and to find your nearest neighbors you want to first find your closest topic (or maybe closest two topics?) and then search in those lower indices? Each of these hypotheticals is literally a different “index string” in an embedding search called FAISS, and could easily be thousands of lines of code if you did it yourself.
It’s definitely a good learning experience to implement your own embedding database atop git! Especially if you run it in production! 100MB is small enough that anything reasonable is going to be fast.