Production Stack

version: '3.8'
 
services:
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes
 
  postgres:
    image: postgres:15-alpine
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: remina
      POSTGRES_PASSWORD: remina
      POSTGRES_DB: remina
    volumes:
      - postgres_data:/var/lib/postgresql/data
 
  qdrant:
    image: qdrant/qdrant:latest
    ports:
      - "6333:6333"
      - "6334:6334"
    volumes:
      - qdrant_data:/qdrant/storage
 
volumes:
  redis_data:
  postgres_data:
  qdrant_data:

docker-compose up -d

pip install remina-memory[gemini,postgres,qdrant,redis]

import os
from remina import Memory
 
os.environ["GOOGLE_API_KEY"] = "your-api-key"
 
config = {
    "cache": {
        "redis_url": "redis://localhost:6379",
        "ttl_seconds": 3600,
        "max_memories_per_user": 100,
        "enabled": True,
    },
    "storage": {
        "provider": "postgres",
        "config": {
            "host": "localhost",
            "port": 5432,
            "database": "remina",
            "user": "remina",
            "password": "remina",
            "collection_name": "memories",
            "min_connections": 2,
            "max_connections": 10,
        }
    },
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "url": "http://localhost:6333",
            "collection_name": "remina_memories",
            "embedding_dims": 768,
        }
    },
    "embedder": {
        "provider": "gemini",
        "config": {
            "model": "models/text-embedding-004",
            "dimensions": 768,
        }
    },
    "llm": {
        "provider": "gemini",
        "config": {
            "model": "gemini-2.0-flash",
            "temperature": 0.1,
            "max_tokens": 2000,
        }
    },
    "weight_recency": 0.4,
    "weight_frequency": 0.3,
    "weight_importance": 0.3,
    "dedup_threshold": 0.9,
}
 
memory = Memory(config)

"""
Production stack: Gemini + Qdrant + PostgreSQL + Redis
"""
 
import os
from remina import Memory
 
os.environ["GOOGLE_API_KEY"] = "your-api-key"
 
def main():
    config = {
        "cache": {
            "redis_url": "redis://localhost:6379",
            "ttl_seconds": 3600,
            "enabled": True,
        },
        "storage": {
            "provider": "postgres",
            "config": {
                "host": "localhost",
                "port": 5432,
                "database": "remina",
                "user": "remina",
                "password": "remina",
            }
        },
        "vector_store": {
            "provider": "qdrant",
            "config": {
                "url": "http://localhost:6333",
                "collection_name": "remina_memories",
                "embedding_dims": 768,
            }
        },
        "embedder": {
            "provider": "gemini",
            "config": {
                "model": "models/text-embedding-004",
                "dimensions": 768,
            }
        },
        "llm": {
            "provider": "gemini",
            "config": {
                "model": "gemini-2.0-flash",
                "temperature": 0.1,
            }
        },
    }
    
    print("Initializing production stack...")
    memory = Memory(config)
    
    user_id = "prod_user_001"
    
    memory.delete_all(user_id=user_id)
    
    # Add from text
    print("\nAdding memories from text...")
    result = memory.add(
        messages="I'm Sarah, a data scientist at Google. I specialize in NLP.",
        user_id=user_id,
    )
    print(f"Extracted {len(result['results'])} memories")
    
    # Add from conversation
    print("Adding memories from conversation...")
    result = memory.add(
        messages=[
            {"role": "user", "content": "I prefer PyTorch over TensorFlow"},
            {"role": "assistant", "content": "PyTorch is excellent for research."},
            {"role": "user", "content": "I use Jupyter notebooks daily"},
        ],
        user_id=user_id,
    )
    print(f"Extracted {len(result['results'])} memories")
    
    # Search
    print("\nSearch: 'ML frameworks'")
    results = memory.search(
        query="What ML frameworks does the user prefer?",
        user_id=user_id,
        limit=5,
    )
    for mem in results["results"]:
        print(f"  [{mem['score']:.3f}] {mem['memory']}")
    
    # List all
    print("\nAll memories:")
    all_memories = memory.get_all(user_id=user_id)
    for i, mem in enumerate(all_memories["results"], 1):
        print(f"  {i}. {mem['memory']}")
    
    memory.close()
    print("\nComplete.")
 
if __name__ == "__main__":
    main()

config = {
    "cache": {
        "redis_url": "redis://your-redis-host:6379",
        "enabled": True,
    },
    "storage": {
        "provider": "postgres",
        "config": {
            "host": "your-postgres-host",
            "port": 5432,
            "database": "remina",
            "user": "postgres",
            "password": "your-password",
        }
    },
    "vector_store": {
        "provider": "pinecone",
        "config": {
            "api_key": os.environ["PINECONE_API_KEY"],
            "index_name": "remina-prod",
            "namespace": "production",
            "embedding_dims": 1536,
            "cloud": "aws",
            "region": "us-east-1",
        }
    },
    "embedder": {
        "provider": "openai",
        "config": {
            "model": "text-embedding-3-small",
            "dimensions": 1536,
        }
    },
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4o-mini",
            "temperature": 0.1,
        }
    },
}

def check_health(memory: Memory) -> dict:
    health = {"status": "healthy", "services": {}}
    
    try:
        memory.get_all(user_id="health_check", limit=1)
        health["services"]["storage"] = "ok"
    except Exception as e:
        health["services"]["storage"] = f"error: {e}"
        health["status"] = "unhealthy"
    
    try:
        memory.search(query="test", user_id="health_check", limit=1)
        health["services"]["vector_store"] = "ok"
        health["services"]["embeddings"] = "ok"
    except Exception as e:
        health["services"]["vector_store"] = f"error: {e}"
        health["status"] = "unhealthy"
    
    return health