Hi all — I come from a database reliability background (Postgres/MySQL, currently at TigerData/Timescale), and I’ve been building TekmerDB — an open-source (Apache 2.0) memory/storage layer for AI agents that does something most vector stores don’t: it checks new facts against what’s already stored, flags contradictions via an NLI classifier, and adjusts confidence on the source that’s out of step, instead of just storing everything as equally valid. It ships with an MCP server, so it can plug straight into an agent’s tool/memory layer.
Since LangChain/LangGraph is where a lot of people wire up agent memory and tool use, I’m curious whether this has come up for anyone building longer-running agents here — e.g. an agent that pulls from multiple tools/sources over time and has no way to know when two of them disagree, or when one source has been unreliable historically.
Not proposing a specific integration, just want to know if this is a real pain point for people building with LangChain/LangGraph, or if something already handles this that I’m not aware of. Happy to share a short demo if useful.
I think this is a really good point. In real-world applications, not all sources are equally trustworthy. Considering both relevance and reliability could help reduce incorrect or conflicting responses, especially for long-running agents that work with multiple data sources.
Yeah that’s basically why I started building this in the first place. Most setups just don’t have a way to say “this came from somewhere shakier” — everything gets treated the same once it’s retrieved. The NLI check + confidence adjustment thing was my attempt at fixing that without just having an LLM guess a number.
Still early days on my end. If you’re dealing with source drift on a long-running agent, curious what your setup looks like — happy to compare notes.
Strongly agree this is an under-addressed gap.
Most retrieval and memory layers optimize for relevance (similarity) and stop there. But once an agent runs for a while and pulls from multiple tools/sources, two other dimensions start mattering a lot:
- Logical consistency / contradiction detection (what you’re doing with NLI + confidence adjustment)
- Temporal reliability — whether the source is still current
We’ve been working on the second one: a deterministic temporal decay layer that scores retrieved context by how stale it is (platform-aware half-lives) and can hard-gate high-decay chunks before they enter the agent’s context or memory. It doesn’t solve contradiction detection, but it stops the agent from treating 18-month-old docs with the same weight as something from last week.
The combination feels powerful: relevance + temporal freshness + logical consistency. Right now most stacks only do the first.
Curious how you’re thinking about the interaction between source confidence and recency — do you treat an old but previously reliable source differently from a new but untrusted one?
Honest answer: no, not yet — but it’s not an oversight, it’s parked deliberately. Confidence right now is purely source reliability x corroboration, no time dimension. A source that’s been reliable for two years and one I saw for the first time last week get the same score as long as reliability and corroboration match — e.g. both land at 0.87.
Time-based decay is on my roadmap, but I’ve parked it until I evaluate if this project is worthy to keep investing time on or not, data decay will be a complex feature to implement at storage level without impacting overall performance.
Your framing is useful because it confirmed for me that decay and contradiction detection are separate axes, not the same problem wearing two hats — contradiction is “these sources disagree now,” decay is “this source hasn’t been re-confirmed in a while.” Planning to keep them as separate signals rather than blending into one number, so “why is this low confidence” always has a specific answer.
Genuinely curious about your half-lives — hand-tuned per source type (arxiv vs. twitter), or learned from observed update frequency? Might save me some trial and error when I get to it.