Built a vector database from scratch in Rust. No Postgres, no SQLite.
Custom IVF index + K-means
gRPC API (tonic)
Atomic snapshot persistence
29/29 e2e tests passing
Can I build a database, not just use one?
https://t.co/HIesFOeH8V
#rustlang#buildinpublic#opentowork
If you're hiring for Rust backend / AI infra roles: I'm the person who'll replace your anyhow::Result with real typed errors before you even ask, and who treats cargo clippy warnings as bugs, not suggestions. #rustlang#hiring#opentowork
Semantic memories: 365 days. Episodic: 30. Working memory: 4 hours. Giving an AI system a deliberate forgetting policy is an underrated design problem — most people only think about what to store, not what to expire. #AIinfra#vectorsearch
Looking for roles where I can work on the infra layer of AI systems — storage, retrieval, the plumbing that makes "intelligent" systems actually reliable. Currently deep in Rust + SQLite building exactly that. #AIinfra#rustlang#opentowork
Wrote a test today that had to manually forge an expired database row because my own public API refuses to produce invalid state. That's not a workaround, that's the API doing its job. #rustlang#testing
Zero .unwrap() calls across the entire database layer of my Rust project. Every fallible path bubbles up as a typed error. This is what "production-ready" actually looks like, not just a buzzword on a README. #rustlang#backendengineering
Building the "boring" half of an AI system first: persistence, typed errors, expiry, tests. No embeddings yet. No LLM calls yet. Because a memory store that can't reliably forget things isn't ready to remember things either. #AIinfra#systemsdesign
Ran cargo clippy -- -D warnings as a hard gate before every commit. Caught a naming collision with FromStr that would've confused every future contributor, including future me. Lint gates aren't bureaucracy, they're memory for your team. #rustlang#devtools
TTL isn't a nice-to-have for AI memory systems — it's the difference between a system that scales and one that becomes a landfill. Per-type expiry defaults, shipped today. #AIinfra#rustlang#vectordb
If your database layer still returns anyhow::Result, you don't have error handling — you have error hiding. Just replaced mine with a proper thiserror enum. Small change, huge difference for anyone calling your code. #rustlang#backenddev
Building an AI memory engine in Rust from scratch: typed errors, zero unwraps, clippy-clean, self-expiring storage. Not a tutorial project — a real system with real tradeoffs. #rustlang#AIinfra#systemsengineering
Next up: embeddings + cosine similarity search so recall() stops being a todo!() and starts being real. The systems half is banked. Time to make it smart. #rustlang#vectorsearch#buildinpublic
Checkpoint: fully typed, persistent, self-expiring SQLite store — and not a single line of AI in it yet. Sometimes the most important part of an "AI project" is the boring part that has nothing to do with AI. #rustlang#buildinpublic
purge_expired() now returns a count of deleted rows instead of just silently doing its thing. Observability isn't just for prod systems — even your local key-value store deserves a receipt.
cargo clippy --all-targets --all-features -- -D warnings — one warning today: a method named from_str that wasn't actually FromStr. Renamed it to parse_str. Clippy: 1, my past self's naming instincts: 0.
Ripped out anyhow from the entire database layer today and replaced it with a proper thiserror enum. Five variants, five ways to fail, zero mystery. "Something went wrong" is not a personality trait I want my library to have.
Grepped the whole codebase for .unwrap() on database calls today. Found zero. Felt like checking under the bed for monsters and actually finding none. #rustlang
Wrote a test today that required manually inserting an "already expired" row into SQLite via a second raw connection — because my own store() function is too well-behaved to ever produce one. Being locked out of your own bug is a good problem to have.
store() now auto-calculates expires_at based on memory type. The caller doesn't think about TTLs at all — it just happens. My favorite kind of API: the one where you can't mess it up even if you tried.
Working memories now expire in 4 hours. Semantic facts live a year. Procedural knowledge gets 2 years. Basically gave my database the attention span of a goldfish and the long-term memory of a librarian. #rustlang#systemsengineering
Spent today teaching my memory store to forget things on purpose. Turns out "forgetting" is a feature, not a bug, when you're the one writing the expiry logic. 🧠🗑️ #rustlang#buildinpublic