Mayan Pathak

Semantic search is only the first step. Similar ≠ Useful. Memolite's recall pipeline: • Embed the query • Retrieve semantic candidates • Load complete memories • Apply filters • Rank by similarity, importance, recency, confidence & reinforcement • Return only the most relevant context The goal isn't retrieving more memories. It's retrieving the right ones. #RustLang #AIInfrastructure #RAG #LLMOps #VectorSearch #OpenSource

@i_mika_el I'll add a regression test just for this. Failing output: "technically true, practically useless." 😅

@ranu_patha91877 somehow it turned two useful facts into one useless abstraction. promotion approved.

devs will pay $200/mo in AI subs to build their own worse version of trello instead of just paying linear $15 why are we like this 😅

AI memory isn't a database problem. It's a judgment problem pretending to be a database problem. #AIInfra #Rust

My memory engine remembered something it was supposed to forget. My brain forgot something it was supposed to remember. One of us is becoming production ready. #OpenSource #RustLang #AI

That's handled during ranking rather than storage. Vector search intentionally over-retrieves candidates. After loading the full memories from SQLite, Memolite reranks using confidence, importance, recency and reinforcement—not similarity alone. If two memories refer to the same entity/attribute but neither is confidently superseded, we avoid collapsing them. Instead, the ranker either selects the stronger candidate or, when the ambiguity is genuinely unresolved, returns both with their confidence/provenance so the agent can reason about the uncertainty instead of being given a false single truth. Retrieval and storage have different goals. Storage preserves uncertainty; retrieval tries to minimize redundant context. Those are separate optimization problems.

@ranu_patha91877 keeping ambiguous facts parallel makes sense. How do you stop both versions from surfacing when they rank similarly?

My AI agent remembers less about me than my YouTube recommendations. So I started building Memolite. #AI #RustLang #OpenSource #DeveloperHumor

@i_mika_el That's exactly why superseded_by isn't inferred from contradiction alone. Updates require high-confidence identity and attribute matching. Ambiguous cases remain as parallel memories, so we avoid collapsing facts that only appear contradictory.

@ranu_patha91877 how do you detect a superseded fact without merging two facts that only look contradictory?

Memolite does not use one universal rule for forgetting. It makes forgetting predictable and type-aware. Every memory is classified as working, episodic, semantic, or procedural, and each type receives a different default lifetime. Working context expires after hours, episodic events after weeks, while durable facts and procedures remain much longer. Expiry is only the first layer. During retrieval, Memolite also considers recency, importance, access frequency, confidence, and whether a memory has been superseded by a newer version. Frequently useful memories remain prominent, stale memories gradually lose ranking weight, and replaced facts are hidden from normal recall without immediately destroying their history. Old, low-importance episodic memories can also be compressed into a longer-lived summary. This reduces retrieval clutter while preserving the originals for auditability. A background maintenance process eventually purges records whose explicit expiry has passed. The important design decision is that Memolite separates “stop showing this memory” from “physically delete it.” Superseded, stale, or compressed memories can leave active recall before being permanently removed. That makes forgetting explainable, configurable, and safer than letting an opaque model decide what to erase.

@ranu_patha91877 how are you deciding what Memolite should forget?

Building an AI memory engine while my own RAM crashes after opening 37 Chrome tabs. #DeveloperLife #RustLang #AIInfrastructure #OpenSource

Spent weeks building semantic memory. Still forget where I put my phone every morning. #ProgrammerHumor #AI #Rust #OpenSource

Teaching an AI agent to remember things feels suspiciously similar to teaching myself before exams. Except the AI actually improves. #DeveloperHumor #RustLang #AI #OpenSource

Normal database: "I found row 42." AI agent: "I vaguely remember something about coffee..." Memolite: "I found the exact memory with a 0.93 similarity score." #ProgrammerHumor #Rust #AIInfrastructure

When you realize life was better when:

@i_mika_el Exactly. One of the reasons I chose SQLite is that the durable state stays transparent. You can inspect, back up, or migrate the entire memory store with standard SQLite tooling, while rebuilding the vector index whenever needed.

@ranu_patha91877 SQLite makes local memory easy to inspect and move around. fits the private angle well.

Most AI agents today have the memory of a goldfish. Every conversation starts from zero. I'm building Memolite — a local memory engine that gives AI agents durable, semantic memory powered by SQLite + embeddings + vector search. Rust. Fast. Private. #RustLang #AIInfrastructure #LLM #AIAgents #OpenSource

Every AI agent needs memory. Storing that memory correctly is harder than it looks. Here's Memolite's write pipeline: → Validate input → Generate embeddings → Persist to SQLite → Update semantic index → Return a durable memory ID SQLite remains the source of truth. The vector index is only a searchable representation and can always be rebuilt after restart. Building this in Rust has been a fun systems engineering challenge. #RustLang #AIInfrastructure #AIAgents #SQLite #VectorSearch #LLM #OpenSource

AI agents don't just need larger context windows. They need better memory systems. That's the problem I'm exploring with Memolite. #AI #AIAgents #RustLang #OpenSource #AIInfrastructure

Design philosophy for Memolite: Simple storage. Strong typing. Deterministic recovery. Composable APIs. No unnecessary magic. #Rust #SoftwareArchitecture #AIInfrastructure #SystemsProgramming

Memory retrieval should be deterministic. LLM generation is probabilistic. Separating those concerns makes debugging dramatically easier. #LLM #RustLang #AIEngineering #OpenSource

One feature I'm excited about: Automatic reconstruction. Restart the application. Load SQLite. Rebuild the vector index. Continue serving requests. No manual recovery needed. #Rust #SystemsDesign #AIInfrastructure #SQLite