betterdb-inc/monitorMonitoraggio in tempo reale e analisi degli slowlog per database Valkey e Redis con rilevamento delle anomalie, audit delle ACL ed esportazione delle metriche Prometheus.
# BetterDB Monitor
[](https://hub.docker.com/r/betterdb/monitor)
[](https://hub.docker.com/r/betterdb/monitor/tags)
[](https://artifacthub.io/packages/search?repo=betterdb-monitor)
[](https://www.npmjs.com/package/@betterdb/monitor)
[](https://www.npmjs.com/package/@betterdb/monitor)
[](https://github.com/betterdb-inc/monitor/actions/workflows/api-tests.yml)
[](LICENSE)
[](https://valkey.io)
[](https://redis.io)
**Il livello di monitoraggio che Valkey merita.**
BetterDB conserva ciò che Valkey scarta - slowlog, pattern dei comandi, attività dei client, segnali di anomalia - così puoi fare debug di ciò che è accaduto alle 3 del mattino, non solo di ciò che sta accadendo ora. Realizzato per Valkey 8.x con supporto nativo per COMMANDLOG, CLUSTER SLOT-STATS e metriche I/O per thread. Compatibile con Redis 6+ per tutto il resto.
[Sito web](https://betterdb.com) | [Docker Hub](https://hub.docker.com/r/betterdb/monitor) | [npm](https://www.npmjs.com/package/@betterdb/monitor) | [Documentazione](https://docs.betterdb.com) | [Blog](https://betterdb.com/blog)
BetterDB è sviluppato da [BetterDB Inc.](https://betterdb.com), una public benefit company che opera secondo la [OCV Open Charter](https://github.com/OpenCoreVentures/ocv-public-benefit-company).
## Avvio rapido (Docker)
```bash
docker run -d --name betterdb -p 3001:3001 betterdb/monitor:latest
```
Porta il browser su `http://localhost:3001`. Per monitorare un'istanza specifica:
```bash
docker run -d \
--name betterdb \
-p 3001:3001 \
-e DB_HOST=your-valkey-host \
-e DB_PORT=6379 \
-e DB_PASSWORD=your-password \
betterdb/monitor:latest
```
> **Ti stai connettendo a un database sulla tua macchina host?** All'interno del container
> `localhost` è il container stesso, non il tuo host — quindi usa
> `host.docker.internal` come host del database. Su **Docker Desktop
> (macOS/Windows)** funziona subito; su **Linux** aggiungi
> `--add-host=host.docker.internal:host-gateway` al comando `docker run` così
> il nome viene risolto. Il pulsante "connect to local instance" con un clic della dashboard
> lo rileva automaticamente e precompila l'host corretto per te.
Sono pubblicate due varianti dell'immagine, entrambe multi-arch (`linux/amd64`, `linux/arm64`):
| Tag | Cos'è |
|-----|------------|
| `latest`, `X.Y.Z-no-ai` | Immagine predefinita - include tutte le funzionalità di monitoraggio, senza le dipendenze per l'AI Helper sperimentale con LLM locale |
| `X.Y.Z` | Aggiunge l'AI Helper sperimentale (bring your own Ollama; disabilitato per impostazione predefinita tramite `AI_ENABLED`) |
Vedi [Docker Production Deployment](#docker-production-deployment) per storage persistente, porte personalizzate, licenze e configurazioni air-gapped.
## Quick Start (Kubernetes / Helm)
```bash
helm repo add betterdb https://docs.betterdb.com/charts
helm repo update
helm install betterdb-monitor betterdb/betterdb-monitor \
--namespace betterdb --create-namespace \
--set db.host=my-valkey.default.svc.cluster.local \
--set db.password=yourpassword
```
Poi `kubectl port-forward -n betterdb svc/betterdb-monitor 3001:3001` e apri `http://localhost:3001`, oppure abilita l'ingress del chart. La cronologia basata su PostgreSQL, i Secrets forniti dall'utente e le licenze air-gapped sono tutti trattati nella [guida Kubernetes](https://docs.betterdb.com/kubernetes) e nel [README del chart](https://github.com/betterdb-inc/monitor/blob/master/charts/betterdb-monitor/README.md).
## Avvio rapido (CLI)
Esegui BetterDB Monitor senza Docker:
```bash
npx @betterdb/monitor
```
Al primo avvio, una procedura guidata interattiva ti accompagna nella configurazione della connessione al database, del backend di archiviazione (SQLite, PostgreSQL o in-memory) e delle impostazioni del server. La configurazione viene salvata in `~/.betterdb/config.json`.
```bash
npm install -g @betterdb/monitor # global install
betterdb --setup # re-run setup wizard
betterdb --port 8080 # override server port
betterdb --db-host 1.2.3.4 # override database host
betterdb --help # all options
```
Richiede Node.js >= 20.0.0 e un'istanza Valkey o Redis da monitorare. Per l'archiviazione SQLite, eseguire anche `npm install -g better-sqlite3`.
## Cosa Ottieni
### Vedi tutto, conserva tutto
- **Analisi storiche** - interroga slowlog, pattern dei comandi, attività dei client e latenza su qualsiasi intervallo di tempo. I dati che prima scomparivano dopo una rotazione dei log.
- **Supporto COMMANDLOG** - esclusivo di Valkey 8.1+. Richieste e risposte di grandi dimensioni, non solo quelle lente.
- **Sessioni di cattura MONITOR** - registra il traffico reale su richiesta: live tail, filtro, replay, esportazione in JSON/CSV e confronto incrociato con la cronologia delle connessioni.
- **Tracciamento delle hot key** - chiavi più accedute per frequenza con variazione del rank nel tempo. Key Analytics (Pro, gratuito in accesso anticipato) aggiunge distribuzioni di tipo, TTL e dimensione dal campionamento live.
- **Visibilità del cluster** - grafici della topologia, heatmap SLOT-STATS, CPU per slot e distribuzione delle chiavi.
- **Auto-registrazione del cluster** - una connessione cluster può registrare automaticamente ogni nodo come connessione monitorata a sé stante, mantenuta sincronizzata man mano che il cluster si espande. Vedi [docs/cluster-auto-registration.md](https://github.com/betterdb-inc/monitor/blob/master/docs/cluster-auto-registration.md).
- **Metriche dei thread CPU e I/O** - visibilità per thread che nessuno strumento Redis può fornire.
- **Analisi dei client** - vedi esattamente quale servizio è responsabile di cosa, attribuito per nome e pattern del client.
- **Audit trail ACL** - traccia chi ha acceduto a cosa, persistito per la conformità e il debug post-incidente.
### Comprendi e agisci
- **Rilevamento delle anomalie** (Pro, gratuito in accesso anticipato) - apprendimento automatico della baseline con eventi correlati e diagnosi in linguaggio naturale. Oltre 20 rilevatori, senza soglie manuali.
- **Previsione della capacità** - tempo stimato al limite per memoria, ops/sec, CPU e frammentazione.
- **Webhook** - consegne di avvisi firmate con HMAC con tentativi ripetuti e un log completo delle consegne.
- **Migrazione live** - spostamento tra Redis e Valkey con un flusso di lavoro in tre fasi: analisi, esecuzione e validazione.
### Progettato per l'era dell'AI
- **Osservabilità della ricerca vettoriale** - ops/sec e latenza di FT.SEARCH con stato di salute per indice per [valkey-search](https://github.com/valkey-io/valkey-search) e RediSearch. Vedi [docs/vector-ai](https://github.com/betterdb-inc/monitor/blob/master/docs/vector-ai/README.md).
- **Latenza di inferenza** - p50/p95/p99 per indice, con avvisi di violazione SLA (Pro, gratuito in accesso anticipato).
- **Intelligenza della cache semantica** (Pro, gratuito in accesso anticipato) - stato di salute dell'hit-rate, raccomandazioni sulla soglia di similarità e un flusso di lavoro di proposte approva/rifiuta. Include l'osservabilità della memoria degli agenti.
- **Tracce AI** - waterfall degli span OTLP dalla tua applicazione AI, correlati con lo stato live di Valkey sottostante a ogni richiesta. Vedi [docs/opentelemetry.md](https://github.com/betterdb-inc/monitor/blob/master/docs/opentelemetry.md).
### Si integra con tutto
- **Server MCP** - 60 strumenti per Claude Code, Cursor o qualsiasi client MCP tramite [`@betterdb/mcp`](https://github.com/betterdb-inc/monitor/blob/master/packages/mcp).
- **Endpoint Prometheus** - oltre 100 metriche `betterdb_*`. Vedi [docs/prometheus-metrics.md](https://github.com/betterdb-inc/monitor/blob/master/docs/prometheus-metrics.md).
- **OpenTelemetry** - acquisisci tracce OTLP e rispecchia metriche ed eventi verso qualsiasi backend OTLP. Vedi [docs/opentelemetry.md](https://github.com/betterdb-inc/monitor/blob/master/docs/opentelemetry.md).
- **API REST** - tutto nella UI è una chiamata API, documentata tramite OpenAPI.
## Accedi ai Tuoi Dati a Modo Tuo
| Interfaccia | Dettagli |
|-----------|---------|
| Web UI | `http://localhost:3001` |
| Server MCP | `npx @betterdb/mcp` (stdio) - crea un token in Impostazioni → MCP Tokens (obbligatorio sul cloud, opzionale in self-hosted) |
| Prometheus | `http://localhost:3001/api/prometheus/metrics` |
| API REST (OpenAPI) | `http://localhost:3001/docs` |
| Health check | `http://localhost:3001/api/health` |
> **Nota**: nelle build di produzione (Docker, CLI) le route API sono servite sotto il prefisso `/api`. Nello sviluppo locale (`pnpm dev`) non c'è prefisso - ad esempio `http://localhost:3001/health`.
## Database Supportati
| Database | Versione Minima | Funzionalità Supportate |
|----------|----------------|-------------------|
| **Valkey** | 8.0+ | Tutte le funzionalità, incluse COMMANDLOG (8.1+) e CLUSTER SLOT-STATS |
| **Redis** | 6+ | Tutte le funzionalità tranne COMMANDLOG e CLUSTER SLOT-STATS, esclusive di Valkey |
Il backend utilizza un adapter unificato sul client `iovalkey` compatibile a livello di protocollo e rileva automaticamente Valkey o Redis dalla risposta `INFO` (`DB_TYPE=auto`). Funzionalità come COMMANDLOG e SLOT-STATS vengono rilevate per versione, e l'interfaccia utente degrada in modo controllato quando una funzionalità non è disponibile.
Sono supportati anche i servizi gestiti: le guide per AWS ElastiCache, MemoryDB, Redis Cloud e Upstash si trovano in [docs/providers](https://github.com/betterdb-inc/monitor/blob/master/docs/providers), e [`@betterdb/agent`](https://github.com/betterdb-inc/monitor/blob/master/packages/agent) raggiunge le istanze accessibili solo tramite VPC attraverso un WebSocket in uscita.
## Deployment di produzione con Docker
L'immagine Docker contiene l'applicazione di monitoraggio (backend + frontend). Richiede:
1. Un'istanza Valkey/Redis da monitorare
2. Un'istanza PostgreSQL per la persistenza dei dati (oppure l'uso dell'archiviazione in memoria)
### Esecuzione con archiviazione PostgreSQL
```bash
docker run -d \
--name betterdb-monitor \
-p 3001:3001 \
-e DB_HOST=your-valkey-host \
-e DB_PORT=6379 \
-e DB_PASSWORD=your-password \
-e STORAGE_TYPE=postgres \
-e STORAGE_URL=postgresql://user:pass@postgres-host:5432/dbname \
betterdb/monitor
```
### Esecuzione su una porta personalizzata
Imposta la variabile d'ambiente `PORT` e abbinala alla mappatura `-p`:
```bash
docker run -d \
--name betterdb-monitor \
-p 8080:8080 \
-e PORT=8080 \
-e DB_HOST=your-valkey-host \
betterdb/monitor
```
### Esecuzione con rete host (accesso ai servizi localhost)
Se Valkey e PostgreSQL sono in esecuzione sullo stesso host:
```bash
docker run -d \
--name betterdb-monitor \
--network host \
-e DB_HOST=localhost \
-e DB_PORT=6380 \
-e DB_PASSWORD=devpassword \
-e STORAGE_TYPE=postgres \
-e STORAGE_URL=postgresql://dev:devpass@localhost:5432/postgres \
betterdb/monitor
```
### Variabili d'ambiente
| Variabile | Obbligatoria | Predefinito | Descrizione |
|----------|----------|---------|-------------|
| `DB_HOST` | Sì | `localhost` | Host Valkey/Redis da monitorare |
| `DB_PORT` | No | `6379` | Porta Valkey/Redis |
| `DB_PASSWORD` | No | - | Password Valkey/Redis |
| `DB_USERNAME` | No | `default` | Nome utente ACL Valkey/Redis |
| `DB_TYPE` | No | `auto` | Tipo di database: `auto`, `valkey` o `redis` |
| `DB_TLS` | No | `false` | Impostare a `true` per connettersi al database monitorato tramite TLS (richiesto da provider gestiti come Aiven o ElastiCache Serverless) |
| `STORAGE_TYPE` | No | `memory` | Backend di archiviazione: `memory` o `postgres` |
| `STORAGE_URL` | Condizionale | - | URL di connessione PostgreSQL (obbligatorio se `STORAGE_TYPE=postgres`) |
| `STORAGE_SSL_CA` | No | - | Percorso (o URL HTTPS attendibile) di un certificato CA usato per verificare il server PostgreSQL. Per i provider gestiti con una propria CA (ad es. Aiven), fornire qui la CA del progetto per la verifica completa della catena + hostname. Ha la precedenza su `STORAGE_SSL_NO_VERIFY` |
| `STORAGE_SSL_NO_VERIFY` | No | `false` | Connettersi a PostgreSQL tramite TLS **senza** verificare il certificato del server (crittografato ma non autenticato). Comodità per i provider gestiti che presentano una propria CA e forzano `sslmode=require` quando non è possibile fornire `STORAGE_SSL_CA`. Preferire `STORAGE_SSL_CA` in produzione |
| `PORT` | No | `3001` | Porta HTTP dell'applicazione |
| `NODE_ENV` | No | `production` | Ambiente Node |
| `ANOMALY_DETECTION_ENABLED` | No | `true` | Abilita il rilevamento delle anomalie |
| `ANOMALY_PROMETHEUS_INTERVAL_MS` | No | `30000` | Intervallo di aggiornamento del riepilogo Prometheus (ms) |
| `BETTERDB_LICENSE_KEY` | No | - | Chiave di licenza online (Pro/Enterprise), validata tramite rete |
| `BETTERDB_OFFLINE_LICENSE_FILE` | No | - | Percorso di una licenza offline firmata `.jwt` per host **air-gapped** (vedi sotto) |
| `BETTERDB_OFFLINE_LICENSE` | No | - | Token di licenza offline come stringa JWT inline |
| `BETTERDB_DATA_DIR` | No | `/app/data` | Directory per lo stato della licenza persistito (montare un volume scrivibile) |
| `ENCRYPTION_KEY` | No | - | Chiave (min 16 caratteri) usata per crittografare con envelope encryption le password di connessione memorizzate e i segreti dei tunnel SSH a riposo. Senza di essa, i segreti vengono memorizzati in chiaro |
| `BETTERDB_SSH_KEY_DIR` | No | - | Directory in cui devono risiedere le chiavi private SSH lato server. Abilita l'origine chiave "percorso file server" per i [tunnel SSH](#ssh-tunnels); il percorso della chiave di una connessione deve risolversi al suo interno. Se non impostata, disabilita le chiavi basate su file (le chiavi incollate inline funzionano comunque) |
| `BETTERDB_TELEMETRY` | No | `true` | Impostare a `false` per disabilitare la telemetria anonima |
Riferimento completo, inclusi AI, ottimizzazione dei webhook e soglie di health-gate: [docs/configuration.md](https://github.com/betterdb-inc/monitor/blob/master/docs/configuration.md). Per l'ingest delle tracce OTLP e l'esportazione di metriche/eventi, vedere [docs/opentelemetry.md](https://github.com/betterdb-inc/monitor/blob/master/docs/opentelemetry.md).
### Tunnel SSH
Le connessioni possono raggiungere un database tramite un bastion/jump host SSH invece di connettersi direttamente — utile per Valkey/Redis in una subnet privata, ElastiCache o MemoryDB. Abilitare **Connect via SSH tunnel** quando si aggiunge una connessione e fornire host, porta e nome utente SSH. È supportato un singolo hop.
L'autenticazione avviene tramite password o chiave privata. Le chiavi private provengono da una di due origini:
- **Incolla chiave** (inline): il contenuto della chiave PEM viene inviato con la connessione. Viene memorizzato crittografato a riposo **solo quando `ENCRYPTION_KEY` è impostata** (envelope encryption); senza quella chiave viene memorizzato in chiaro, come le password di connessione. Funziona ovunque, incluse le distribuzioni gestite/cloud.
- **Percorso file server**: la chiave risiede già nel filesystem del server di monitoraggio ed è referenziata tramite percorso. Ciò richiede di impostare la variabile d'ambiente `BETTERDB_SSH_KEY_DIR` alla directory che contiene le chiavi consentite, e il percorso referenziato deve risolversi al suo interno, così l'API non può mai essere indotta a leggere file arbitrari. Lasciare `BETTERDB_SSH_KEY_DIR` non impostata per disabilitare questa opzione.
Facoltativamente, blocca l'**impronta della chiave host** del server SSH (`SHA256:...`) sulla connessione; se impostata, il tunnel viene rifiutato a meno che il server presenti una chiave corrispondente, prevenendo attacchi man-in-the-middle sul percorso del bastion. Se lasciata vuota, l'identità del server non viene verificata (viene registrato un avviso).
Il tunnel inoltra verso il database tramite `127.0.0.1`; quando TLS è abilitato, il certificato viene comunque validato rispetto al nome host reale del database. Imposta `ENCRYPTION_KEY` in modo che le password SSH, le passphrase delle chiavi e le chiavi inline siano crittografate a riposo.
**Limitazione nota — topologie cluster/Sentinel:** viene incanalata solo la connessione che configuri. Il monitoraggio di cluster e Sentinel si dirama verso gli altri nodi utilizzando gli indirizzi che tali nodi pubblicizzano (`CLUSTER NODES` / Sentinel), e tali connessioni per-nodo vengono effettuate direttamente, non attraverso il tunnel. Se gli altri nodi sono raggiungibili solo tramite il bastion (ad es. ElastiCache/MemoryDB in una subnet privata), le viste per-nodo non saranno disponibili. Usa i tunnel SSH per il monitoraggio di singoli nodi/primari, oppure colloca il monitor dove può raggiungere direttamente i nodi del cluster.
### Licenze e supporto air-gapped
BetterDB Monitor sblocca le funzionalità Pro/Enterprise in uno dei due modi, a seconda
che l'host abbia accesso a internet:
- **Chiave di licenza online** - imposta `BETTERDB_LICENSE_KEY`. Il monitor la convalida
rispetto a `betterdb.com` e memorizza nella cache un **token firmato** verificato localmente, così il tuo
livello continua a funzionare durante brevi interruzioni e riavvii.
- **Token di licenza offline / air-gapped** - per host **senza alcun accesso a internet**
(vedi sotto).
#### Come funziona la licenza air-gapped
Ogni diritto è un **JWT RS256 firmato**. Il monitor lo verifica **localmente**
rispetto a chiavi pubbliche incorporate nell'immagine - non deve mai raggiungere un server di licenza
per fidarsi di un token. Quindi un host air-gapped può eseguire i livelli a pagamento con connettività zero:
1. Su una macchina connessa a internet, accedi a
[betterdb.com/account/licenses](https://www.betterdb.com/account/licenses) e
**scarica il tuo token di licenza offline** (`.jwt`, Pro/Enterprise). Non contiene
segreti e non può essere manomesso - qualsiasi modifica invalida la firma.
2. Trasferiscilo sull'host air-gapped come preferisci (USB, gestione della configurazione, un
mount di secret Docker/Kubernetes).
3. Forniscilo tramite `BETTERDB_OFFLINE_LICENSE_FILE` (percorso), `BETTERDB_OFFLINE_LICENSE`
(stringa inline), oppure incollalo nell'interfaccia utente sotto **Settings → License → "Air-gapped
environment? Activate an offline license."**
Quando è configurato un token offline e **non** è impostata alcuna `BETTERDB_LICENSE_KEY`, il
monitor effettua **zero richieste in uscita** - i controlli di licenza, la telemetria e i ping di aggiornamento
sono tutti disabilitati. Esegue il livello concesso fino alla scadenza del token (le licenze
perpetue vengono riscaricate annualmente), poi torna a Community.
```bash
# fully offline - no network required
docker volume create betterdb-data
docker run --rm -v betterdb-data:/d alpine chown 1001:1001 /d # volume writable by UID 1001 (one-time)
docker run -d --name betterdb-monitor -p 3001:3001 \
-e DB_HOST=your-valkey-host -e DB_PORT=6379 -e DB_PASSWORD=your-password \
-v /path/to/betterdb-license.jwt:/run/secrets/betterdb-license.jwt:ro \
-e BETTERDB_OFFLINE_LICENSE_FILE=/run/secrets/betterdb-license.jwt \
-v betterdb-data:/app/data \
betterdb/monitor
```
Verifica con `GET /api/license/status` → `source: offline-token`, `mode: offline`,
`airGapped: true`.
> **Persistenza:** monta un volume scrivibile su `/app/data` in modo che la licenza offline e
> il token di tolleranza per le interruzioni online sopravvivano ai riavvii. Il container viene eseguito come **UID 1001**,
> quindi un volume appena creato deve essere sottoposto a `chown` verso tale UID (come mostrato sopra) - altrimenti
> la persistenza fallisce con `EACCES … license.jwt`.
Per il flusso completo, la precedenza di verifica e la procedura di rotazione delle chiavi consulta
**[Licenze offline e air-gapped](https://github.com/betterdb-inc/monitor/blob/master/docs/offline-licenses.md)** e il
**[Riferimento di configurazione](https://github.com/betterdb-inc/monitor/blob/master/docs/configuration.md#license-configuration)**.
### Dettagli dell'immagine Docker
- **Immagine di base**: `node:20-alpine`
- **Dimensione compressa**: ~360MB (`latest` / `-no-ai`) / ~640MB (immagine versionata con le dipendenze local-LLM dell'AI Helper sperimentale)
- **Piattaforme**: `linux/amd64`, `linux/arm64`
- **Contiene**: API backend + file statici del frontend (serviti da Fastify)
- **Escluso**: supporto SQLite (usa PostgreSQL o Memory storage)
### Operazioni sul container
```bash
docker logs -f betterdb-monitor # follow logs
docker stop betterdb-monitor # stop
docker rm betterdb-monitor # remove
```
## Backend di archiviazione
BetterDB Monitor persiste audit trail, analytics, catture e dati di anomalia su uno dei quattro backend:
| Backend | Caso d'uso | Note |
|---------|----------|-------|
| `memory` | Test, ambienti effimeri | Predefinito in Docker; tutti i dati vengono persi al riavvio |
| `postgres` | Produzione | `STORAGE_TYPE=postgres` + `STORAGE_URL=postgresql://user:pass@host:port/db` |
| `turso` | Produzione / SQLite serverless | `STORAGE_TYPE=turso` + `STORAGE_URL=libsql://...` + `STORAGE_AUTH_TOKEN`; funziona in Docker |
| `sqlite` | Sviluppo locale / CLI | Modulo nativo rimosso dall'immagine Docker `latest`; `STORAGE_SQLITE_FILEPATH` opzionale |
## Metriche Prometheus
Le metriche sono esposte su `GET /api/prometheus/metrics` in formato testo Prometheus: audit ACL, connessioni client, pattern slowlog/commandlog, memoria, throughput, keyspace, replica, statistiche degli slot del cluster e metriche runtime di Node.js - tutte con prefisso `betterdb_`.
```yaml
scrape_configs:
- job_name: 'betterdb-monitor'
metrics_path: '/api/prometheus/metrics'
static_configs:
- targets: ['your-monitor-host:3001']
```
Riferimento completo delle metriche: [docs/prometheus-metrics.md](https://github.com/betterdb-inc/monitor/blob/master/docs/prometheus-metrics.md) e [docs/prometheus-integration.md](https://github.com/betterdb-inc/monitor/blob/master/docs/prometheus-integration.md).
## Sviluppo
### Struttura del progetto
```
betterdb-monitor/
├── apps/
│ ├── api/ # NestJS backend (Fastify)
│ └── web/ # React frontend (Vite)
├── packages/ # Published packages (see below)
├── docs/ # Documentation site (Jekyll)
├── docker-compose.yml # Local Valkey (port 6380) and Redis (port 6382) for testing
└── package.json # Workspace root
```
### Pacchetti
Questo monorepo include diversi pacchetti standalone. Consulta [`packages/`](https://github.com/betterdb-inc/monitor/blob/master/packages) per l'elenco completo.
| Pacchetto | Linguaggio | Registry |
|---|---|---|
| [`@betterdb/monitor`](https://github.com/betterdb-inc/monitor/blob/master/packages/cli) | TypeScript | [npm](https://www.npmjs.com/package/@betterdb/monitor) |
| [`@betterdb/mcp`](https://github.com/betterdb-inc/monitor/blob/master/packages/mcp) | TypeScript | [npm](https://www.npmjs.com/package/@betterdb/mcp) |
| [`@betterdb/agent`](https://github.com/betterdb-inc/monitor/blob/master/packages/agent) | TypeScript | [npm](https://www.npmjs.com/package/@betterdb/agent) |
| [`@betterdb/semantic-cache`](https://github.com/betterdb-inc/monitor/blob/master/packages/semantic-cache) | TypeScript | [npm](https://www.npmjs.com/package/@betterdb/semantic-cache) |
| [`betterdb-semantic-cache`](https://github.com/betterdb-inc/monitor/blob/master/packages/semantic-cache-py) | Python | [PyPI](https://pypi.org/project/betterdb-semantic-cache/) |
| [`@betterdb/agent-cache`](https://github.com/betterdb-inc/monitor/blob/master/packages/agent-cache) | TypeScript | [npm](https://www.npmjs.com/package/@betterdb/agent-cache) |
| [`betterdb-agent-cache`](https://github.com/betterdb-inc/monitor/blob/master/packages/agent-cache-py) | Python | [PyPI](https://pypi.org/project/betterdb-agent-cache/) |
| [`cache-benchmark`](https://github.com/betterdb-inc/monitor/blob/master/packages/cache-benchmark) | Python | Harness di replay per il benchmarking delle cache semantiche |
### Stack tecnologico
- **Backend**: NestJS con adattatore Fastify, `iovalkey` per le connessioni Valkey/Redis, TypeScript in modalità strict. Porta **3001**.
- **Frontend**: React + TypeScript, Vite, TailwindCSS, Recharts. Server di sviluppo sulla porta **5173**.
- **Monorepo**: pnpm workspaces + Turborepo.
### Configurazione locale
Prerequisiti: Node.js >= 20.0.0, pnpm >= 9.0.0, Docker.
```bash
pnpm install
cp .env.example .env
pnpm docker:dev # local Valkey (6380) and Redis (6382)
pnpm dev # web on :5173, api on :3001
```
Per connettersi a Redis invece di Valkey, impostare `DB_PORT=6382` in `.env`.
```bash
pnpm dev:api # API only
pnpm dev:web # frontend only
pnpm docker:dev:down # stop local databases
pnpm build # production build
pnpm test # API tests
```
Build delle immagini Docker:
```bash
pnpm docker:build # local build
pnpm docker:publish # multi-arch build & push (requires buildx)
```
### Aggiunta di nuove funzionalità
1. Aggiungi nuovi endpoint in `apps/api/src/`
2. Aggiungi le chiamate API corrispondenti in `apps/web/src/api/`
3. Aggiungi i tipi condivisi in `packages/shared/src/types/`
### Stile del codice
- TypeScript in modalità strict, tipi di ritorno espliciti, nessun `any`
- ESLint + Prettier configurati
## Licenza
- Il contenuto sotto `docs/` è concesso in licenza secondo CC BY-SA 4.0.
- Il contenuto sotto `proprietary/` è coperto da una licenza commerciale (vedi `proprietary/LICENSE`). Queste funzionalità sono gratuite durante l'accesso anticipato.
- Tutto il resto è [MIT](https://github.com/betterdb-inc/monitor/blob/master/LICENSE).