Hosting
Console and metrics
The console bundled in every server, and Prometheus metrics.
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.
# 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/metricsThe 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:
| Metric | Type | Meaning |
|---|---|---|
| mentedb_up | gauge | 1 while the server is serving. |
| mentedb_uptime_seconds | gauge | Seconds since the process started. |
| mentedb_memory_count | gauge | Memories stored on this node. |
| mentedb_stores_total | counter | Writes: memories stored. Graph as a rate for write throughput. |
| mentedb_recalls_total | counter | Reads: recall/query operations served. |
| mentedb_buffer_pool_hits_total | counter | Page cache hits. hits / (hits+misses) is the cache hit ratio. |
| mentedb_buffer_pool_misses_total | counter | Page cache misses (disk reads). |
| mentedb_buffer_pool_evictions_total | counter | CLOCK evictions: cache thrash. |
| mentedb_storage_bytes | gauge | On-disk data size in bytes. |
| mentedb_pages_total | gauge | Pages in the store. |
| mentedb_vector_index_size | gauge | Vectors in the HNSW index. |
| mentedb_graph_nodes | gauge | Nodes in the memory graph. |
| mentedb_standing_rules | gauge | Pinned scope:always standing rules. |
| mentedb_cluster_live_nodes | gauge | Live nodes in the gossip cluster (1 when sharding is off). |
| mentedb_http_requests_total{method,status} | counter | HTTP requests, labelled by method and response status. |
| mentedb_http_request_duration_seconds{method} | histogram | Request latency; exposes _bucket, _sum and _count per method. |
| process_cpu_seconds_total | counter | Total CPU time consumed (Linux). |
| process_resident_memory_bytes | gauge | Resident 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:
# 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 214261760Point 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.