Blog

Latest updates, guides, and insights about Valkey monitoring and observability.

OpenTelemetry, both directions: the monitor speaks OTLP in and out

The monitor now speaks OpenTelemetry in both directions: it re-emits its whole Prometheus surface and its events over OTLP, and its /v1/traces endpoint ingests OTLP spans from any instrumented service. That gives BetterDB four positions in your pipeline - feed your collector, be one, produce spans, or consume them and add the one thing a pure trace tool can't: the live database state behind the span. It fits wherever your stack has an OTLP-shaped socket open.

Kristiyan Ivanov•August 13, 2026

Boring Is Important

The most valuable work we did this week was also the least tweetable: patching CVEs nobody will ever see, halving our Docker image, and fixing build-pipeline plumbing. No AI, no new features - just the unglamorous work that separates a demo from something you can run at 3am. Here's what we did, and why we keep choosing it over the shiny thing.

Kristiyan Ivanov•August 12, 2026

How to Actually Cache an LLM App: Exact, Semantic, or Both

We ship two caching libraries and people keep asking which one to use. The answer is a decision tree, not a product name. Here is the playbook: what to cache exactly, what to cache semantically, how to tune the threshold, and the numbers behind every claim.

Kristiyan Ivanov•August 7, 2026

One trace, two layers: OpenTelemetry between your LLM app and your cache

Every layer of the AI stack grew its own observability, but the layers can't see each other. This is a story about merging the LLM trace and the cache decision into one waterfall with zero custom glue, because BetterDB and LangWatch both chose to speak OpenTelemetry.

Kristiyan Ivanov•August 4, 2026

What shipped in July: offline licensing, native OpenTelemetry, and fifteen new detectors

A full month in review. BetterDB Monitor now runs fully air-gapped, speaks OpenTelemetry natively, grew its MCP surface, and picked up fifteen new anomaly detectors built straight from the Valkey issue tracker - plus cleaner migration off KeyDB and older Redis, and a month of caching and agent-memory SDK work.

Kristiyan Ivanov•July 31, 2026

No Internet Required: Air-Gapped Monitoring for Valkey and Redis

The teams that most need deep database observability are often the ones that can't send a single packet to the outside world. BetterDB Monitor 0.28.0 runs fully air-gapped: signed licenses, local verification, zero phone-home. This post covers how it works and the honest trade-offs.

Kristiyan Ivanov•July 29, 2026

We benchmarked our semantic cache against Upstash. The thresholds did not transfer.

BetterDB vs @upstash/semantic-cache on four public datasets. Quality is at parity. The same embedding model produced different score distributions on each runtime, so the optimal threshold was different on each side, which is the whole argument for self-tuning. Latency is local Valkey vs a cloud REST API, so we report it as a deployment difference, not a library win. And BetterDB ships OpenTelemetry, Prometheus, and dollars-saved tracking in the MIT library, where Upstash ships none of it.

Kristiyan Ivanov•May 29, 2026

A week benchmarking LLM caches against RedisVL and Upstash. Here is what held up.

Over the past week we benchmarked our semantic cache against RedisVL and Upstash on four public datasets. Quality is at parity. Thresholds do not transfer between runtimes. Auto-tuning gains up to +2.8% F1 where the starting threshold was wrong. Latency is mostly about where you run the cache. And adversarial paraphrases beat every cosine cache.

Kristiyan Ivanov•May 29, 2026

We gave our semantic cache a self-tuning loop and benchmarked it on two academic datasets. Here is what happened.

BetterDB's Monitor-driven threshold autotuning on STSb and SICK: the cache loosened when too strict, tightened when too loose, and did nothing when it was already right. Up to +2.8% F1 on STSb and +2.1% F1 on SICK vs static thresholds, with zero degradation when the threshold was already optimal.

Kristiyan Ivanov•May 27, 2026

We benchmarked our semantic cache against Redis's. Here is what we found.

BetterDB vs RedisVL's SemanticCache on two public datasets, nine thresholds, and three configuration modes. Quality is at parity. First-query latency is at parity. On repeated queries BetterDB is 7x faster thanks to built-in embedding caching. Valkey and Redis 8 are indistinguishable. Full methodology and raw numbers included.

Kristiyan Ivanov•May 25, 2026

The cache that tunes itself: three autonomous optimization runs and what they found

A cache optimizer on a 6-hour Vercel Cron that issues proposals and either auto-approves them or queues them for human review in BetterDB Monitor: three runs against chat.betterdb.com, 15 tool calls down to 8, and what the repetition between runs 1 and 2 revealed about a problem no amount of TTL tuning can fix.

Kristiyan Ivanov•May 7, 2026

Two-tier caching for RAG: what we measured building chat.betterdb.com

I built a RAG chatbot over Valkey, Redis, and Dragonfly docs in a weekend, expecting to find that semantic caches silently corrupt answers when entity-swap queries collide. The data showed the opposite. Here is what we measured, what the architecture looks like, and where the real failure mode lives.

Kristiyan Ivanov•April 28, 2026

You can't debug what you can't see: shipping the Vector / AI tab for valkey-search and RediSearch

Why FT.INFO and INFO commandstats aren't enough for production vector workloads on Valkey or Redis - and how BetterDB's new Vector / AI tab closes the gap.

Kristiyan Ivanov•April 22, 2026

Your Agent Works Locally. Then You Deploy to AWS.

The quietest assumption in modern AI frameworks is that Redis means Redis 8 with modules. It doesn't, on any managed service you're likely to use. Here's why your agent cache breaks on deploy, and what to do about it.

Kristiyan Ivanov•April 20, 2026

Know Before You Hit the Wall: Metric Forecasting in BetterDB

BetterDB now forecasts ops/sec, CPU, memory, and fragmentation - so you can see capacity problems coming before they become incidents.

Kristiyan Ivanov•April 13, 2026

Introducing the BetterDB CLI: Run Valkey Commands Without Leaving Your Monitor

Stop switching tabs. BetterDB now includes an integrated CLI so you can investigate and act on what you see - without ever leaving the monitor.

Kristiyan Ivanov•April 9, 2026

Your In-Memory Data Should Go Where You Want It

BetterDB's migration tooling gives you a complete picture before you move a single key -- and confirms the picture after.

Kristiyan Velkov•April 1, 2026

Debugging Valkey with MCP: When Your AI Can Query Your Monitoring

Why natural language access to Valkey observability data changes how incidents get investigated - and what it means for AI agents that use Valkey directly.

Kristiyan Ivanov•March 31, 2026

Debugging a MemoryDB Incident: CloudWatch vs BetterDB

A walkthrough of the same MemoryDB incident debugged three ways - CloudWatch, BetterDB UI, and BetterDB MCP. Same data, very different outcomes.

Kristiyan Ivanov•March 24, 2026

The Glue Layer Most People Don't Design Intentionally: Caching, State, and Session Management in AI Apps

Your AI app works great in dev. Then LLM costs spike, latency doubles, and your agent forgets mid-task. The problem is the layer between your app and your model.

Kristiyan Ivanov•March 21, 2026

How to Connect to a Remote Valkey (or Redis) Instance from VS Code (and Cursor, Windsurf, and Others) via SSH Tunnel

Stop running ssh -L by hand every time you need to check something. Here's how to connect to remote Valkey and Redis instances via SSH tunnel without leaving your editor.

Kristiyan Ivanov•March 11, 2026

What BetterDB Exposes to Prometheus (And Why It Matters)

A practical guide to BetterDB's 99 Prometheus metrics - what they cover, how to configure scraping, and PromQL queries worth keeping around.

Kristiyan Ivanov•March 6, 2026

Valkey's Moment: Why AI Inference Needs What Postgres Can't Deliver

Why the database that was 'just a cache' might be the most important piece of your AI infrastructure

Kristiyan Ivanov•March 3, 2026

Valkey/Redis Monitoring Overhead: Interleaved Benchmark Results

Most monitoring tools claim low overhead but never show their work. Here's the interleaved benchmark methodology we use to measure BetterDB's monitoring overhead on Valkey and Redis.

Kristiyan Ivanov•February 5, 2026

Real-Time Alerting Without the Infrastructure: Why We Built Native Webhooks

BetterDB 0.3.0 introduces native webhook notifications-real-time alerts for your Valkey or Redis databases without requiring Prometheus or Alertmanager.

Kristiyan Ivanov•January 30, 2026

Introducing BetterDB for Valkey: A Free VS Code Extension

Browse keys, edit values, and run commands against Valkey and Redis without leaving your editor. MIT-licensed and open source.

Kristiyan Ivanov•January 24, 2026