grkmemory 1.16.0

GRKMemory (Graph Retrieve Knowledge Memory) - A semantic graph-based memory system for AI agents developed by MonkAI team

🧠 GRKMemory - Graph Retrieve Knowledge Memory

GRKMemory = Graph Retrieve Knowledge Memory

GRKMemory é um sistema de memória semântica baseado em grafos para agentes de IA, desenvolvido pelo time MonkAI. Recuperação inteligente de conhecimento com grande economia de tokens (~95% em nossos benchmarks internos — veja Performance).

🚀 Começando

1️⃣ Instalação

pip install grkmemory        # sempre em um venv (ou via pipx)

Requer Python 3.10–3.13 (distribuímos apenas wheels compilados, sem sdist).

Instalando no Python do sistema (Debian/Ubuntu, devcontainers de IDE)? Prefira um venv ou pipx install --python python3.12 grkmemory — o site-packages do sistema não entra no caminho e nada conflita. Se precisar instalar direto no sistema e o pip falhar com "Cannot uninstall PyJWT... no RECORD" (o extra [mcp] puxa pyjwt>=2.10.1 via SDK MCP, e o PyJWT do apt não pode ser removido pelo pip), use: pip install --ignore-installed PyJWT "grkmemory[mcp]".

2️⃣ Token de acesso (opcional — só para o gate de autenticação)

O uso direto da biblioteca (GRKMemory, MemoryRepository, servidor MCP, plugin Claude Code) não exige token. O token MonkAI só é necessário se você quiser a camada opcional de controle de acesso (GRKAuth/AuthenticatedGRK) — útil quando vários times/serviços compartilham o mesmo store:

📧 Contato: [e-mail]
🌐 Site: www.monkai.com.br

3️⃣ Configurar Token

# Configurar como variável de ambiente
export GRKMEMORY_API_KEY="grk_seu_token_aqui"

# OpenAI (padrão)
export OPENAI_API_KEY="sua_openai_key"

# OU Azure OpenAI
export USE_AZURE_OPENAI="true"
export AZURE_OPENAI_API_KEY="sua_azure_key"
export AZURE_OPENAI_ENDPOINT="https://seu-recurso.openai.azure.com"
export AZURE_OPENAI_DEPLOYMENT="gpt-4o"
export AZURE_OPENAI_EMBEDDING_DEPLOYMENT="text-embedding-3-small"

4️⃣ Autenticar e Usar

from grkmemory import GRKMemory, GRKAuth, AuthenticatedGRK

# Autenticar com token MonkAI
auth = GRKAuth.from_env()  # Usa GRKMEMORY_API_KEY
print("✅ Autenticado!")

# Inicializar GRKMemory protegido
grk = GRKMemory()
secure = AuthenticatedGRK(grk, auth.get_current_token())

# Usar!
secure.save_conversation([
    {"role": "user", "content": "Olá!"},
    {"role": "assistant", "content": "Oi! Como posso ajudar?"}
])

results = secure.search("Olá")

🎯 Quick Start (Completo)

from grkmemory import GRKMemory, GRKAuth, AuthenticatedGRK
import os

# 1. Autenticar
api_key = os.getenv("GRKMEMORY_API_KEY")
auth = GRKAuth()
auth.authenticate(api_key)

# 2. Criar GRKMemory autenticado
grk = GRKMemory()
secure = AuthenticatedGRK(grk, api_key)

# 3. Salvar conversa
secure.save_conversation([
    {"role": "user", "content": "Vamos falar sobre Python"},
    {"role": "assistant", "content": "Claro! O que você quer saber?"}
])

# 4. Buscar memórias relevantes
results = secure.search("O que discutimos sobre Python?")

# 5. Chat com contexto de memória automático
response = secure.chat("Me conte sobre nossas discussões anteriores")

🔐 Autenticação

Token MonkAI

A autenticação é uma camada de proteção opcional: ela só entra em cena quando você envolve a lib com GRKAuth/AuthenticatedGRK para dar a cada consumidor um token com permissões próprias (vários times/serviços num mesmo store). O uso direto — GRKMemory, MemoryRepository, servidor MCP, plugin Claude Code — funciona sem nenhum token (ver "Modo Offline (Sem Token)" abaixo). O que o GRKMemory/MemoryConfig exigem é uma chave OpenAI/Azure (para o chat agent e embeddings de API) — e mesmo essa é dispensável com MemoryRepository(enable_embeddings=False) ou com o provider local (grkmemory[local-embeddings]).

Permissão	Descrição
read	Buscar e consultar memórias
write	Salvar novas memórias
admin	Gerenciamento completo

Métodos de Autenticação

from grkmemory import GRKAuth

# Método 1: Via variável de ambiente (recomendado)
auth = GRKAuth.from_env()  # Usa GRKMEMORY_API_KEY

# Método 2: Diretamente
auth = GRKAuth()
auth.authenticate("grk_seu_token")

# Verificar permissões
print(f"Pode ler: {auth.check_permission('read')}")
print(f"Pode escrever: {auth.check_permission('write')}")

⚠️ Importante: Tokens são fornecidos exclusivamente pelo time MonkAI.

⚙️ Configuração

from grkmemory import GRKMemory, MemoryConfig

config = MemoryConfig(
    model="gpt-4o",
    memory_file="minhas_memorias.json",
    enable_embeddings=True,
    background_memory_method="graph",  # 'graph', 'embedding', 'tags', 'entities', 'hybrid'
    background_memory_limit=5,
    background_memory_threshold=0.3,
    storage_format="json",   # 'json' (padrão) ou 'toon'
    output_format="json"     # 'json', 'toon', 'text' ou 'raw'
)

grk = GRKMemory(config=config)

🗄️ Backends de Armazenamento (file / postgres)

O armazenamento e a busca vetorial vivem atrás de uma interface StorageBackend plugável. O default (file) mantém o comportamento histórico — um único arquivo plano (JSON/TOON, opcionalmente criptografado) com índice FAISS em memória. Ele é seguro apenas em processo único: dois processos compartilhando o mesmo MEMORY_FILE competem (último a escrever vence). Para um servidor com memória que precisa escalar horizontalmente, externalize o storage para remover esse acoplamento a instância-única + volume persistente.

Backend	Concorrência	Quando usar
file (default)	processo único	dev local, single-instance, sem nova dependência
postgres	entre processos (transacional)	produção horizontal/stateless

Seleção via ambiente (ou MemoryConfig):

# Default — nada muda
GRKMEMORY_STORAGE_BACKEND=file

# pgvector (requer o extra grkmemory[postgres])
GRKMEMORY_STORAGE_BACKEND=postgres
GRKMEMORY_POSTGRES_DSN=postgresql://user:pass@host:5432/db
GRKMEMORY_EMBEDDING_DIM=1536   # dimensão do embedding (default 1536)

pip install "grkmemory[postgres]"   # instala psycopg + pgvector

A biblioteca base nunca importa psycopg — o PostgresVectorBackend é resolvido sob demanda, então quem usa o backend file não ganha dependência nova. O backend externo cria a tabela + índice ANN HNSW (cosseno) na primeira inicialização. O grafo semântico continua sendo reconstruído em memória a partir dos registros (v1 não persiste arestas no banco).

Também é possível injetar um backend diretamente:

from grkmemory.memory.repository import MemoryRepository
from grkmemory.memory.backends import PostgresVectorBackend

backend = PostgresVectorBackend(dsn="postgresql://...", embedding_dim=1536)
repo = MemoryRepository(backend=backend)

☁️ Azure OpenAI

GRKMemory suporta Azure OpenAI nativamente. Configure via variáveis de ambiente ou código:

Via Variáveis de Ambiente

export USE_AZURE_OPENAI="true"
export AZURE_OPENAI_API_KEY="sua-api-key"
export AZURE_OPENAI_ENDPOINT="https://seu-recurso.openai.azure.com"
export AZURE_OPENAI_DEPLOYMENT="gpt-4o"
export AZURE_OPENAI_EMBEDDING_DEPLOYMENT="text-embedding-3-small"
export AZURE_OPENAI_API_VERSION="2024-02-01"  # opcional

Via Código

from grkmemory import GRKMemory, MemoryConfig

# Configuração Azure OpenAI
config = MemoryConfig(
    use_azure=True,
    api_key="sua-azure-api-key",
    azure_endpoint="https://seu-recurso.openai.azure.com",
    azure_deployment="gpt-4o",
    azure_embedding_deployment="text-embedding-3-small",
    azure_api_version="2024-02-01"
)

grk = GRKMemory(config=config)

Tabela de Configurações Azure

Variável	Config	Descrição
USE_AZURE_OPENAI	use_azure	Ativar Azure (true/false)
AZURE_OPENAI_API_KEY	api_key	Chave da API Azure
AZURE_OPENAI_ENDPOINT	azure_endpoint	URL do recurso Azure
AZURE_OPENAI_DEPLOYMENT	azure_deployment	Nome do deployment (chat)
AZURE_OPENAI_EMBEDDING_DEPLOYMENT	azure_embedding_deployment	Nome do deployment (embeddings)
AZURE_OPENAI_API_VERSION	azure_api_version	Versão da API (default: 2024-02-01)

📦 Formatos de Armazenamento (JSON vs TOON)

GRKMemory suporta dois formatos de serialização:

Formato	Vantagem	Uso Recomendado
JSON	Parsing 27x mais rápido	Armazenamento (padrão)
TOON	25% menos tokens	Contexto para LLM

Instalando TOON (opcional)

pip install toon_format

Estratégia Híbrida (Recomendada)

from grkmemory import MemoryRepository

# JSON para armazenamento (rápido) + TOON para LLM (economia de tokens)
repo = MemoryRepository(
    memory_file="memorias.json",
    storage_format="json",      # Parsing rápido
    output_format="toon"        # 25% menos tokens para LLM
)

# Buscar e formatar para LLM
results = repo.search("Python")
context = repo.format_for_llm(results)  # Retorna em TOON (~25% menos tokens)

Comparando Formatos

# Estimar economia de tokens
estimates = repo.get_token_estimate(results)
print(estimates)
# {'json': 689, 'toon': 512, 'savings_toon_vs_json': '25.7%'}

✂️ output_format="raw" — Modo enxuto de tokens

Quando o consumidor downstream só precisa do conteúdo da resposta (a mensagem do assistant) e não dos metadados de cada memória (summary, tags, entities, sentiment, etc.), use output_format="raw". Devolve apenas o content do primeiro turno de assistant de cada conversa recuperada, separado por \n\n---\n\n.

repo = MemoryRepository(
    memory_file="memorias.json",
    output_format="raw",
)

results = repo.search("capital da França")
context = repo.format_for_llm(results)
# "A capital da França é Paris."
# (sem JSON wrapper, sem metadados, sem labels)

Benchmark (issue #13)

47k chars de snapshot, 30 queries, gpt-4.1-mini + judge gpt-4.1 (rubrica 0–3):

Formato	input tokens	judge	recall vs json
json (default)	1.705	1.47	igual
toon	1.475	1.47	igual
text	252	1.00	cai (perde conversation)
raw	640	1.47	igual

→ ~2.7× mais barato que json com recall idêntico em consultas factuais. Use quando o LLM downstream só precisa do que o assistente respondeu antes; use json/toon quando o LLM precisa raciocinar sobre tags/sentiment/confidence.

🔍 preserve_identifiers — Recall em corpus pequeno/identifier-dense

O KnowledgeAgent resume cada conversa antes de embeddar, o que é ótimo para chat narrativo, mas descarta tokens identificadores (semver v1.6.0, issue refs #42, env vars OPENAI_API_KEY, key=value floor_value=30) — justamente o que consultas factuais matcham. Em corpus pequeno/identifier-dense (<~95k tokens), cosine ingênuo sobre chunks crus chega a vencer o GRKMemory em 0.3–1.1 pontos de judge nessas consultas. Acima de ~95k tokens o GRKMemory volta a ganhar (a discriminação semântica supera o "imposto" da perda de surface).

A solução é um dual-index opt-in:

from grkmemory import MemoryConfig, GRKMemory

cfg = MemoryConfig(
    preserve_identifiers=True,  # default False — opt-in, sem custo se off
    # identifier_regex=...      # opcional; default cobre semver/#issue/SCREAMING_SNAKE/key_=val
    background_memory_method="hybrid",  # max-pool sobre os 2 embeddings
)

grk = GRKMemory(config=cfg)
grk.save_conversation([
    {"role": "user", "content": "qual a última versão?"},
    {"role": "assistant", "content": "Liberamos v1.6.0 no PyPI ontem."},
])

# Consulta factual com surface token — o embedding do summary largou "v1.6.0",
# mas o embedding_identifier preservou. O hybrid recupera.
results = grk.search("v1.6.0")

O que muda no schema

Quando ligado, cada memória ganha 2 campos:

• identifiers: List[str] — tokens extraídos do conversation[assistant].content
• embedding_identifier: List[float] — vetor sobre {summary} {identifiers}

search(method="hybrid") calcula max(cos(query, embedding), cos(query, embedding_identifier)) por memória. Custo extra: 1 chamada de embedding adicional por save() (zero se o regex não casa nada nessa memória). Default off — backwards compatible.

Padrões cobertos pelo regex default

Padrão	Exemplo
semver	v1.6.0, 0.47.0-rc1
issue ref	#42, #300
SCREAMING_SNAKE	OPENAI_API_KEY, RUN_LLM_E2E
lower_snake=value	floor_value=30, top_k=5

Customizável via identifier_regex ou env IDENTIFIER_REGEX.

Convertendo entre Formatos

# Exportar para TOON
repo.export("backup.toon", format="toon")

# Converter armazenamento para TOON
repo.convert_storage_format("toon")

👥 Multi-tenant (user_id / session_id / tenant_id)

É possível isolar memórias por usuário, sessão e/ou tenant usando os parâmetros opcionais user_id, session_id e tenant_id em save_conversation, search, chat, get_stats e get_top_memories. O armazenamento continua em um único arquivo/store; o filtro é aplicado na busca.

# Salvar conversa para um usuário/sessão
grk.save_conversation(
    [{"role": "user", "content": "Olá!"}, {"role": "assistant", "content": "Oi!"}],
    user_id="user_123",
    session_id="sess_abc"
)

# Buscar apenas memórias desse usuário
results = grk.search("Olá", user_id="user_123")

# Ou apenas dessa sessão
results = grk.search("Olá", session_id="sess_abc")

# Chat e save também aceitam user_id/session_id
response = grk.chat("O que discutimos?", user_id="user_123")

Sem user_id/session_id, o comportamento é o mesmo de antes (todas as memórias são consideradas).

Isolamento por tenant (stores compartilhados)

Use tenant_id para garantir que dois tenants com o mesmo user_id em um store compartilhado nunca vejam as memórias um do outro. A chave efetiva de isolamento é tenant × user × session.

from grkmemory import GRKMemory, MemoryConfig

# Uma instância GRKMemory por tenant (recomendado para stores compartilhados)
grk = GRKMemory(MemoryConfig(tenant_id="tenant_x"))
grk.save_conversation(msgs, user_id="guest")   # armazenado sob tenant_x
grk.search("pedidos", user_id="guest")          # escopo restrito a tenant_x

# Ou sobrescrever por chamada
grk.search("pedidos", user_id="guest", tenant_id="other_tenant")

tenant_id=None (padrão) preserva o namespace global existente — nenhum deploy atual precisa mudar. A variável GRKMEMORY_TENANT_ID define o padrão no config via env.

⏳ Fatos temporais (bi-temporalidade)

Fatos mudam com o tempo ("threshold aprovado = 0.7" → semanas depois "= 0.5"). Cada memória pode carregar uma janela de validade [valid_from, valid_until) além do created_at, e uma memória nova pode superseder a antiga sem apagá-la:

# Janela de validade explícita no save (opcional)
repo.save({"summary": "threshold aprovado = 0.7", "tags": ["threshold"],
           "valid_from": "2026-01-10T00:00:00"})
repo.save({"summary": "threshold aprovado = 0.5", "tags": ["threshold"],
           "valid_from": "2026-03-15T00:00:00"})

# A decisão nova supersede a antiga (anotação, nunca delete)
grk.supersede(old_id, new_id)

# Recall padrão = "válido agora": só o fato vigente aparece
grk.search("threshold")

# Time-travel: o que era verdade em fevereiro?
grk.search("threshold", as_of="2026-02-01T00:00:00")

Regras: valid_until é exclusivo; sem campos de validade a memória é sempre válida (100% retrocompatível); em consultas as_of explícitas o created_at faz papel de valid_from quando este falta. A memória superada continua acessível via as_of e get_memory_detail — o campo superseded_by aponta para quem a substituiu. Detecção automática de supersessão (LLM/heurística) está fora de escopo por ora (ver issue #50).

🔌 Servidor MCP (grkmemory[mcp])

Exponha a memória como tools para qualquer cliente MCP (Claude Code, claude.ai, Agent SDK):

pip install grkmemory[mcp]

# Claude Code
claude mcp add grkmemory -- grkmemory-mcp

Tools expostas: memory_save (ingestão sem LLM — summary/tags/entities/key_points precomputados), memory_search (métodos graph/embedding/tags/entities/hybrid + as_of para time-travel), memory_supersede, memory_get, memory_stats_tool.

Configuração 100% via env vars padrão da lib (MEMORY_FILE, GRKMEMORY_STORAGE_BACKEND file/postgres, GRKMEMORY_TENANT_ID, BACKGROUND_MEMORY_LIMIT, ...). Embeddings ligam automaticamente quando há credencial OpenAI/Azure no ambiente (OPENAI_API_KEY/AZURE_OPENAI_API_KEY/AZURE_FOUNDRY_KEY) ou ENABLE_EMBEDDINGS=true; sem credencial o recall usa graph/tags/entities e o servidor funciona 100% offline com o file backend. Embeddings nunca aparecem nos payloads das tools.

Instalação por IDE (VS Code / JetBrains) e Claude Desktop

As extensões de IDE do Claude Code leem a mesma configuração MCP do CLI: .mcp.json na raiz do projeto (escopo projeto, versionável) ou ~/.claude.json (escopo user). Não precisa de terminal para ativar — gere o arquivo pronto com:

grkmemory-mcp init             # cria/mescla ./.mcp.json (escopo projeto)
grkmemory-mcp init --desktop   # idem para o Claude Desktop (type: stdio, paths absolutos)
grkmemory-mcp init --memory-file /outro/caminho/memoria.json

O comando aponta o bloco grkmemory para o binário em execução (path absoluto), define MEMORY_FILE (default ~/.grkmemory/memoria.json, diretório criado na hora) e preserva outros servidores já configurados no arquivo. Na primeira abertura a extensão pede aprovação do servidor; use /mcp no chat para ver o status da conexão.

Bloco gerado (referência, caso prefira escrever à mão):

{
  "mcpServers": {
    "grkmemory": {
      "command": "/caminho/venv/bin/grkmemory-mcp",
      "args": [],
      "env": { "MEMORY_FILE": "/Users/voce/.grkmemory/memoria.json" }
    }
  }
}

Alternativa zero-install com uv: "command": "uvx", "args": ["--from", "grkmemory[mcp]", "grkmemory-mcp"].

Recall vetorial sem chave de API (grkmemory[local-embeddings]): com GRKMEMORY_EMBEDDING_PROVIDER=local, os métodos embedding/hybrid rodam com modelo on-device (fastembed/ONNX, default sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2, 384 dims, multilíngue — ~120MB baixados no primeiro uso; troque via GRKMEMORY_LOCAL_EMBEDDING_MODEL, precisa ser modelo suportado pelo fastembed). O servidor MCP liga embeddings automaticamente nesse modo — memória semântica 100% offline e keyless. Com pgvector, aponte GRKMEMORY_EMBEDDING_DIM para a dimensão do modelo.

Recall não é automático só com o MCP: instalar o servidor torna as tools disponíveis — o Claude decide chamá-las pelo contexto. Para memória verdadeiramente automática, use o plugin abaixo.

Plugin Claude Code (memória automática)

O plugin adiciona hooks que fazem o ciclo completo sem nenhuma instrução:

• UserPromptSubmit → busca memórias relevantes para o prompt e injeta como contexto do turno (recall automático, escopado por projeto);
• Stop/SessionEnd → destila a sessão (tarefa + desfecho + conceitos) e salva/atualiza uma memória por sessão, com segredos redactados antes de persistir;
• comando /memoria → buscar, salvar, supersedir e inspecionar pela conversa;
• registra o MCP server automaticamente (dispensa .mcp.json).

pip install "grkmemory[mcp]"        # o plugin usa o grkmemory-mcp do PATH (ou uvx)
/plugin marketplace add BeMonkAI/GRKMemory
/plugin install grkmemory@grkmemory

Os hooks nunca quebram a sessão (falhas vão para stderr e saem 0) e funcionam offline (recall graph/tags). Store default ~/.grkmemory/memoria.json; escopo por projeto via tenant_id derivado do diretório.

Sessões headless (claude -p em automação): as tools MCP entram deferred; use ENABLE_TOOL_SEARCH=false claude -p ... para carregá-las upfront.

Sessões cloud / claude.ai (MCP remoto via HTTP)

Sessões em containers efêmeros (Claude Code web, conectores claude.ai) não conseguem usar o transporte stdio local — o binário e o arquivo de memória evaporam com o container. Para esse caso, rode o servidor em um host seu e conecte por URL:

# no host (Railway, VM, etc.)
export GRKMEMORY_MCP_TOKENS="grk_um_token_por_consumidor"   # auth é OBRIGATÓRIA no modo HTTP
export GRKMEMORY_STORAGE_BACKEND=postgres                    # recomendado (multi-instância)
export GRKMEMORY_POSTGRES_DSN=postgres://...
grkmemory-mcp serve --http --host 0.0.0.0 --port 8080

O cliente conecta em https://<host>/mcp com header Authorization: Bearer <token>. Requisição sem token válido recebe 401 — um servidor exposto sem auth configurada nem sobe (fail-fast). Alternativa ao token estático: um arquivo de tokens GRKAuth (GRKMEMORY_TOKENS_FILE) com ciclo de vida completo via grkmemory-token (permissões, revogação).

⚡ API assíncrona

Para uso em código assíncrono (ex.: AtendentePro) sem bloquear o event loop, use os métodos *_async, que executam a lógica síncrona em thread (ex.: asyncio.to_thread em Python 3.9+):

import asyncio
from grkmemory import GRKMemory

grk = GRKMemory()

async def main():
    results = await grk.search_async("IA")
    await grk.save_conversation_async([
        {"role": "user", "content": "Olá"},
        {"role": "assistant", "content": "Oi!"}
    ])
    response = await grk.chat_async("O que discutimos?")

asyncio.run(main())

Disponíveis: search_async, save_conversation_async, chat_async, chat_with_history_async. Com AuthenticatedGRK: search_async, save_conversation_async, chat_async (com checagem de permissão).

🔓 Modo Offline (Sem Token)

O modo offline usa MemoryRepository com enable_embeddings=False e serve como backend sem API key para testes ou ambientes restritos, usando apenas tags, entities e grafo semântico (sem embeddings). Você pode usar o MemoryRepository sem token/API key quando embeddings estão desabilitados:

from grkmemory import MemoryRepository

# Modo offline - não precisa de API key
repo = MemoryRepository(
    memory_file="memories.json",
    enable_embeddings=False  # ← Chave: desabilitar embeddings
)

# Funcionalidades disponíveis sem token:
# ✅ Salvar memórias
repo.save({
    "summary": "Conversa sobre Python",
    "tags": ["python", "programação"],
    "entities": ["Python"],
    "key_points": ["Linguagem interpretada"]
})

# ✅ Buscar por tags
results = repo.search("python", method="tags")

# ✅ Buscar por entities
results = repo.search("Python", method="entities")

# ✅ Buscar por grafo (sem embeddings)
results = repo.search("programação", method="graph")

# ❌ Busca por embedding requer API key
# results = repo.search("query", method="embedding")  # Retorna vazio sem API key

Nota: GRKMemory e MemoryConfig requerem API key. Apenas MemoryRepository com enable_embeddings=False funciona sem token.

💾 Salvando Conversas em JSON

O GRKMemory salva automaticamente as conversas em um arquivo JSON estruturado:

Estrutura do JSON

{
  "sessoes": [
    {
      "id": "sess_abc123",
      "timestamp": "2025-01-09T12:00:00",
      "summary": "Discussão sobre Python e IA",
      "tags": ["python", "ia", "programação"],
      "entities": ["Python", "OpenAI", "GPT"],
      "concepts": ["machine learning", "api"],
      "messages": [
        {"role": "user", "content": "..."},
        {"role": "assistant", "content": "..."}
      ]
    }
  ]
}

Estrutura do TOON (Token-Optimized Object Notation)

O mesmo conteúdo em TOON ocupa ~25% menos tokens, ideal para contexto de LLM:

sessoes[1]:
  - id: sess_abc123
    timestamp: "2025-01-09T12:00:00"
    summary: Discussão sobre Python e IA
    tags[3]: python,ia,programação
    entities[3]: Python,OpenAI,GPT
    concepts[2]: machine learning,api
    messages[2]{role,content}:
      user,Vamos falar sobre Python
      assistant,Claro! O que você quer saber?

Nota: TOON elimina chaves, colchetes e aspas redundantes, compactando listas e tabelas em notação posicional. Instale com pip install toon_format.

Usando o MemoryRepository diretamente

from grkmemory import MemoryRepository

# Inicializar repositório
repo = MemoryRepository(memory_file="minhas_memorias.json")

# Salvar memória estruturada
memoria = {
    "summary": "Conversa sobre Python",
    "tags": ["python", "programação"],
    "entities": ["Python", "VS Code"],
    "concepts": ["sintaxe", "bibliotecas"],
    "messages": [
        {"role": "user", "content": "Como instalar Python?"},
        {"role": "assistant", "content": "Baixe em python.org..."}
    ]
}
repo.save(memoria)

# Buscar memórias
resultados = repo.search("Python", method="tags")

📊 Métodos de Busca

Método	Descrição
graph	Grafo semântico (recomendado)
embedding	Similaridade vetorial
tags	Busca por tags
entities	Busca por entidades

# Busca por grafo semântico
results = secure.search("IA", method="graph")

# Busca por embedding
results = secure.search("machine learning", method="embedding")

📈 Estatísticas

# Estatísticas gerais
stats = secure.get_stats()
print(f"Total de memórias: {stats['total_memories']}")

# Estatísticas do grafo
graph_stats = secure.get_graph_stats()
print(f"Nós: {graph_stats['total_nodes']}")
print(f"Arestas: {graph_stats['total_edges']}")

📁 Estrutura do Projeto

GRKMemory/
├── grkmemory/              # 📦 Pacote principal
│   ├── core/               # Classes principais
│   ├── memory/             # Repositório de memória
│   ├── graph/              # Grafo semântico
│   ├── auth/               # Autenticação
│   └── utils/              # Utilitários
├── examples/               # 💡 Exemplos de uso
├── papers/                 # 📄 Documentação técnica
└── README.md

📚 Exemplos

Veja a pasta examples/ para exemplos completos:

Exemplo	Descrição
01_basic_usage.py	Uso básico
02_custom_config.py	Configuração personalizada
03_chatbot_with_memory.py	Chatbot com memória
04_graph_analysis.py	Análise do grafo
05_batch_processing.py	Processamento em lote
06_authentication.py	Uso com autenticação
07_storage_formats.py	Formatos de armazenamento (JSON/TOON)
08_azure_openai.py	Integração com Azure OpenAI
09_multi_tenant.py	Multi-tenant com user_id e session_id
10_async_usage.py	Uso da API assíncrona (search_async, chat_async)

🔬 Performance

Números de benchmarks internos (corpus de conversas reais; comparação: enviar o histórico completo na context window vs recall seletivo do GRKMemory). Reproduzíveis via repo.get_token_estimate() e os harnesses em tests/ — meça no seu corpus antes de assumir os mesmos ganhos:

Métrica	Histórico completo na context window	GRKMemory (recall seletivo)
Tokens/query	~50.000	~2.500 (~95% de economia neste corpus)
Latência de recuperação	cresce com o histórico	~constante (grafo/índice local)

✅ Qualidade

Sem selos — sinais verificáveis:

• Suite de testes: 249 testes rodando em CI a cada push/PR (Python 3.10–3.13), incluindo testes de integração contra Postgres/pgvector real e harnesses de regressão de recall (ablation/formula sweep) — veja tests/ e o workflow ci.yml.
• Coverage com gate mínimo configurado no CI.
• Em produção: a lib roda em serviços MonkAI de produção como camada de memória de agentes.
• Por que só wheels (sem sdist)? O código é compilado com Cython para proteção de propriedade intelectual — decisão deliberada, não descuido. A API pública, os testes e este README são o contrato auditável.

📞 Contato

Para obter seu token de acesso ou suporte:

📧 Email: [e-mail]
🌐 Site: www.monkai.com.br

📄 Licença

MIT License - veja LICENSE

👨‍💻 Autor

Arthur Vaz - MonkAI