# 1. Clone and setup
git clone https://github.com/case-404/SentinentalBERT.git
cd SentinentalBERT

# 2. Setup Python environment
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# 3. Start NLP service
cd services/nlp
python main.py &

# 4. Setup and start frontend
cd ../../frontend
npm install --legacy-peer-deps
npm start

# Update system
sudo apt update && sudo apt upgrade -y

# Install Python and Node.js
sudo apt install python3 python3-pip python3-venv -y
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs

# Install Homebrew if not installed
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install Python and Node.js
brew install python@3.11 node

# Clone repository
git clone https://github.com/case-404/SentinentalBERT.git
cd SentinentalBERT

# Create Python virtual environment
python3 -m venv venv
source venv/bin/activate  # Linux/macOS
# venv\Scripts\activate   # Windows

# Install Python dependencies
pip install -r requirements.txt

cd services/nlp
python main.py

cd SentinentalBERT/frontend

# Install dependencies
npm install --legacy-peer-deps

# Create environment file
echo "DANGEROUSLY_DISABLE_HOST_CHECK=true" > .env
echo "REACT_APP_API_URL=http://localhost:8000" >> .env

# Start frontend
npm start

# Ubuntu/Debian
sudo apt update
sudo apt install -y docker.io docker-compose
sudo usermod -aG docker $USER
newgrp docker

# macOS (using Homebrew)
brew install docker docker-compose

# Verify installation
docker --version
docker-compose --version

# Ubuntu/Debian
sudo apt install -y git

# macOS
brew install git

# Verify installation
git --version

# Using Node Version Manager (recommended)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
source ~/.bashrc
nvm install 18
nvm use 18

# Verify installation
node --version
npm --version

# Install Rust toolchain
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# Verify installation
rustc --version
cargo --version

# Ubuntu/Debian
sudo apt install -y openjdk-17-jdk maven

# macOS
brew install openjdk@17 maven

# Verify installation
java --version
mvn --version

# Ubuntu/Debian
sudo apt install -y python3.11 python3.11-pip python3.11-venv

# macOS
brew install python@3.11

# Verify installation
python3.11 --version
pip3.11 --version

# Clone the main repository
git clone https://github.com/your-org/SentinelBERT.git
cd SentinelBERT

# Verify project structure
ls -la

SentinelBERT/
├── services/
│   ├── ingestion/          # Rust-based data ingestion service
│   ├── nlp/               # Python-based NLP processing service
│   └── backend/           # Spring Boot backend service
├── frontend/              # React-based dashboard
├── database/              # Database initialization scripts
├── monitoring/            # Prometheus, Grafana configurations
├── k8s/                  # Kubernetes deployment manifests
├── docker-compose.yml    # Local development environment
└── docs/                 # Additional documentation

# Add to .env file
TWITTER_BEARER_TOKEN=your_bearer_token_here

# Add to .env file
REDDIT_CLIENT_ID=your_client_id_here
REDDIT_CLIENT_SECRET=your_client_secret_here
REDDIT_USER_AGENT=SentinelBERT/1.0

# Add to .env file
YOUTUBE_API_KEY=your_api_key_here

# Add to .env file
INSTAGRAM_ACCESS_TOKEN=your_access_token_here

# Add to .env file
TELEGRAM_BOT_TOKEN=your_bot_token_here

# Copy example environment file
cp .env.example .env

# Edit with your configuration
nano .env

# =============================================================================
# SentinelBERT Environment Configuration
# =============================================================================

# -----------------------------------------------------------------------------
# Database Configuration
# -----------------------------------------------------------------------------
POSTGRES_DB=sentinelbert
POSTGRES_USER=sentinel
POSTGRES_PASSWORD=your_secure_password_here
POSTGRES_HOST=postgres
POSTGRES_PORT=5432

# -----------------------------------------------------------------------------
# Redis Configuration
# -----------------------------------------------------------------------------
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_PASSWORD=your_redis_password_here

# -----------------------------------------------------------------------------
# ElasticSearch Configuration
# -----------------------------------------------------------------------------
ELASTICSEARCH_HOST=elasticsearch
ELASTICSEARCH_PORT=9200
ELASTICSEARCH_USERNAME=elastic
ELASTICSEARCH_PASSWORD=your_elastic_password_here

# -----------------------------------------------------------------------------
# Social Media API Keys (Free Tier)
# -----------------------------------------------------------------------------
# Twitter/X.com API
TWITTER_BEARER_TOKEN=your_twitter_bearer_token_here

# Reddit API
REDDIT_CLIENT_ID=your_reddit_client_id_here
REDDIT_CLIENT_SECRET=your_reddit_client_secret_here
REDDIT_USER_AGENT=SentinelBERT/1.0

# YouTube Data API
YOUTUBE_API_KEY=your_youtube_api_key_here

# Instagram Basic Display API
INSTAGRAM_ACCESS_TOKEN=your_instagram_access_token_here

# Telegram Bot API
TELEGRAM_BOT_TOKEN=your_telegram_bot_token_here

# -----------------------------------------------------------------------------
# Security Configuration
# -----------------------------------------------------------------------------
JWT_SECRET=your_jwt_secret_key_minimum_32_characters_long
JWT_EXPIRATION=900  # 15 minutes
JWT_REFRESH_EXPIRATION=604800  # 7 days

# Encryption keys (generate with: openssl rand -base64 32)
ENCRYPTION_KEY=your_encryption_key_here
HASH_SALT=your_hash_salt_here

# -----------------------------------------------------------------------------
# Application Configuration
# -----------------------------------------------------------------------------
# Environment (development, staging, production)
ENVIRONMENT=development

# API Configuration
API_HOST=0.0.0.0
API_PORT=8080
API_WORKERS=4

# NLP Service Configuration
NLP_HOST=0.0.0.0
NLP_PORT=8000
NLP_WORKERS=2
MODEL_PATH=/app/models
CUDA_VISIBLE_DEVICES=0

# Ingestion Service Configuration
INGESTION_HOST=0.0.0.0
INGESTION_PORT=8081
RUST_LOG=info

# Frontend Configuration
REACT_APP_API_URL=http://localhost:8080
REACT_APP_WEBSOCKET_URL=ws://localhost:8080
REACT_APP_VERSION=1.0.0

# -----------------------------------------------------------------------------
# Monitoring Configuration
# -----------------------------------------------------------------------------
# Prometheus
PROMETHEUS_PORT=9090

# Grafana
GRAFANA_USER=admin
GRAFANA_PASSWORD=your_grafana_password_here
GRAFANA_PORT=3001

# Jaeger Tracing
JAEGER_PORT=16686

# -----------------------------------------------------------------------------
# Rate Limiting Configuration
# -----------------------------------------------------------------------------
# Requests per minute per IP
RATE_LIMIT_PER_MINUTE=100

# Requests per hour per user
RATE_LIMIT_PER_HOUR=1000

# -----------------------------------------------------------------------------
# Data Retention Configuration
# -----------------------------------------------------------------------------
# Data retention period in days
DATA_RETENTION_DAYS=730  # 2 years

# Log retention period in days
LOG_RETENTION_DAYS=90

# Cache TTL in seconds
CACHE_TTL=3600  # 1 hour

# -----------------------------------------------------------------------------
# Email Configuration (for alerts)
# -----------------------------------------------------------------------------
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USER=your_email@gmail.com
SMTP_PASSWORD=your_app_password_here
SMTP_FROM=noreply@sentinelbert.com

# Generate JWT secret (minimum 32 characters)
openssl rand -base64 32

# Generate encryption key
openssl rand -base64 32

# Generate hash salt
openssl rand -base64 16

# Create database initialization directory
mkdir -p database/init

# Create PostgreSQL initialization script
cat > database/init/01-init.sql << 'EOF'
-- SentinelBERT Database Initialization Script
-- This script creates the initial database schema and indexes

-- Enable required extensions
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pg_trgm";
CREATE EXTENSION IF NOT EXISTS "btree_gin";
CREATE EXTENSION IF NOT EXISTS "postgis";

-- Create main tables
CREATE TABLE IF NOT EXISTS social_posts (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    platform VARCHAR(50) NOT NULL,
    content TEXT NOT NULL,
    author_id_hash VARCHAR(64) NOT NULL,
    author_username VARCHAR(255) NOT NULL,
    author_display_name VARCHAR(255),
    created_at TIMESTAMP WITH TIME ZONE NOT NULL,
    engagement_score DECIMAL(10,4) DEFAULT 0,
    sentiment_score DECIMAL(5,4),
    behavioral_patterns JSONB,
    geographic_data JSONB,
    hashtags TEXT[],
    mentions TEXT[],
    language VARCHAR(10),
    indexed_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- Create indexes for performance
CREATE INDEX IF NOT EXISTS idx_social_posts_platform_created 
    ON social_posts(platform, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_social_posts_author_hash 
    ON social_posts(author_id_hash);
CREATE INDEX IF NOT EXISTS idx_social_posts_sentiment 
    ON social_posts(sentiment_score) WHERE sentiment_score IS NOT NULL;
CREATE INDEX IF NOT EXISTS idx_social_posts_content_gin 
    ON social_posts USING gin(to_tsvector('english', content));
CREATE INDEX IF NOT EXISTS idx_social_posts_hashtags_gin 
    ON social_posts USING gin(hashtags);
CREATE INDEX IF NOT EXISTS idx_social_posts_geographic_gin 
    ON social_posts USING gin(geographic_data);

-- Create user profiles table
CREATE TABLE IF NOT EXISTS user_profiles (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    platform VARCHAR(50) NOT NULL,
    username VARCHAR(255) NOT NULL,
    display_name VARCHAR(255),
    follower_count BIGINT DEFAULT 0,
    following_count BIGINT DEFAULT 0,
    post_count BIGINT DEFAULT 0,
    influence_score DECIMAL(10,4),
    verification_status BOOLEAN DEFAULT FALSE,
    account_created TIMESTAMP WITH TIME ZONE,
    last_updated TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    UNIQUE(platform, username)
);

-- Create indexes for user profiles
CREATE INDEX IF NOT EXISTS idx_user_profiles_influence 
    ON user_profiles(influence_score DESC) WHERE influence_score IS NOT NULL;
CREATE INDEX IF NOT EXISTS idx_user_profiles_followers 
    ON user_profiles(follower_count DESC);

-- Create query history table for audit
CREATE TABLE IF NOT EXISTS query_history (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    user_id VARCHAR(255) NOT NULL,
    query_params JSONB NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    result_count BIGINT,
    execution_time_ms BIGINT,
    ip_address INET,
    user_agent TEXT
);

-- Create index for query history
CREATE INDEX IF NOT EXISTS idx_query_history_user_created 
    ON query_history(user_id, created_at DESC);

-- Create audit log table
CREATE TABLE IF NOT EXISTS audit_logs (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    user_id VARCHAR(255) NOT NULL,
    action VARCHAR(100) NOT NULL,
    resource_type VARCHAR(100),
    resource_id VARCHAR(255),
    timestamp TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    ip_address INET,
    user_agent TEXT,
    request_details JSONB,
    result VARCHAR(20) NOT NULL CHECK (result IN ('SUCCESS', 'FAILURE', 'UNAUTHORIZED'))
);

-- Create index for audit logs
CREATE INDEX IF NOT EXISTS idx_audit_logs_user_timestamp 
    ON audit_logs(user_id, timestamp DESC);
CREATE INDEX IF NOT EXISTS idx_audit_logs_action 
    ON audit_logs(action, timestamp DESC);

-- Create application users table
CREATE TABLE IF NOT EXISTS app_users (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    username VARCHAR(100) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    role VARCHAR(50) NOT NULL DEFAULT 'VIEWER',
    department VARCHAR(100),
    clearance_level INTEGER DEFAULT 1,
    is_active BOOLEAN DEFAULT TRUE,
    last_login TIMESTAMP WITH TIME ZONE,
    failed_login_attempts INTEGER DEFAULT 0,
    account_locked BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- Create index for app users
CREATE INDEX IF NOT EXISTS idx_app_users_username ON app_users(username);
CREATE INDEX IF NOT EXISTS idx_app_users_email ON app_users(email);

-- Insert default admin user (password: admin123 - CHANGE IN PRODUCTION!)
INSERT INTO app_users (username, email, password_hash, role, clearance_level) 
VALUES (
    'admin', 
    'admin@sentinelbert.local', 
    '$2b$12$LQv3c1yqBWVHxkd0LHAkCOYz6TtxMQJqhN8/LewdBPj/RK.PZvO.S', 
    'ADMIN', 
    4
) ON CONFLICT (username) DO NOTHING;

-- Create function to update updated_at timestamp
CREATE OR REPLACE FUNCTION update_updated_at_column()
RETURNS TRIGGER AS $$
BEGIN
    NEW.updated_at = CURRENT_TIMESTAMP;
    RETURN NEW;
END;
$$ language 'plpgsql';

-- Create trigger for app_users table
CREATE TRIGGER update_app_users_updated_at 
    BEFORE UPDATE ON app_users 
    FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

-- Grant permissions
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO sentinel;
GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO sentinel;
EOF

# Create ElasticSearch configuration directory
mkdir -p database/elasticsearch

# Create index template for social posts
cat > database/elasticsearch/social_posts_template.json << 'EOF'
{
  "index_patterns": ["social_posts*"],
  "template": {
    "settings": {
      "number_of_shards": 3,
      "number_of_replicas": 1,
      "analysis": {
        "analyzer": {
          "social_content_analyzer": {
            "type": "custom",
            "tokenizer": "standard",
            "filter": [
              "lowercase",
              "stop",
              "snowball",
              "hashtag_filter",
              "mention_filter"
            ]
          }
        },
        "filter": {
          "hashtag_filter": {
            "type": "pattern_capture",
            "preserve_original": true,
            "patterns": ["#(\\w+)"]
          },
          "mention_filter": {
            "type": "pattern_capture",
            "preserve_original": true,
            "patterns": ["@(\\w+)"]
          }
        }
      }
    },
    "mappings": {
      "properties": {
        "id": {"type": "keyword"},
        "platform": {"type": "keyword"},
        "content": {
          "type": "text",
          "analyzer": "social_content_analyzer",
          "fields": {
            "keyword": {"type": "keyword", "ignore_above": 256}
          }
        },
        "author_id_hash": {"type": "keyword"},
        "author_username": {"type": "keyword"},
        "author_display_name": {"type": "text"},
        "created_at": {"type": "date"},
        "engagement_score": {"type": "float"},
        "sentiment_score": {"type": "float"},
        "behavioral_patterns": {"type": "keyword"},
        "geographic_data": {
          "properties": {
            "location": {"type": "geo_point"},
            "country": {"type": "keyword"},
            "region": {"type": "keyword"},
            "city": {"type": "keyword"}
          }
        },
        "hashtags": {"type": "keyword"},
        "mentions": {"type": "keyword"},
        "language": {"type": "keyword"}
      }
    }
  }
}
EOF

# Make sure you're in the project root directory
cd SentinelBERT

# Build and start all services
docker-compose up -d --build

# Check service status
docker-compose ps

# View logs for all services
docker-compose logs -f

# View logs for specific service
docker-compose logs -f nlp-service

# Wait for services to be ready (may take 2-3 minutes)
sleep 180

# Check PostgreSQL
docker-compose exec postgres pg_isready -U sentinel -d sentinelbert

# Check Redis
docker-compose exec redis redis-cli ping

# Check ElasticSearch
curl -X GET "localhost:9200/_cluster/health?pretty"

# Check NLP Service
curl -X GET "localhost:8000/health"

# Check Backend Service
curl -X GET "localhost:8080/actuator/health"

# Check Frontend
curl -X GET "localhost:3000"

# Create the social posts index template
curl -X PUT "localhost:9200/_index_template/social_posts_template" \
  -H "Content-Type: application/json" \
  -d @database/elasticsearch/social_posts_template.json

# Create the initial index
curl -X PUT "localhost:9200/social_posts" \
  -H "Content-Type: application/json" \
  -d '{
    "settings": {
      "number_of_shards": 3,
      "number_of_replicas": 1
    }
  }'

# Verify index creation
curl -X GET "localhost:9200/_cat/indices?v"

# Test NLP service sentiment analysis
curl -X POST "localhost:8000/analyze" \
  -H "Content-Type: application/json" \
  -d '{
    "texts": ["This is a great day!", "I am feeling sad today."],
    "include_behavioral_analysis": true,
    "include_influence_score": true
  }'

# Test backend search endpoint (requires authentication)
curl -X POST "localhost:8080/api/v1/auth/login" \
  -H "Content-Type: application/json" \
  -d '{
    "username": "admin",
    "password": "admin123"
  }'

# Save the JWT token from the response and use it for authenticated requests
export JWT_TOKEN="your_jwt_token_here"

curl -X POST "localhost:8080/api/v1/search" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $JWT_TOKEN" \
  -d '{
    "keywords": ["climate change"],
    "platforms": ["twitter", "reddit"],
    "dateRange": {
      "start": "2024-01-01T00:00:00Z",
      "end": "2024-12-31T23:59:59Z"
    },
    "regions": ["US", "UK"],
    "limit": 100
  }'

# Connect to PostgreSQL and verify tables
docker-compose exec postgres psql -U sentinel -d sentinelbert -c "\dt"

# Check if sample data exists
docker-compose exec postgres psql -U sentinel -d sentinelbert -c "SELECT COUNT(*) FROM social_posts;"

# Verify user accounts
docker-compose exec postgres psql -U sentinel -d sentinelbert -c "SELECT username, role FROM app_users;"

# Create Grafana dashboards directory
mkdir -p monitoring/grafana/dashboards

# Download pre-built dashboards
curl -o monitoring/grafana/dashboards/sentinelbert-overview.json \
  https://raw.githubusercontent.com/your-org/SentinelBERT/main/monitoring/dashboards/overview.json

curl -o monitoring/grafana/dashboards/sentinelbert-nlp.json \
  https://raw.githubusercontent.com/your-org/SentinelBERT/main/monitoring/dashboards/nlp-service.json

# Restart Grafana to load dashboards
docker-compose restart grafana

# Create alerting rules for Prometheus
cat > monitoring/prometheus/alerts.yml << 'EOF'
groups:
- name: sentinelbert.rules
  rules:
  - alert: ServiceDown
    expr: up == 0
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "Service {{ $labels.instance }} is down"
      description: "{{ $labels.instance }} has been down for more than 1 minute."

  - alert: HighMemoryUsage
    expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes > 0.9
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High memory usage on {{ $labels.instance }}"
      description: "Memory usage is above 90% for more than 5 minutes."

  - alert: HighCPUUsage
    expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High CPU usage on {{ $labels.instance }}"
      description: "CPU usage is above 80% for more than 5 minutes."
EOF

# Restart Prometheus to load alerts
docker-compose restart prometheus

# Update .env file with secure passwords
sed -i 's/your_secure_password_here/$(openssl rand -base64 32)/' .env
sed -i 's/your_redis_password_here/$(openssl rand -base64 32)/' .env
sed -i 's/your_grafana_password_here/$(openssl rand -base64 32)/' .env

# Restart services to apply new passwords
docker-compose down
docker-compose up -d

# Generate SSL certificates (for development only)
mkdir -p nginx/ssl
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout nginx/ssl/sentinelbert.key \
  -out nginx/ssl/sentinelbert.crt \
  -subj "/C=US/ST=State/L=City/O=Organization/CN=localhost"

# Update nginx configuration for HTTPS
cat > nginx/nginx.conf << 'EOF'
events {
    worker_connections 1024;
}

http {
    upstream backend {
        server backend-service:8080;
    }

    upstream frontend {
        server frontend:80;
    }

    server {
        listen 80;
        server_name localhost;
        return 301 https://$server_name$request_uri;
    }

    server {
        listen 443 ssl;
        server_name localhost;

        ssl_certificate /etc/nginx/ssl/sentinelbert.crt;
        ssl_certificate_key /etc/nginx/ssl/sentinelbert.key;

        location /api/ {
            proxy_pass http://backend/;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }

        location / {
            proxy_pass http://frontend/;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }
    }
}
EOF

# Restart nginx
docker-compose restart nginx

# Install and configure UFW firewall
sudo ufw enable
sudo ufw default deny incoming
sudo ufw default allow outgoing

# Allow SSH
sudo ufw allow ssh

# Allow HTTP and HTTPS
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

# Allow specific application ports (for development)
sudo ufw allow 3000/tcp  # Frontend
sudo ufw allow 8080/tcp  # Backend
sudo ufw allow 8000/tcp  # NLP Service
sudo ufw allow 3001/tcp  # Grafana

# Check firewall status
sudo ufw status

# Check Docker daemon status
sudo systemctl status docker

# Check available disk space
df -h

# Check available memory
free -h

# View detailed service logs
docker-compose logs service-name

# Restart specific service
docker-compose restart service-name

# Check PostgreSQL logs
docker-compose logs postgres

# Test database connection
docker-compose exec postgres psql -U sentinel -d sentinelbert -c "SELECT 1;"

# Reset database (WARNING: This will delete all data)
docker-compose down -v
docker-compose up -d postgres
sleep 30
docker-compose up -d

# Verify API keys are set correctly
docker-compose exec ingestion-service env | grep -E "(TWITTER|REDDIT|YOUTUBE)"

# Test API connectivity
curl -H "Authorization: Bearer $TWITTER_BEARER_TOKEN" \
  "https://api.twitter.com/2/tweets/search/recent?query=hello"

# Check memory usage
docker stats

# Increase Docker memory limit (Docker Desktop)
# Go to Docker Desktop -> Settings -> Resources -> Memory

# Reduce service replicas if needed
docker-compose up -d --scale nlp-service=1

# Check which processes are using ports
sudo netstat -tulpn | grep :8080
sudo netstat -tulpn | grep :3000

# Kill processes using required ports
sudo kill -9 $(sudo lsof -t -i:8080)

# Change ports in docker-compose.yml if needed

# View all service logs
docker-compose logs -f

# View logs for specific time range
docker-compose logs --since="2024-01-01T00:00:00" --until="2024-01-01T23:59:59"

# Search logs for errors
docker-compose logs | grep -i error

# Export logs to file
docker-compose logs > sentinelbert-logs.txt

# Monitor resource usage
docker stats --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}\t{{.BlockIO}}"

# Optimize PostgreSQL settings
docker-compose exec postgres psql -U sentinel -d sentinelbert -c "
ALTER SYSTEM SET shared_buffers = '256MB';
ALTER SYSTEM SET effective_cache_size = '1GB';
ALTER SYSTEM SET maintenance_work_mem = '64MB';
SELECT pg_reload_conf();
"

# Clear Redis cache if needed
docker-compose exec redis redis-cli FLUSHALL