@cybermem/mcp 0.5.1 → 0.6.0

package/dist/templates/docker-compose.yml

@@ -1,219 +0,0 @@
-# CyberMem - OpenMemory + DevOps monitoring stack
-# For local development only
-# Production deployment: use Helm chart (charts/cybermem/)
-
-services:
-  traefik:
-    image: traefik:v3.0
-    container_name: cybermem-traefik
-    command:
-      - --api.dashboard=true
-      - --api.insecure=true
-      - --providers.docker=true
-      - --providers.docker.exposedbydefault=false
-      - --entrypoints.web.address=:8626
-      - --accesslog=true
-      - --accesslog.filepath=/var/log/traefik/access.log
-      - --accesslog.format=json
-    ports:
-      - "8626:8626"
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock:ro
-      - ./monitoring/traefik/traefik.yml:/etc/traefik/traefik.yml:ro
-      - traefik-logs:/var/log/traefik
-    labels:
-      - traefik.enable=true
-    restart: unless-stopped
-
-  openmemory:
-    image: ghcr.io/mikhailkogan17/cybermem-openmemory:latest
-    container_name: cybermem-openmemory
-    ports: [] # Access via Traefik on 8626
-    volumes:
-      - openmemory-data:/data
-      - ${CYBERMEM_ENV_PATH}:/.env
-    environment:
-      # Core settings
-      OM_PORT: "8080"
-      OM_TIER: "deep"
-      # API Key is loaded from /.env file
-
-      # Embeddings (local dev uses Ollama)
-      OM_EMBEDDINGS: ${EMBEDDINGS_PROVIDER:-ollama}
-      OLLAMA_URL: ${OLLAMA_URL:-http://ollama:11434}
-      OPENAI_API_KEY: ${OPENAI_API_KEY:-}
-
-      # Database (local dev uses SQLite)
-      OM_METADATA_BACKEND: ${DB_BACKEND:-sqlite}
-      OM_DB_PATH: ${DB_PATH:-/data/openmemory.sqlite}
-      OM_VECTOR_BACKEND: ${VECTOR_BACKEND:-sqlite}
-
-      # PostgreSQL (for production/testing)
-      OM_PG_HOST: ${PG_HOST:-postgres}
-      OM_PG_PORT: ${PG_PORT:-5432}
-      OM_PG_DB: ${PG_DB:-openmemory}
-      OM_PG_USER: ${PG_USER:-openmemory}
-      OM_PG_PASSWORD: ${PG_PASSWORD:-}
-
-      # Performance
-      OM_RATE_LIMIT_ENABLED: "true"
-      OM_RATE_LIMIT_MAX_REQUESTS: "1000"
-
-    labels:
-      - traefik.enable=true
-      - traefik.http.routers.openmemory.entrypoints=web
-      - traefik.http.routers.openmemory.rule=PathPrefix(`/memory`) || PathPrefix(`/health`) || PathPrefix(`/v1`) || PathPrefix(`/api`) || PathPrefix(`/all`) || PathPrefix(`/add`) || PathPrefix(`/mcp`) || PathPrefix(`/sse`)
-      - traefik.http.services.openmemory.loadbalancer.server.port=8080
-    healthcheck:
-      test:
-        [
-          "CMD",
-          "wget",
-          "--quiet",
-          "--tries=1",
-          "--spider",
-          "http://localhost:8080/health",
-        ]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 40s
-    restart: unless-stopped
-    depends_on:
-      - traefik
-
-  db-exporter:
-    image: ghcr.io/mikhailkogan17/cybermem-db_exporter:latest
-    container_name: cybermem-db-exporter
-    environment:
-      DB_PATH: /data/openmemory.sqlite
-      SCRAPE_INTERVAL: "15"
-      EXPORTER_PORT: "8000"
-    ports:
-      - "8000:8000"
-    volumes:
-      - openmemory-data:/data:ro
-    restart: unless-stopped
-    depends_on:
-      - openmemory
-
-  log-exporter:
-    image: ghcr.io/mikhailkogan17/cybermem-log_exporter:latest
-    container_name: cybermem-log-exporter
-    environment:
-      LOG_FILE: /var/log/traefik/access.log
-      SCRAPE_INTERVAL: "5"
-      EXPORTER_PORT: "8001"
-      DB_PATH: /data/openmemory.sqlite
-    volumes:
-      - traefik-logs:/var/log/traefik:ro
-      - openmemory-data:/data
-      - ./monitoring/log_exporter/exporter.py:/app/exporter.py:ro
-    restart: unless-stopped
-    depends_on:
-      - traefik
-      - openmemory
-
-  postgres:
-    image: postgres:15-alpine
-    container_name: cybermem-postgres
-    environment:
-      POSTGRES_DB: ${PG_DB:-openmemory}
-      POSTGRES_USER: ${PG_USER:-openmemory}
-      POSTGRES_PASSWORD: ${PG_PASSWORD:-postgres}
-    ports:
-      - "5432:5432"
-    volumes:
-      - postgres-data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U ${PG_USER:-openmemory}"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-    restart: unless-stopped
-    profiles:
-      - postgres
-
-  postgres-exporter:
-    image: prometheuscommunity/postgres-exporter:v0.15.0
-    container_name: cybermem-postgres-exporter
-    environment:
-      DATA_SOURCE_NAME: postgresql://${PG_USER:-openmemory}:${PG_PASSWORD:-postgres}@postgres:5432/${PG_DB:-openmemory}?sslmode=disable
-      PG_EXPORTER_EXTEND_QUERY_PATH: /queries.yml
-    ports:
-      - "9187:9187"
-    volumes:
-      - ./monitoring/postgres_exporter/queries.yml:/queries.yml:ro
-    restart: unless-stopped
-    depends_on:
-      - postgres
-    profiles:
-      - postgres
-
-  ollama:
-    image: ollama/ollama:latest
-    container_name: cybermem-ollama
-    ports:
-      - "11434:11434"
-    volumes:
-      - ollama-models:/root/.ollama
-    restart: unless-stopped
-    profiles:
-      - ollama
-
-  prometheus:
-    image: prom/prometheus:v2.48.0
-    container_name: cybermem-prometheus
-    command:
-      - --config.file=/etc/prometheus/prometheus.yml
-      - --storage.tsdb.path=/prometheus
-      - --storage.tsdb.retention.time=${PROM_RETENTION:-7d}
-      - --web.console.libraries=/usr/share/prometheus/console_libraries
-      - --web.console.templates=/usr/share/prometheus/consoles
-    ports:
-      - "9092:9090"
-    volumes:
-      - ./monitoring/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
-      - prometheus-data:/prometheus
-    restart: unless-stopped
-    depends_on:
-      - db-exporter
-
-  dashboard:
-    image: ghcr.io/mikhailkogan17/cybermem-dashboard:latest
-    container_name: cybermem-dashboard
-    environment:
-      NEXT_PUBLIC_PROMETHEUS_URL: http://prometheus:9090
-      PROMETHEUS_URL: http://prometheus:9090
-      OM_API_KEY: ${OM_API_KEY:-dev-secret-key}
-      # WATCHPACK_POLLING: "true" # Enable if hot reload blocks (high CPU usage)
-    ports:
-      - "3000:3000"
-    volumes:
-      - openmemory-data:/data
-      - /var/run/docker.sock:/var/run/docker.sock
-      - ${CYBERMEM_ENV_PATH}:/app/shared.env
-    restart: unless-stopped
-    depends_on:
-      - prometheus
-
-volumes:
-  openmemory-data:
-    name: cybermem-openmemory-data
-    driver: local
-  postgres-data:
-    name: cybermem-postgres-data
-    driver: local
-  ollama-models:
-    name: cybermem-ollama-models
-    driver: local
-  prometheus-data:
-    name: cybermem-prometheus-data
-    driver: local
-  traefik-logs:
-    name: cybermem-traefik-logs
-    driver: local
-
-networks:
-  default:
-    name: cybermem-network

package/dist/templates/envs/local.example

@@ -1,27 +0,0 @@
-# Example environment configuration
-# Copy to .env and customize
-
-# Embeddings provider: ollama (local) or openai (cloud)
-EMBEDDINGS_PROVIDER=ollama
-OLLAMA_URL=http://ollama:11434
-OPENAI_API_KEY=
-
-# Database backend: sqlite (local/rpi) or postgres (vps)
-DB_BACKEND=sqlite
-DB_PATH=/data/openmemory.sqlite
-VECTOR_BACKEND=sqlite
-
-# PostgreSQL settings (only for DB_BACKEND=postgres)
-PG_HOST=postgres
-PG_PORT=5432
-PG_DB=openmemory
-PG_USER=openmemory
-PG_PASSWORD=change-me
-
-# OpenMemory API key (Optional for local mode)
-# CYBERMEM_API_KEY=
-
-# Monitoring
-PROM_RETENTION=7d
-GRAFANA_USER=admin
-GRAFANA_PASSWORD=admin

package/dist/templates/envs/rpi.example

@@ -1,27 +0,0 @@
-# Raspberry Pi environment
-# Optimized for low memory (1GB total)
-DOCKER_PLATFORM=linux/arm64
-
-
-# Embeddings (use Ollama with small models)
-EMBEDDINGS_PROVIDER=ollama
-OLLAMA_URL=http://ollama:11434
-OPENAI_API_KEY=
-
-# Database (SQLite for RPi - low memory footprint)
-DB_BACKEND=sqlite
-DB_PATH=/data/openmemory.sqlite
-
-# PostgreSQL (not used)
-PG_HOST=postgres
-PG_DB=openmemory
-PG_USER=openmemory
-PG_PASSWORD=not-used
-
-# OpenMemory
-CYBERMEM_API_KEY=key-change-me
-
-# Monitoring (short retention for disk space)
-PROM_RETENTION=3d
-GRAFANA_USER=admin
-GRAFANA_PASSWORD=admin

package/dist/templates/envs/vps.example

@@ -1,25 +0,0 @@
-# VPS production environment
-# For Hetzner CX22 or similar (2 vCPU, 4GB RAM)
-
-# Embeddings (use OpenAI for production)
-EMBEDDINGS_PROVIDER=openai
-OPENAI_API_KEY=sk-change-me-in-production
-OLLAMA_URL=
-
-# Database (PostgreSQL for production)
-DB_BACKEND=postgres
-VECTOR_BACKEND=postgres
-
-# PostgreSQL
-PG_HOST=postgres
-PG_DB=openmemory
-PG_USER=openmemory
-PG_PASSWORD=change-me-in-production-use-secrets
-
-# OpenMemory
-CYBERMEM_API_KEY=change-me-in-production-use-secrets
-
-# Monitoring
-PROM_RETENTION=30d
-GRAFANA_USER=admin
-GRAFANA_PASSWORD=change-me-in-production-use-secrets

package/dist/templates/monitoring/db_exporter/Dockerfile

@@ -1,19 +0,0 @@
-FROM python:3.11-alpine
-
-WORKDIR /app
-
-# Install dependencies
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy exporter script
-COPY exporter.py .
-
-# Make script executable
-RUN chmod +x exporter.py
-
-# Expose Prometheus metrics port
-EXPOSE 8000
-
-# Run exporter
-CMD ["python", "-u", "exporter.py"]

package/dist/templates/monitoring/db_exporter/exporter.py

@@ -1,313 +0,0 @@
-#!/usr/bin/env python3
-"""
-CyberMem Database Exporter for Prometheus
-
-Queries OpenMemory's database and exports per-client metrics to Prometheus.
-Replaces the complex Vector + Traefik access logs pipeline with simple DB queries.
-"""
-
-import os
-import time
-import sqlite3
-import json
-from prometheus_client import Gauge, Info, generate_latest, CONTENT_TYPE_LATEST
-from flask import Flask, Response, request, jsonify
-import logging
-import threading
-
-# Configuration
-DB_PATH = os.getenv("DB_PATH", "/data/openmemory.sqlite")
-SCRAPE_INTERVAL = int(os.getenv("SCRAPE_INTERVAL", "15"))  # seconds
-EXPORTER_PORT = int(os.getenv("EXPORTER_PORT", "8000"))
-
-# Setup logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger("db_exporter")
-
-# Prometheus metrics
-info = Info('cybermem_exporter', 'CyberMem Database Exporter Info')
-info.info({'version': '1.0.0', 'db_path': DB_PATH})
-
-memories_total = Gauge(
-    'openmemory_memories_total',
-    'Total number of memories stored',
-    ['client']
-)
-
-memories_recent_24h = Gauge(
-    'openmemory_memories_recent_24h',
-    'Memories created in the last 24 hours',
-    ['client']
-)
-
-memories_recent_1h = Gauge(
-    'openmemory_memories_recent_1h',
-    'Memories created in the last hour',
-    ['client']
-)
-
-requests_by_operation = Gauge(
-    'openmemory_requests_total',
-    'Total requests by client and operation (from cybermem_stats table)',
-    ['client_name', 'operation']
-)
-
-errors_by_operation = Gauge(
-    'openmemory_errors_total',
-    'Total errors by client and operation (from cybermem_stats table)',
-    ['client_name', 'operation']
-)
-
-sectors_count = Gauge(
-    'openmemory_sectors_total',
-    'Number of unique sectors per client',
-    ['client']
-)
-
-avg_score = Gauge(
-    'openmemory_avg_score',
-    'Average score of memories',
-    ['client']
-)
-
-# Aggregate metrics (not per-client)
-total_requests_aggregate = Gauge(
-    'openmemory_requests_aggregate_total',
-    'Total API requests (aggregate, from stats table)'
-)
-
-total_errors_aggregate = Gauge(
-    'openmemory_errors_aggregate_total',
-    'Total API errors (aggregate, from stats table)'
-)
-
-success_rate_aggregate = Gauge(
-    'openmemory_success_rate_aggregate',
-    'API success rate percentage (aggregate)'
-)
-
-
-def get_db_connection():
-    """Get SQLite database connection."""
-    try:
-        conn = sqlite3.connect(DB_PATH)
-        conn.row_factory = sqlite3.Row
-        return conn
-    except Exception as e:
-        logger.error(f"Failed to connect to database: {e}")
-        raise
-
-
-def collect_metrics():
-    """Collect all metrics from OpenMemory database."""
-    try:
-        db = get_db_connection()
-        cursor = db.cursor()
-
-        # Metric 1: Total memories per client
-        cursor.execute('''
-            SELECT user_id as client, COUNT(*) as count
-            FROM memories
-            GROUP BY user_id
-        ''')
-        for row in cursor.fetchall():
-            client = row['client'] or 'anonymous'
-            memories_total.labels(client=client).set(row['count'])
-
-        logger.debug(f"Collected total memories for {cursor.rowcount} clients")
-
-        # Metric 2: Recent memories (24h)
-        # Note: created_at is stored as milliseconds since epoch
-        cursor.execute('''
-            SELECT user_id as client, COUNT(*) as count
-            FROM memories
-            WHERE created_at > ?
-            GROUP BY user_id
-        ''', [int((time.time() - 86400) * 1000)])
-        for row in cursor.fetchall():
-            client = row['client'] or 'anonymous'
-            memories_recent_24h.labels(client=client).set(row['count'])
-
-        logger.debug(f"Collected 24h memories for {cursor.rowcount} clients")
-
-        # Metric 3: Recent memories (1h)
-        cursor.execute('''
-            SELECT user_id as client, COUNT(*) as count
-            FROM memories
-            WHERE created_at > ?
-            GROUP BY user_id
-        ''', [int((time.time() - 3600) * 1000)])
-        for row in cursor.fetchall():
-            client = row['client'] or 'anonymous'
-            memories_recent_1h.labels(client=client).set(row['count'])
-
-        logger.debug(f"Collected 1h memories for {cursor.rowcount} clients")
-
-        # Metric 4: Per-client request stats from cybermem_stats table
-        cursor.execute('''
-            SELECT client_name, operation, count, errors
-            FROM cybermem_stats
-        ''')
-        for row in cursor.fetchall():
-            client_name = row['client_name'] or 'unknown'
-            operation = row['operation']
-            count = row['count']
-            errors = row['errors']
-            requests_by_operation.labels(client_name=client_name, operation=operation).set(count)
-            errors_by_operation.labels(client_name=client_name, operation=operation).set(errors)
-
-        logger.debug(f"Collected request stats for {cursor.rowcount} client/operation pairs")
-
-        # Metric 5: Aggregate request stats from OpenMemory's stats table
-        # Note: stats table has no client_id, so these are aggregate only
-        hour_ago_ms = int((time.time() - 3600) * 1000)
-
-        # Get total requests (sum of qps snapshots)
-        cursor.execute('''
-            SELECT SUM(count) as total
-            FROM stats
-            WHERE type = 'qps' AND ts > ?
-        ''', [hour_ago_ms])
-        total_reqs = cursor.fetchone()['total'] or 0
-        total_requests_aggregate.set(total_reqs)
-
-        # Get total errors
-        cursor.execute('''
-            SELECT COUNT(*) as total
-            FROM stats
-            WHERE type = 'error' AND ts > ?
-        ''', [hour_ago_ms])
-        total_errs = cursor.fetchone()['total'] or 0
-        total_errors_aggregate.set(total_errs)
-
-        # Calculate success rate
-        if total_reqs > 0:
-            success_rate = ((total_reqs - total_errs) / total_reqs) * 100
-            success_rate_aggregate.set(max(0.0, success_rate))  # Cap at 0% minimum
-        else:
-            success_rate_aggregate.set(100.0)  # No requests = 100% success
-
-        logger.debug(f"Collected aggregate stats: {total_reqs} reqs, {total_errs} errs")
-
-        # Metric 5: Number of unique sectors per client
-        cursor.execute('''
-            SELECT user_id as client, COUNT(DISTINCT primary_sector) as count
-            FROM memories
-            WHERE primary_sector IS NOT NULL
-            GROUP BY user_id
-        ''')
-        for row in cursor.fetchall():
-            client = row['client'] or 'anonymous'
-            sectors_count.labels(client=client).set(row['count'])
-
-        logger.debug(f"Collected sectors count for {cursor.rowcount} clients")
-
-        # Metric 6: Average feedback score per client
-        cursor.execute('''
-            SELECT user_id as client, AVG(feedback_score) as avg_score
-            FROM memories
-            WHERE feedback_score IS NOT NULL
-            GROUP BY user_id
-        ''')
-        for row in cursor.fetchall():
-            client = row['client'] or 'anonymous'
-            avg_score.labels(client=client).set(row['avg_score'] or 0)
-
-        logger.debug(f"Collected average scores for {cursor.rowcount} clients")
-
-        db.close()
-        logger.info("Metrics collection completed successfully")
-
-    except Exception as e:
-        logger.error(f"Error collecting metrics: {e}", exc_info=True)
-
-
-def get_logs_from_db(start_ms: int, limit: int = 100):
-    """Get access logs from database"""
-    try:
-        db = get_db_connection()
-        cursor = db.cursor()
-
-        cursor.execute('''
-            SELECT timestamp, client_name, client_version, method, endpoint, operation, status, is_error
-            FROM cybermem_access_log
-            WHERE timestamp >= ?
-            ORDER BY timestamp DESC
-            LIMIT ?
-        ''', [start_ms, limit])
-
-        logs = []
-        for row in cursor.fetchall():
-            logs.append({
-                'timestamp': row['timestamp'],
-                'client_name': row['client_name'],
-                'client_version': row['client_version'],
-                'method': row['method'],
-                'endpoint': row['endpoint'],
-                'operation': row['operation'],
-                'status': row['status'],
-                'is_error': bool(row['is_error'])
-            })
-
-        db.close()
-        return logs
-    except Exception as e:
-        logger.error(f"Error fetching logs: {e}", exc_info=True)
-        return []
-
-
-# Create Flask app
-app = Flask(__name__)
-
-@app.route('/metrics')
-def metrics():
-    """Prometheus metrics endpoint"""
-    return Response(generate_latest(), mimetype=CONTENT_TYPE_LATEST)
-
-@app.route('/api/logs')
-def api_logs():
-    """Access logs API endpoint"""
-    try:
-        start_ms = int(request.args.get('start', 0))
-        limit = int(request.args.get('limit', 100))
-
-        logs = get_logs_from_db(start_ms, limit)
-        return jsonify({'logs': logs})
-    except Exception as e:
-        logger.error(f"Error in /api/logs: {e}", exc_info=True)
-        return jsonify({'error': str(e)}), 500
-
-def metrics_collection_loop():
-    """Background thread for collecting metrics"""
-    logger.info("Starting metrics collection loop")
-    while True:
-        try:
-            collect_metrics()
-            time.sleep(SCRAPE_INTERVAL)
-        except Exception as e:
-            logger.error(f"Error in metrics collection: {e}", exc_info=True)
-            time.sleep(SCRAPE_INTERVAL)
-
-def main():
-    """Start the exporter and metrics collection loop."""
-    logger.info(f"Starting CyberMem Database Exporter on port {EXPORTER_PORT}")
-    logger.info(f"Database path: {DB_PATH}")
-    logger.info(f"Scrape interval: {SCRAPE_INTERVAL}s")
-
-    # Start metrics collection in background thread
-    metrics_thread = threading.Thread(target=metrics_collection_loop, daemon=True)
-    metrics_thread.start()
-
-    # Start Flask HTTP server
-    logger.info(f"Starting HTTP server on http://0.0.0.0:{EXPORTER_PORT}")
-    logger.info(f"  Metrics: http://0.0.0.0:{EXPORTER_PORT}/metrics")
-    logger.info(f"  Logs API: http://0.0.0.0:{EXPORTER_PORT}/api/logs")
-
-    app.run(host='0.0.0.0', port=EXPORTER_PORT, threaded=True)
-
-
-if __name__ == '__main__':
-    main()

package/dist/templates/monitoring/db_exporter/requirements.txt

@@ -1,2 +0,0 @@
-prometheus-client==0.19.0
-flask==3.0.0