Hosting

Console and metrics

The console bundled in every server, and Prometheus metrics.

llms.txt

Every MenteDB server ships its own management UI and metrics, bundled into the binary, so a self-hosted node is observable and manageable with no extra deploy and no build step.

Bundled console

Open /console for a live health view (status, uptime, memories stored, live cluster nodes, requests/sec, CPU, memory) and a Memories tab to browse, search, filter by type or agent, and delete, gated by your --admin-key.

Prometheus metrics

/metrics exposes aggregate metrics (no per-account labels): process CPU and memory, uptime, memories, live nodes, and request rate and latency. Scrape with Prometheus and import the Grafana dashboard from the repo for full history.

Terminal
# health + memory browser (needs --admin-key for the Memories tab)
mentedb-server --admin-key "$ADMIN_KEY"
open http://localhost:6677/console

# aggregate Prometheus metrics
curl http://localhost:6677/metrics

The console reads only your node's /metrics for health, and the admin-key-gated /v1/admin/memories for browsing, so it is as private as the server you run it on. On MenteDB Cloud these health signals surface in the admin dashboard instead, and the hosted /metrics and console are kept internal.

What /metrics returns

Standard Prometheus text format, aggregate only (no per-account or per-agent labels), so it is safe to scrape without auth. The MenteDB series:

MetricTypeMeaning
mentedb_upgauge1 while the server is serving.
mentedb_uptime_secondsgaugeSeconds since the process started.
mentedb_memory_countgaugeMemories stored on this node.
mentedb_stores_totalcounterWrites: memories stored. Graph as a rate for write throughput.
mentedb_recalls_totalcounterReads: recall/query operations served.
mentedb_buffer_pool_hits_totalcounterPage cache hits. hits / (hits+misses) is the cache hit ratio.
mentedb_buffer_pool_misses_totalcounterPage cache misses (disk reads).
mentedb_buffer_pool_evictions_totalcounterCLOCK evictions: cache thrash.
mentedb_storage_bytesgaugeOn-disk data size in bytes.
mentedb_pages_totalgaugePages in the store.
mentedb_vector_index_sizegaugeVectors in the HNSW index.
mentedb_graph_nodesgaugeNodes in the memory graph.
mentedb_standing_rulesgaugePinned scope:always standing rules.
mentedb_cluster_live_nodesgaugeLive nodes in the gossip cluster (1 when sharding is off).
mentedb_http_requests_total{method,status}counterHTTP requests, labelled by method and response status.
mentedb_http_request_duration_seconds{method}histogramRequest latency; exposes _bucket, _sum and _count per method.
process_cpu_seconds_totalcounterTotal CPU time consumed (Linux).
process_resident_memory_bytesgaugeResident memory in bytes (Linux).

On Linux the standard process_* collector also exports virtual memory, open file descriptors, and start time. Gauges read the current value; counters only ever rise, so graph them as a rate; the histogram gives you latency quantiles from its buckets.

A scrape looks like this:

Text
# HELP mentedb_up 1 if the server is serving
# TYPE mentedb_up gauge
mentedb_up 1
# HELP mentedb_memory_count Memories stored on this node
# TYPE mentedb_memory_count gauge
mentedb_memory_count 20876
mentedb_stores_total 41902
mentedb_recalls_total 138204
mentedb_buffer_pool_hits_total 982314
mentedb_buffer_pool_misses_total 20981
mentedb_storage_bytes 402653184
mentedb_vector_index_size 20876
# HELP mentedb_http_requests_total HTTP requests by method and status
# TYPE mentedb_http_requests_total counter
mentedb_http_requests_total{method="POST",status="200"} 1423
mentedb_http_requests_total{method="GET",status="200"} 5310
# TYPE mentedb_http_request_duration_seconds histogram
mentedb_http_request_duration_seconds_bucket{method="POST",le="0.05"} 1290
mentedb_http_request_duration_seconds_sum{method="POST"} 41.2
mentedb_http_request_duration_seconds_count{method="POST"} 1423
process_cpu_seconds_total 88.4
process_resident_memory_bytes 214261760

Point Prometheus at it and import the Grafana dashboard from observability/ in the repo, or bring up the whole stack with the pre-wired observability/docker-compose.yml (Prometheus + Grafana). On MenteDB Cloud these same series are scraped into CloudWatch, so the hosted dashboard shows memories stored, request volume, and latency with no setup.