Memory Dashboard

Displays live, time-series data for core system health indicators. Key metrics include:

• Memory Latency: Query and write response times (p50, p95, p99).
• Memory Throughput: Operations per second (reads/writes).
• Memory Cache Hit Rate: Percentage of requests served from cache.
• Memory Error Rate: Count of failed operations (5xx errors, timeouts).
• Memory Concurrency: Active connections/threads versus configured limits. Dashboards often feature configurable alert thresholds that trigger notifications when metrics breach acceptable ranges.

Provides visibility into the semantic search and retrieval layer. This panel analyzes:

• Top Queries: Most frequent or slowest-running search patterns.
• Retrieval Score Distribution: Histogram of similarity scores for returned results, helping tune relevance thresholds.
• Query Planner Performance: Breakdown of which indexes (e.g., vector, keyword) are being used and their efficiency.
• Null Result Rate: Percentage of queries that return no matches, indicating potential gaps in the knowledge base or poor query formulation.

Aggregates status checks for all dependencies and internal components. Features include:

• Memory Health Check Status: Visual pass/fail indicators for connectivity to vector databases, embedding models, and object stores.
• Resource Utilization: Graphs of CPU, memory (RAM), and I/O usage for the memory service nodes.
• Dependency Latency: Response times for external services like embedding APIs or LLM context windows.
• Memory Consistency Checks: Results of periodic data integrity validations in distributed or replicated setups.

Surfaces security and governance-related events from the memory system's audit trails. This includes:

• Memory Access Control Logs: Lists of authenticated users/agents and their CRUD operations.
• Memory Compliance Logs: Filtered views showing data accesses relevant to regulations (e.g., GDPR right-to-be-forgotten requests).
• Memory Eviction Logs: Records of data purged due to retention policies or cache limits.
• Schema Change History: Log of modifications made via the Memory Schema API.

Enables deep inspection of individual operations using distributed tracing. Engineers can:

• Follow a Memory Trace: View the end-to-end journey of a single query, from ingestion through embedding, retrieval, and response.
• Use Memory Correlation IDs: Search all logs, metrics, and traces for a specific request to isolate failures.
• Analyze Latency Breakdowns: See time spent in each subsystem (e.g., embedding generation, vector search, result ranking). This is critical for diagnosing sporadic performance issues and understanding complex retrieval paths.

Monitors the scale and lifecycle of stored memories. This view tracks:

• Total Memory Items: Count of unique records (embeddings, metadata) in primary and archival stores.
• Storage Growth Trends: Rate of new memory creation over time.
• Memory Retention Policy Enforcement: Visualization of data scheduled for deletion or archiving.
• Embedding Model Drift: Metrics on the distribution of new embedding vectors versus historical baselines, which can signal declining retrieval quality.

The automated collection and transmission of operational data from an agentic memory system. This is the raw data source for a dashboard. Key streams include:

• Performance metrics: Latency, throughput, and error rates for read/write operations.
• Resource utilization: CPU, memory (RAM), and I/O consumption by the memory service.
• Behavioral signals: Query patterns, cache hit rates, and retrieval score distributions.
• Health indicators: Connectivity status to vector databases and other dependencies.

The primary programmatic interface for searching memory. A dashboard monitors its usage and performance. Key observability points include:

• Query volume and types: Tracking the frequency of semantic vs. keyword searches.
• Latency percentiles: Measuring P50, P95, and P99 response times for queries.
• Result set analysis: Monitoring the average number of chunks or entities returned per query.
• Error tracking: Identifying failed queries due to timeouts, malformed requests, or system limits.

An immutable, chronological log of all access and modification events. The dashboard provides filtered views and alerting on this trail. Critical logged events include:

• CRUD operations: Every create, read, update, and delete action on a memory record, with timestamps and user/agent identifiers.
• Access control events: Successful and failed authentication/authorization attempts.
• Policy enforcement: Logs of data being archived or deleted per a retention policy.
• Compliance triggers: Events relevant to regulations like GDPR (e.g., data access requests).

The quantitative measurements that form the core of dashboard visualizations. These are often exposed via endpoints like /metrics. Essential categories are:

• Latency: memory_read_duration_seconds, memory_write_duration_seconds.
• Throughput: memory_operations_total (counter), memory_concurrent_requests (gauge).
• Efficiency: memory_cache_hit_ratio, memory_embedding_model_inference_duration_seconds.
• Reliability: memory_operation_errors_total, memory_healthcheck_status (1 for healthy, 0 for not).

A diagnostic API endpoint (e.g., /health) that tests system viability. The dashboard polls this endpoint to determine overall status. Comprehensive checks include:

• Dependency connectivity: Verifying connections to vector databases (e.g., Pinecone, Weaviate), embedding model APIs, and blob storage.
• Internal service status: Confirming all critical sub-processes (e.g., index builders, cache managers) are running.
• Resource thresholds: Checking that disk space, memory, and CPU are within acceptable limits.
• Readiness vs. Liveness: A liveness probe indicates the service is running, while a readiness probe indicates it can accept traffic.