# Compressão de contexto quando próximo do limite
def compress_context(messages: list[Message], max_tokens: int = 80_000) -> list[Message]:
    if count_tokens(messages) < max_tokens * 0.8:
        return messages  # Ainda tem espaço

    # Preserva system prompt + últimas N mensagens
    system = [m for m in messages if m.role == "system"]
    recent = messages[-10:]  # Últimas 10 mensagens sempre inteiras

    # Comprime o meio
    middle = messages[len(system):-10]
    summary = llm.summarize(middle, instruction="Resumo conciso das decisões e contexto relevante")

    return system + [Message(role="system", content=f"[Histórico resumido]: {summary}")] + recent

from mem0 import Memory

memory = Memory()

# Após uma sessão com o usuário
memory.add(
    messages=conversa_da_sessao,
    user_id="elton",
    metadata={"session_date": "2026-04-06", "project": "ecommerce-api"}
)

# Na próxima sessão, recuperar memórias relevantes
def get_relevant_memories(user_id: str, query: str) -> str:
    memories = memory.search(query=query, user_id=user_id, limit=5)
    if not memories["results"]:
        return ""
    return "\n".join([f"- {m['memory']}" for m in memories["results"]])

# Injeta no system prompt
relevant = get_relevant_memories("elton", "autenticação JWT")
system_prompt = f"""Você é o assistente de Elton.
{f'Memórias relevantes:\n{relevant}' if relevant else ''}
"""

from zep_cloud.client import AsyncZep

client = AsyncZep(api_key="...")

# Zep extrai automaticamente fatos das mensagens
await client.memory.add(
    session_id="session-123",
    messages=[
        {"role": "user", "content": "Prefiro usar TypeScript no frontend"},
        {"role": "assistant", "content": "Anotado, vou usar TypeScript nos exemplos"}
    ]
)

# Fatos extraídos automaticamente por Zep:
# - usuário: prefere TypeScript para frontend
# - usuário: trabalha com projetos que têm frontend

-- Habilitando a extensão
CREATE EXTENSION IF NOT EXISTS vector;

-- Tabela de conhecimento com embeddings
CREATE TABLE knowledge_base (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    content TEXT NOT NULL,
    embedding vector(1536),  -- dimensão do text-embedding-3-small
    source TEXT,
    metadata JSONB,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Índice para busca por similaridade
CREATE INDEX ON knowledge_base
USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100);

import openai
import psycopg2
import json

def index_document(content: str, source: str, metadata: dict):
    embedding = openai.embeddings.create(
        input=content,
        model="text-embedding-3-small"
    ).data[0].embedding

    conn = psycopg2.connect(DATABASE_URL)
    with conn.cursor() as cur:
        cur.execute(
            "INSERT INTO knowledge_base (content, embedding, source, metadata) VALUES (%s, %s, %s, %s)",
            (content, json.dumps(embedding), source, json.dumps(metadata))
        )
    conn.commit()

def semantic_search(query: str, limit: int = 5) -> list[dict]:
    query_embedding = openai.embeddings.create(
        input=query,
        model="text-embedding-3-small"
    ).data[0].embedding

    conn = psycopg2.connect(DATABASE_URL)
    with conn.cursor() as cur:
        cur.execute("""
            SELECT content, source, metadata,
                   1 - (embedding <=> %s::vector) as similarity
            FROM knowledge_base
            ORDER BY embedding <=> %s::vector
            LIMIT %s
        """, (json.dumps(query_embedding), json.dumps(query_embedding), limit))
        return [
            {"content": row[0], "source": row[1], "metadata": row[2], "similarity": row[3]}
            for row in cur.fetchall()
        ]

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

client = QdrantClient(url="http://localhost:6333")

# Busca híbrida: semântica + filtro por metadata
results = client.search(
    collection_name="codebase",
    query_vector=query_embedding,
    query_filter={
        "must": [
            {"key": "language", "match": {"value": "typescript"}},
            {"key": "module", "match": {"value": "auth"}}
        ]
    },
    limit=10
)

# Spec: Análise de Pull Request

## Objetivo
Revisar um PR e fornecer feedback estruturado.

## Inputs
- URL ou número do PR
- Contexto do projeto (linguagem, padrões de código, área de negócio)

## Processo
1. Buscar diff completo do PR
2. Identificar mudanças por categoria: lógica, estilo, testes, docs
3. Para cada mudança de lógica: verificar edge cases, error handling, performance
4. Para cada mudança de estilo: verificar aderência ao guia de estilo do projeto
5. Gerar comentários contextuais por linha quando relevante

## Output
- Resumo executivo (máximo 3 parágrafos)
- Lista de issues críticos (bloqueantes para merge)
- Lista de sugestões (não-bloqueantes)
- Score de qualidade (1-10) com justificativa

## Regras
- Nunca aprovar PR sem cobertura de testes para lógica nova
- Sempre mencionar impacto de performance para mudanças em hot paths
- Usar linguagem construtiva, não prescritiva

def build_pr_review_agent_prompt(spec: str, project_context: str) -> str:
    return f"""Você é um agente de revisão de código especializado.

## Procedimento de Revisão
{spec}

## Contexto do Projeto
{project_context}

Execute a revisão seguindo o procedimento acima rigorosamente.
"""

class MemoryRouter:
    def __init__(self):
        self.mem0 = Memory()          # Episodic
        self.qdrant = QdrantClient()  # Semantic
        self.specs = SpecLoader()     # Procedural

    async def get_context(self, query: str, user_id: str, task_type: str) -> str:
        # Consulta todas as camadas em paralelo
        episodic, semantic, procedural = await asyncio.gather(
            self.get_episodic(query, user_id),
            self.get_semantic(query),
            self.get_procedural(task_type)
        )

        context_parts = []
        if episodic:
            context_parts.append(f"## Histórico Relevante\n{episodic}")
        if semantic:
            context_parts.append(f"## Conhecimento do Domínio\n{semantic}")
        if procedural:
            context_parts.append(f"## Como Executar Esta Tarefa\n{procedural}")

        return "\n\n".join(context_parts)

    async def get_episodic(self, query: str, user_id: str) -> str:
        results = self.mem0.search(query=query, user_id=user_id, limit=3)
        return "\n".join([f"- {r['memory']}" for r in results["results"]])

    async def get_semantic(self, query: str) -> str:
        results = self.qdrant.search(
            collection_name="knowledge_base",
            query_vector=embed(query),
            limit=5
        )
        return "\n\n".join([r.payload["content"] for r in results])

    async def get_procedural(self, task_type: str) -> str:
        return self.specs.load(task_type)  # Carrega spec do filesystem/DB

# Uso no agente
router = MemoryRouter()

async def run_agent(user_message: str, user_id: str, task_type: str):
    # 1. Recupera contexto das 3 camadas externas
    memory_context = await router.get_context(
        query=user_message,
        user_id=user_id,
        task_type=task_type
    )

    # 2. Constrói prompt com Working Memory + contexto recuperado
    messages = build_messages(
        system=f"Você é um assistente especializado.\n\n{memory_context}",
        history=get_compressed_history(user_id),  # Working Memory
        user_message=user_message
    )

    # 3. Executa o agente
    response = await llm.complete(messages)

    # 4. Salva a sessão na Episodic Memory
    await router.mem0.add(
        messages=[{"role": "user", "content": user_message},
                  {"role": "assistant", "content": response}],
        user_id=user_id
    )

    return response

from langmem import create_memory_manager
from langgraph.graph import StateGraph

# Cria gerenciador de memória
memory_manager = create_memory_manager(
    episodic_store="mem0",       # Backend para memória episódica
    semantic_store="pgvector",    # Backend para memória semântica
    auto_extract=True             # Extrai automaticamente fatos de conversas
)

# Integra no grafo LangGraph
graph = StateGraph(AgentState)
graph.add_node("memory_load", memory_manager.load_node)
graph.add_node("agent", agent_node)
graph.add_node("memory_save", memory_manager.save_node)

graph.set_entry_point("memory_load")
graph.add_edge("memory_load", "agent")
graph.add_edge("agent", "memory_save")