Deployment

Production deployment guide for Remina.

Infrastructure Requirements

Minimum

Component	Requirement
Python	3.10+
Redis	6.0+
Storage	SQLite/PostgreSQL/MongoDB
Vector Store	Chroma/Qdrant/Pinecone

Recommended Production Stack

Component	Recommendation
L1 Cache	Redis Cluster or AWS ElastiCache
L2 Storage	PostgreSQL with connection pooling
Vector Store	Qdrant (self-hosted) or Pinecone (managed)
Embeddings	OpenAI or Gemini
LLM	OpenAI GPT-4o-mini or Gemini Flash

Docker Deployment

docker-compose.yml

 
services:
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes
    restart: unless-stopped
 
  postgres:
    image: postgres:15-alpine
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: remina
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: remina
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
 
  qdrant:
    image: qdrant/qdrant:latest
    ports:
      - "6333:6333"
    volumes:
      - qdrant_data:/qdrant/storage
    restart: unless-stopped
 
  app:
    build: .
    ports:
      - "8000:8000"
    environment:
      - GOOGLE_API_KEY=${GOOGLE_API_KEY}
      - REDIS_URL=redis://redis:6379
      - POSTGRES_HOST=postgres
      - QDRANT_URL=http://qdrant:6333
    depends_on:
      - redis
      - postgres
      - qdrant
    restart: unless-stopped
 
volumes:
  redis_data:
  postgres_data:
  qdrant_data:

Dockerfile

FROM python:3.11-slim
 
WORKDIR /app
 
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
COPY . .
 
CMD ["python", "main.py"]

Kubernetes Deployment

ConfigMap

apiVersion: v1
kind: ConfigMap
metadata:
  name: remina-config
data:
  REDIS_URL: "redis://redis-service:6379"
  POSTGRES_HOST: "postgres-service"
  POSTGRES_PORT: "5432"
  POSTGRES_DB: "remina"
  QDRANT_URL: "http://qdrant-service:6333"

Secret

apiVersion: v1
kind: Secret
metadata:
  name: remina-secrets
type: Opaque
stringData:
  GOOGLE_API_KEY: "your-api-key"
  POSTGRES_USER: "remina"
  POSTGRES_PASSWORD: "your-password"

Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: remina-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: remina
  template:
    metadata:
      labels:
        app: remina
    spec:
      containers:
      - name: remina
        image: your-registry/remina:latest
        ports:
        - containerPort: 8000
        envFrom:
        - configMapRef:
            name: remina-config
        - secretRef:
            name: remina-secrets
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

Cloud Deployments

AWS

Recommended Services:

ElastiCache for Redis
RDS for PostgreSQL
Pinecone or self-hosted Qdrant on EKS
Lambda or ECS for application

Configuration:

config = {
    "cache": {
        "redis_url": "redis://your-elasticache-endpoint:6379",
        "enabled": True,
    },
    "storage": {
        "provider": "postgres",
        "config": {
            "host": "your-rds-endpoint.amazonaws.com",
            "port": 5432,
            "database": "remina",
            "user": "remina",
            "password": os.environ["DB_PASSWORD"],
            "min_connections": 5,
            "max_connections": 20,
        }
    },
    "vector_store": {
        "provider": "pinecone",
        "config": {
            "api_key": os.environ["PINECONE_API_KEY"],
            "index_name": "remina-prod",
            "cloud": "aws",
            "region": "us-east-1",
        }
    },
}

GCP

Recommended Services:

Memorystore for Redis
Cloud SQL for PostgreSQL
Vertex AI Vector Search or self-hosted Qdrant on GKE
Cloud Run or GKE for application

Azure

Recommended Services:

Azure Cache for Redis
Azure Database for PostgreSQL
Azure Cognitive Search or self-hosted Qdrant on AKS
Azure Container Apps or AKS for application

Environment Variables

# API Keys
GOOGLE_API_KEY=your-google-api-key
OPENAI_API_KEY=your-openai-api-key
 
# Database
POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_DB=remina
POSTGRES_USER=remina
POSTGRES_PASSWORD=your-password
 
# Redis
REDIS_URL=redis://localhost:6379
 
# Vector Store
QDRANT_URL=http://localhost:6333
PINECONE_API_KEY=your-pinecone-key

Scaling

Horizontal Scaling

Remina is stateless and supports horizontal scaling:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: remina-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: remina-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Connection Pooling

Configure appropriate connection pools:

"storage": {
    "provider": "postgres",
    "config": {
        "min_connections": 5,
        "max_connections": 20,
    }
}

Monitoring

Health Check

from fastapi import FastAPI
from remina import Memory
 
app = FastAPI()
memory = Memory(config)
 
@app.get("/health")
async def health():
    try:
        memory.get_all(user_id="health_check", limit=1)
        return {"status": "healthy"}
    except Exception as e:
        return {"status": "unhealthy", "error": str(e)}

Logging

import logging
 
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

Security

API Keys: Store in secrets manager (AWS Secrets Manager, HashiCorp Vault)
Database: Use SSL connections, rotate credentials
Redis: Enable AUTH, use TLS
Network: Use private subnets, security groups
Application: Rate limiting, input validation

# SSL for PostgreSQL
"storage": {
    "provider": "postgres",
    "config": {
        "host": "your-host",
        "ssl": "require",
    }
}

Gradio Demo Contributing