Skip to content

🎯 Plano: MemoryService Customizado (Independente do Google Vertex AI)

📋 Resumo Executivo

Migrar de Google Vertex AI Memory Bank para uma solução self-hosted, open-source inspirada em OpenMemory, eliminando dependência de infraestrutura Google e economizando custos.

Benefícios

  • ✅ Independência: Controle total, sem vendor lock-in
  • ✅ Custo: 6-12x mais barato (OpenMemory custa $8-12/mês vs Vertex AI ~$100+/mês)
  • ✅ Transparência: Código aberto, sabe o que está acontecendo
  • ✅ Privacidade: Dados 100% seus, não enviados para Google
  • ✅ Performance: 2-3x mais rápido (115ms vs 250ms por query)
  • ✅ Flexibilidade: Use embeddings locais ou cloud

🏗️ Arquitetura Proposta

┌─────────────────────────────────────────────────────────────┐
│ Seu App (ifriend-agents)                                    │
│                                                             │
│  ┌─────────────────────────────────────────────────────┐  │
│  │ slack_bot.py / ifriend_agent                        │  │
│  │ ↓ Chama CustomMemoryService                         │  │
│  └─────────────────────────────────────────────────────┘  │
│           ↓                                                 │
│  ┌─────────────────────────────────────────────────────┐  │
│  │ CustomMemoryService (Python)                        │  │
│  │ ├─ add_session_to_memory()                          │  │
│  │ ├─ search_memory()                                  │  │
│  │ ├─ reinforce_memory()                               │  │
│  │ └─ delete_memory()                                  │  │
│  └─────────────────────────────────────────────────────┘  │
│           ↓                                                 │
└─────────────────┬───────────────────────────────────────────┘
                  │
        ┌─────────▼──────────────────────────────────────┐
        │ Memory Backend (escolha uma):                  │
        │                                               │
        │ Opção 1: PostgreSQL + Pgvector              │
        │ ├─ SQL para metadata + relações             │
        │ ├─ pgvector ext para embeddings              │
        │ ├─ Escalável, confiável, barato             │
        │ └─ Recomendado para produção ✅              │
        │                                               │
        │ Opção 2: SQLite (desenvolvimento)            │
        │ ├─ Zero setup, local                         │
        │ ├─ Sqlite-vss para busca vetorial           │
        │ └─ Perfeito para prototipar                 │
        │                                               │
        │ Opção 3: Redis Stack                         │
        │ ├─ In-memory, super rápido                   │
        │ ├─ Até 1M embeddings no Redis               │
        │ └─ Cache + persistência                      │
        └─────────────────────────────────────────────────┘
                  │
        ┌─────────▼──────────────────────────────────────┐
        │ Embedding Service (escolha uma):             │
        │                                               │
        │ Opção 1: Local Ollama                        │
        │ ├─ 100% offline                              │
        │ ├─ Modelos: nomic-embed-text, BAAI/BGE      │
        │ └─ Custo: $0                                 │
        │                                               │
        │ Opção 2: Google Gemini (mantém custo baixo) │
        │ ├─ Qualidade superior                        │
        │ ├─ Custo: ~$0.02/1M tokens                   │
        │ └─ Já temos API key                          │
        │                                               │
        │ Opção 3: OpenAI                              │
        │ ├─ Melhor qualidade                          │
        │ ├─ Custo: ~$0.02/1K embeddings              │
        │ └─ Mais caro                                 │
        └─────────────────────────────────────────────────┘

📅 Fases de Implementação

Fase 1: Setup Básico (Semana 1)

Objetivo: Ter MemoryService funcional em dev

  • [ ] Estrutura de código 

    ifriend_agent/memory/
├─ __init__.py
├─ custom_memory_service.py     # Implementação principal
├─ backends/
│  ├─ base.py                   # Interface abstrata
│  ├─ postgresql.py             # Backend PostgreSQL
│  ├─ sqlite.py                 # Backend SQLite
│  └─ redis_backend.py          # Backend Redis (futuro)
├─ embeddings/
│  ├─ base.py                   # Interface
│  ├─ ollama_embeddings.py      # Local Ollama
│  ├─ gemini_embeddings.py      # Google Gemini
│  └─ openai_embeddings.py      # OpenAI (futuro)
└─ models.py                    # Schemas/DataClasses

  • [ ] Interface base (Passo 1) 

    class BaseMemoryBackend:
    async def add_memory(self, memory: MemoryItem) -> str: ...
    async def search(self, embedding: List[float], k: int) -> List[MemoryItem]: ...
    async def get(self, memory_id: str) -> MemoryItem: ...
    async def update(self, memory_id: str, **kwargs) -> None: ...
    async def delete(self, memory_id: str) -> None: ...
    async def reinforce(self, memory_id: str) -> None: ...

  • [ ] CustomMemoryService compatível com ADK 

    class CustomMemoryService(BaseMemoryService):
    async def add_session_to_memory(self, session: Session) -> None: ...
    async def search_memory(self, app_name, user_id, query) -> SearchMemoryResponse: ...

  • [ ] SQLite + sqlite-vss (desenvolvimento)

  • Setup rápido, zero dependências externas
  • Perfeito para prototipar

Fase 2: Integração (Semana 2)

Objetivo: Integrar no agente, testar ponta-a-ponta

  • [ ] Atualizar slack_bot.py 

    from ifriend_agent.memory.custom_memory_service import CustomMemoryService

memory_service = CustomMemoryService(
    backend_type="sqlite",  # ou "postgresql"
    embedding_model="ollama"  # ou "gemini"
)

  • [ ] Atualizar agent.py

  • Passar memory_service ao Runner

  • Configurar callbacks para salvar memória

  • [ ] Testes

  • Unit tests do backend
  • Integration tests com Agent
  • Performance tests

Fase 3: PostgreSQL (Semana 3)

Objetivo: Produção-ready com PostgreSQL

  • [ ] Preparar PostgreSQL com pgvector 

    CREATE EXTENSION vector;
CREATE TABLE memories (
  id UUID PRIMARY KEY,
  user_id TEXT,
  content TEXT,
  embedding VECTOR(384),  -- Tamanho do embedding
  sector TEXT,  -- semantic, episodic, etc
  salience FLOAT,
  recency TIMESTAMP,
  created_at TIMESTAMP,
  updated_at TIMESTAMP
);
CREATE INDEX ON memories USING ivfflat (embedding vector_cosine_ops);

  • [ ] Implementar PostgreSQL backend

  • Conexão pooling (asyncpg)
  • Query com pgvector

  • Índices otimizados

  • [ ] Migration do SQLite → PostgreSQL

  • Script de export/import
  • Validação de dados

Fase 4: Otimizações (Semana 4+)

Objetivo: Performance e features

  • [ ] Memory decay (inspirado em OpenMemory) 

    importance = 0.6×similarity + 0.2×salience + 0.1×recency + 0.1×link_weight

  • [ ] Multi-sector memories

  • Semantic, Episodic, Procedural, Emotional, Reflective

  • Embeddings diferentes por setor

  • [ ] Temporal knowledge graph

  • Quando fatos são verdadeiros
  • Histórico de mudanças

  • Queries por data

  • [ ] Dashboard web (opcional)

  • Visualizar memórias
  • Teste de queries
  • Analytics

🛠️ Stack Técnico Recomendado

Desenvolvimento

Backend: Python (async)
├─ asyncio, aiohttp
├─ sqlalchemy (SQLite/PostgreSQL)
└─ pydantic (validation)

Embeddings: Local
├─ Ollama (zero cost)
└─ Modelos: nomic-embed-text, BGE

Database: SQLite (dev) + sqlite-vss
└─ Zero dependencies

Produção

Opção A: Supabase (RECOMENDADO) ⭐

Database: Supabase PostgreSQL + pgvector
├─ ✅ PostgreSQL managed + pgvector built-in
├─ ✅ Pricing: $25/mês (Pro) ou $15/mês (Free com limites)
├─ ✅ Real-time subscriptions (bônus)
├─ ✅ Edge Functions (bônus)
├─ ✅ Authentication (bônus)
├─ ✅ Dashboard excelente
├─ ✅ Suporte ótimo
└─ ❌ Vendor lock-in Supabase (mas menos que Google)

Embeddings: Gemini (custo-benefício)
├─ $0.02/1M tokens
└─ Qualidade boa

Total: ~$30-40/mês

Opção B: PostgreSQL Managed (DigitalOcean/Railway)

Database: PostgreSQL managed
├─ $12-20/mês (DB only)
├─ Você cria os índices pgvector
└─ Mais controle

Embeddings: Gemini
├─ $0.02/1M tokens
└─ Qualidade boa

Total: ~$25-30/mês

Opção C: Self-hosted PostgreSQL (VPS)

Database: PostgreSQL em VPS
├─ $5-10/mês (VPS)
├─ Você gerencia backups
└─ Risco maior

Embeddings: Gemini
├─ $0.02/1M tokens
└─ Qualidade boa

Total: ~$15-20/mês (mais trabalho)

Recomendação: Supabase (Opção A) por simplicidade + pgvector built-in

💾 Modelos de Dados

MemoryItem

@dataclass
class MemoryItem:
    id: str  # UUID
    user_id: str
    session_id: str
    content: str
    embedding: List[float]
    sector: str  # "semantic", "episodic", etc
    importance: float  # 0-1, baseado em salience+recency
    salience: float  # How important/relevant
    recency: datetime  # Last accessed
    tags: List[str]
    created_at: datetime
    updated_at: datetime
    metadata: dict  # Flex field

SearchResult

@dataclass
class SearchResult:
    memory_id: str
    user_id: str
    content: str
    similarity: float  # 0-1
    importance: float
    waypoints: List[str]  # Related memories
    explanation: str  # Why this matched

📊 Estimativas de Custo

Desenvolvimento (SQLite local)

  • Custo: $0/mês
  • Storage: PC local
  • Embeddings: Ollama (gratuito)

Pequena Escala (10k memórias)

  • PostgreSQL managed: $12-15/mês
  • Embeddings (Gemini): ~$0.10/mês
  • Total: ~$15/mês

Média Escala (100k memórias)

  • PostgreSQL managed: $20-30/mês
  • Embeddings (Gemini): ~$1/mês
  • Total: ~$31/mês

Comparação com Vertex AI Memory Bank

  • Vertex AI: ~$100-300/mês (dependendo uso)
  • Nossa solução: ~$30-50/mês
  • Economia: 70-85%

🐳 Ollama em Google Cloud: Cloud Run vs Self-Hosted

Pergunta: "Posso rodar Ollama em Cloud Run do Google?"

Resposta Curta: Sim, mas não é ideal. Cloud Run é stateless e reinicia containers frequentemente.

Análise Detalhada

❌ Cloud Run (Não Recomendado)

Problema 1: Statelessness
├─ Cloud Run mata containers após ~15min inativo
├─ Ollama precisa de estado (cache de modelos)
└─ Cada reinicialização = reload dos modelos (LENTO)

Problema 2: Storage
├─ /tmp é efêmero (perdido ao reiniciar)
├─ Modelos Ollama = 2-5GB cada
├─ Precisa de persistent storage (GCS + mounting)
└─ Overhead de I/O

Problema 3: Cold Start
├─ Primeiro request = carregar modelo (30-60s!)
└─ Users não vão esperar

Problema 4: Custo
├─ vCPU: $0.00002400 por vCPU-segundo
├─ Memory: $0.00000250 por GB-segundo
└─ Se usar GPU: MUITO caro ($2+ por hora)

✅ Alternativas MELHORES

Opção Custo/mês Setup Performance Recomendação
Cloud Run GPU $100-300 Fácil 5x mais rápido ⚠️ Caro
Compute Engine (e2-medium) $20-30 Médio ✅ Bom ⭐ Recomendado
GKE com GPU Node $50-150 Complexo ⭐ Excelente Para escala
Ollama Cloud (oficial) $5-15/mês Super fácil ✅ Bom ✅ Melhor opção
Local Ollama (dev) $0 Trivial N/A Desenvolvimento

🏆 Solução Recomendada: Compute Engine (e2-medium)

VM: Compute Engine e2-medium (2 vCPU, 4GB RAM)
├─ Custo: ~$20-25/mês
├─ Ollama roda 24/7 sem problemas
├─ Modelos em SSD permanente
├─ Performance: 115ms queries
└─ Setup: 15 minutos

Docker Compose:
  ollama:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ./ollama:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0:11434

Modelos:
  - nomic-embed-text (274MB) → embeddings
  - mistral (4GB) → fallback reasoning

2️⃣ Alternativa: Ollama Cloud (Oficial)

Ollama lançou Ollama Cloud (API managed): 

Vantagens:
├─ ✅ Zero infrastructure
├─ ✅ API HTTP (como OpenAI)
├─ ✅ Custo: $5-15/mês
├─ ✅ Performance garantida
└─ ✅ Escalável automaticamente

API:
POST https://api.ollama.cloud/v1/embeddings
{
  "model": "nomic-embed-text",
  "input": "seu texto aqui"
}

Custo: 
├─ Embedding: $0.00002/1K tokens
└─ Inference: $0.001/1K tokens

🎯 Arquitetura Recomendada (Híbrida)

┌─────────────────────────────────────┐
│ ifriend-agents (Cloud Run)          │
│ ├─ slack_bot.py                     │
│ └─ CustomMemoryService              │
└────────────────┬────────────────────┘
                 │
    ┌────────────┴──────────────┐
    ▼                           ▼
┌──────────────────┐  ┌──────────────────────┐
│ Embeddings:      │  │ Database:            │
│                  │  │                      │
│ Ollama Cloud ✅   │  │ Supabase PostgreSQL  │
│ (ou Compute E.)  │  │ + pgvector ✅         │
│                  │  │                      │
│ $5-15/mês        │  │ $25/mês              │
│ API HTTP         │  │ Managed + Edge Fns   │
└──────────────────┘  └──────────────────────┘

Total: ~$35-45/mês (vs $100-300 Vertex AI)

📋 Setup Passo-a-Passo (Compute Engine)

# 1. Criar VM no Google Cloud
gcloud compute instances create ollama-vm \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --machine-type=e2-medium \
  --zone=us-central1-a

# 2. SSH na VM
gcloud compute ssh ollama-vm --zone=us-central1-a

# 3. Instalar Docker
sudo apt update && sudo apt install -y docker.io
sudo usermod -aG docker $USER

# 4. Rodar Ollama
docker run -d \
  --name ollama \
  -p 11434:11434 \
  -v ollama:/root/.ollama \
  ollama/ollama

# 5. Puxar modelo
docker exec ollama ollama pull nomic-embed-text

# 6. Testar
curl http://localhost:11434/api/embeddings \
  -X POST \
  -d '{"model":"nomic-embed-text","input":"hello"}'

🔗 Conexão do CustomMemoryService

# CustomMemoryService com Ollama Compute Engine
class CustomMemoryService(BaseMemoryService):
    def __init__(self, ollama_url="http://COMPUTE_ENGINE_IP:11434"):
        self.ollama_url = ollama_url
        self.db = supabase_client()

    async def embed_text(self, text: str) -> List[float]:
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.ollama_url}/api/embeddings",
                json={"model": "nomic-embed-text", "input": text}
            ) as resp:
                data = await resp.json()
                return data["embedding"]

    async def search_memory(self, app_name, user_id, query):
        # Embed query
        query_embedding = await self.embed_text(query)

        # Search Supabase
        results = self.db.rpc(
            "match_memories",
            {
                "query_embedding": query_embedding,
                "user_id": user_id,
                "k": 5
            }
        )

        return SearchMemoryResponse(memories=results)

📊 Comparação de Custos (Completo)

Componente Vertex AI Ollama Cloud Compute E.
Database Firestore $50 Supabase $25 Supabase $25
Embeddings ~$50 ~$10 $0 (local)
Inference ~$50 Incl. $0 (local)
Infrastructure Incluso - $25
Total/mês $150+ $35 $50
Economia - 77% 67%

Recomendação Final: 1. Desenvolvimento: Ollama local + SQLite ($0) 2. MVP: Ollama Cloud + Supabase ($35/mês) 3. Escala: Compute Engine + Supabase ($50/mês)

# 1. Criar estrutura
mkdir -p ifriend_agent/memory/{backends,embeddings}

# 2. Instalar dependências
pip install sqlalchemy aiosqlite pydantic asyncio
pip install sqlite-vec  # Para busca vetorial

# 3. Criar CustomMemoryService (Fase 1)
# - Interface base
# - SQLite backend
# - Ollama embeddings (ou Gemini)

# 4. Testar
pytest ifriend_agent/memory/tests/

# 5. Integrar em slack_bot.py
# - Trocar MemoryService
# - Configurar backend/embeddings
# - Deploy

⚠️ Considerações

Migrando de FirestoreSessionService

Firestore (atual):
├─ Armazena: Sessões + histórico
├─ Problema: Não é otimizado para busca
└─ Benefício: Já tem dados lá

Novo CustomMemoryService:
├─ Propósito: Histórico semântico explorado
├─ Storage: PostgreSQL + embeddings
└─ Benefício: Busca rápida por similaridade

Ambos coexistem? SIM! - SessionService: Mantém histórico de thread (como está) - MemoryService: Permite buscar em conversas antigas - Melhor: Usar ambos para máxima capacidade

Segurança

  • ✅ Dados locais (você controla)
  • ✅ Sem API calls desnecessárias
  • ✅ PII scrubbing (opcional)
  • ✅ Per-user isolation (já temos user_id)

Performance

  • Query: 115ms (vs 250ms+ cloud)
  • Throughput: 338 QPS (vs 180 competitors)
  • Storage: 7.9ms/item para 10k+

📝 Próximos Passos

  1. Semana 1
  2. [ ] Criar estrutura de código
  3. [ ] Implementar SQLite backend

  4. [ ] Testar com Ollama local

  5. Semana 2

  6. [ ] Integrar em slack_bot.py
  7. [ ] Testar ponta-a-ponta

  8. [ ] Performance benchmarks

  9. Semana 3

  10. [ ] PostgreSQL + pgvector
  11. [ ] Migration script

  12. [ ] Deploy em staging

  13. Semana 4+

  14. [ ] Dashboard (opcional)
  15. [ ] Multi-sector memories
  16. [ ] Temporal knowledge graph

🔗 Referências

  • OpenMemory: https://github.com/CaviraOSS/OpenMemory
  • pgvector: https://github.com/pgvector/pgvector
  • sqlite-vec: https://github.com/asg017/sqlite-vec
  • Ollama: https://ollama.com

✅ Checklist de Decisão

Antes de começar, decida:

  • [ ] Backend primário? PostgreSQL (recomendado) ou SQLite (dev)
  • [ ] Embeddings? Ollama (offline) ou Gemini (qualidade)
  • [ ] Deploy? Cloud managed (Render/Railway) ou self-hosted (VPS)
  • [ ] Timeline? Imediato (Fase 1+2) ou estendido (Fase 4)
  • [ ] Tim? Quem vai implementar?