# Todos os comandos do vídeo "Memória para suas IAs"

Cola-e-roda, na ordem do vídeo. Nada aqui pede API key nem cartão.

kc1t.com · última revisão: 07/09/2026

---

## Degrau 1 — Obsidian

### Instalar

Baixe em [obsidian.md](https://obsidian.md) e instale. Crie um vault numa pasta vazia.
Um vault é só uma pasta com arquivos `.md` — nada de banco de dados.

### Plugar a IA no vault (MCP que lê o vault direto do disco)

O Obsidian nem precisa estar aberto.

**PowerShell (Windows)** — repare nas aspas simples por fora, elas são obrigatórias aqui:

```powershell
claude mcp add obsidian -- npx -y '@bitbonsai/mcpvault' 'C:\caminho\do\seu\vault'
```

**bash / zsh (Linux e macOS)**:

```bash
claude mcp add obsidian -- npx -y @bitbonsai/mcpvault "/caminho/do/seu/vault"
```

Confira com `/mcp` dentro do Claude Code.

> **Versão mínima: 0.14.1.** Versões anteriores tinham uma falha de path bypass que
> deixava o servidor escapar da pasta do vault. O `-y` sempre pega a mais nova, então
> você já cai numa versão corrigida — só não force uma antiga.

Existe um segundo caminho, via plugin: o **Local REST API** (v5.0+, jul/2026) serve MCP
de dentro do próprio Obsidian por Streamable HTTP. Aí o `claude mcp add` aponta pro
endpoint do plugin e não precisa de servidor ponte — mas o Obsidian tem que estar aberto.

### Estruturar o vault

Use o prompt pronto de setup (o outro arquivo pra baixar nesta página): ele cria as pastas,
o `CLAUDE.md` com a tabela de roteamento, o `AGENTS.md` e os templates de uma vez.

---

## Degrau 2 — Graphify

Grafo do seu código: ele lê a sintaxe de cada arquivo e anota quem chama quem, quem
importa quem. A IA anda pelo grafo em vez de reler o repositório inteiro.

### Instalar

Precisa do `uv`, o gerenciador de pacotes Python. Você **não** precisa ter Python instalado.

```powershell
winget install --id=astral-sh.uv -e
```

```bash
# Linux e macOS
curl -LsSf https://astral.sh/uv/install.sh | sh
```

Depois, o Graphify. Repare no pacote com **dois** "y" e no comando com **um**:

```bash
uv tool install graphifyy
```

Isso instala dois executáveis: `graphify` e `graphify-mcp`.

### Gerar o grafo do seu projeto

```bash
cd /caminho/do/seu/projeto

graphify extract . --code-only --no-label
graphify cluster-only . --no-label
```

- `extract` percorre o repositório e monta os nós e as arestas.
- `--code-only` olha só o código, ignorando docs e configuração.
- `cluster-only` roda por cima e agrupa o grafo em comunidades — os pedaços do projeto
  que andam juntos.

Saída em `graphify-out/`: `GRAPH_REPORT.md` (o relatório em markdown), `graph.html`
(o mapa visual, abre no navegador), `graph.json` e `manifest.json`.

### Comandos que valem a pena

```bash
# os nós com mais conexões — ele acha sozinho o esqueleto do projeto
graphify god-nodes --top 8

# tudo sobre um símbolo: arquivo, linha e cada vizinho com o tipo de ligação
graphify explain "throwIfNoTeamAccess"

# o caminho entre duas partes do código
graphify path "LoginPage" "ApiError" --undirected

# quanto de token você está economizando de verdade
graphify benchmark
```

> **Sobre o `path`:** direcionado ele costuma não achar caminho. Use `--undirected`.

### Plugar no Claude Code

```bash
graphify claude install
```

Escreve uma seção no seu `CLAUDE.md` e instala um hook `PreToolUse`, pra IA consultar o
grafo antes de sair lendo arquivo.

### Números reais do vídeo

Repositório de teste com 304 arquivos de código: **1342 nós, 3337 arestas, 124 comunidades**,
gerado em segundos. O `benchmark` deu **7,9x de redução média** de tokens por pergunta
(55x numa pergunta estrutural, ~5,5x numa pergunta larga).

O "70x" que circula na comunidade é relato, não medição. Rode o `benchmark` no **seu**
repositório — é o único número que vale pra você.

### Pegadinha

Arquivos `.sql` ficam de fora do grafo por padrão. Se você precisa deles:

```bash
uv tool install "graphifyy[sql]"
```

---

## Degrau 3 — ai-memory (do Akita)

Memória do que **aconteceu**: ele escuta suas sessões por hook e vai escrevendo uma wiki
em markdown com SQLite por baixo. A mesma memória serve ~20 agentes diferentes, então dá
pra começar uma tarefa no Claude Code e terminar no Codex.

Repositório: [github.com/akitaonrails/ai-memory](https://github.com/akitaonrails/ai-memory)

### Pré-requisito

Docker instalado e rodando.

### Subir o servidor

**PowerShell (Windows)**:

```powershell
docker run -d --name ai-memory --restart unless-stopped `
  -p 127.0.0.1:49374:49374 -v ai-memory-data:/data `
  akitaonrails/ai-memory:latest
```

**bash / zsh (Linux e macOS)**:

```bash
docker run -d --name ai-memory --restart unless-stopped \
  -p 127.0.0.1:49374:49374 -v ai-memory-data:/data \
  akitaonrails/ai-memory:latest
```

Sem nenhuma variável de LLM, ele roda em modo zero API key: a busca é FTS5 puro do SQLite.

### Instalar o CLI

O download é o zip da release do seu sistema. No Windows:

```powershell
# baixe, extraia numa pasta sua e adicione essa pasta ao PATH do usuário
# https://github.com/akitaonrails/ai-memory/releases/latest/download/ai-memory-windows-x86_64.zip
```

Feche e abra o terminal, e confirme:

```bash
ai-memory status
```

### Ligar nos agentes

Um par de comandos por agente:

```bash
ai-memory install-mcp   --client claude-code --apply
ai-memory install-hooks --agent  claude-code --apply

ai-memory install-mcp   --client codex --apply
ai-memory install-hooks --agent  codex --apply
```

### O que isso muda na sua máquina (leia antes de rodar)

Esses comandos escrevem em configuração **global**, não por projeto. Cada um deles
grava um backup ao lado do arquivo original:

| Arquivo | O que entra |
|---|---|
| `~/.claude.json` | registro do MCP |
| `~/.claude/settings.json` | os hooks |
| `~/.codex/config.toml` | MCP do Codex |
| pasta local do ai-memory | os scripts de hook |

No Codex não existe configuração de MCP por projeto — é sempre global. Na prática é isso
que faz a memória atravessar qualquer pasta que você abrir.

### Primeira vez no Codex

A TUI mostra **"Hooks need review"**. Escolha **"Trust all and continue"**.
Existe a flag `--dangerously-bypass-hook-trust`, mas não use — ela desliga a revisão
de hook pra tudo, não só pra isso.

### Testar o handoff

1. No Claude Code, dentro de um projeto, peça alguma coisa e deixe ele trabalhar.
2. Saia (`Ctrl+C`, `exit`), abra o Codex **na mesma pasta**.
3. Pergunte: *"o que estava sendo feito neste projeto? continue de onde parou."*

Ele retoma. É a prova de que a memória é do projeto, não da ferramenta.

### Ver tudo pelo navegador

```
http://localhost:49374
```

Lista os projetos, as páginas de memória e a atividade recente de cada um.

### Pegadinhas

- A flag do `write-page` é `--body`, não `--content` (o README induz ao erro).
- `write-page` num projeto que ainda não existe devolve `404 project not found`.
  O projeto nasce da sessão do agente — rode de dentro do diretório.

---

## Se algo aqui parar de funcionar

Ferramenta em beta muda rápido. Comenta no vídeo ou me chama no Discord que eu atualizo
esta página.