Content
# 🐘 Conectica
### Your AI memory, as files you own. One vault. Every model.
[](https://github.com/darknodebros/conectica/actions/workflows/ci.yml)
[](LICENSE)
[](https://modelcontextprotocol.io)
You use Claude, ChatGPT, and Gemini. Each one knows a different slice of you, and none
of them share. **Conectica** is one local-first vault on your own disk that every AI
plugs into over the [Model Context Protocol](https://modelcontextprotocol.io) — so context
you build in one AI is instantly available in all of them. Local-first. MCP-native. Yours.
> No pasting context around. No static "memory chips." No switching apps. The AIs you
> already use connect to a vault *you* control.
```
Teach ChatGPT a fact → it lands in your vault → Claude already knows it.
```
This is a working seed (MVP), not a toy: the core has a passing 42-test suite and a CLI
you can run today.
---
## The one-sentence idea
**Conectica *is* an MCP server sitting on top of a local-first file store.**
Because MCP is now supported natively by OpenAI, Google and Anthropic, a single server
makes one vault you own readable and writable by all of them — live and bidirectionally.
## Why this, when Anuma / Memory Forge exist?
The "unified memory layer" concept is validated (Anuma crossed ~60k users). The gap they
leave open is the wedge here:
| | Anuma | Memory Forge | **Conectica (this)** |
|---|---|---|---|
| Open / inspectable | ✗ closed app | partial | ✓ your files, your code |
| MCP server | ✗ none | ✗ | ✓ core feature |
| Keep using Claude/ChatGPT/Gemini apps | ✗ must switch in | n/a | ✓ they connect to you |
| Live read **+ write back** | within app | ✗ static file | ✓ |
| Infrastructure | crypto/wallet | browser only | ✓ zero — files + SQLite |
"Eco-friendly and easy" = no server, no database to run, no crypto. Markdown + SQLite.
## Architecture
```
ChatGPT export ─┐
Claude export ─┤ adapters/normalize.py ┌─ notes/*.md (source of truth, Obsidian-compatible)
Gemini export ─┼─► → MemoryItem (schema) ──► │
manual notes ─┘ └─ index.db (SQLite + FTS5 full-text search)
│
▼
mcp_server.py (the connector)
│
┌─────────────────────────────────┼─────────────────────────────────┐
Claude Desktop ChatGPT Gemini / any MCP client
recall / remember / forget / memory_status
```
- **`conectica/models.py`** — the normalized `MemoryItem` schema every source maps into.
- **`conectica/store.py`** — local-first store: markdown files + SQLite FTS index, with
content-hash dedup (re-importing is idempotent).
- **`conectica/normalize.py`** — tolerant ingest adapters that sniff each provider's export shape.
- **`conectica/mcp_server.py`** — exposes the vault over MCP (`recall`, `remember`, `forget`, `memory_status`).
- **`conectica/cli.py`** — `import`, `search`, `add`, `stats`, `reindex`, `export`, `serve`.
## Quick start
```bash
cd conectica
export CONECTICA_DIR=~/ConecticaVault
# Import what your AIs already exported (March-2026 export features on each platform)
conectica import ~/Downloads/chatgpt_memory.json --source chatgpt
conectica import ~/Downloads/claude_export.json --source claude
conectica search 'project notes'
conectica add "Prefers direct, no-fluff answers" --type preference
conectica stats
conectica export vault-backup.json # round-trip your whole vault back out
conectica reindex # rebuild the search index from notes/*.md
```
### Make it a connector (the point)
```bash
pip install "mcp[cli]" # or: pip install -e ".[mcp]"
conectica onboard # creates the vault + wires Claude Desktop for you
conectica doctor # verify the install end to end
```
`conectica onboard` writes the MCP server entry into your Claude Desktop config
automatically (backing up any existing one). Then fully quit and reopen Claude
Desktop and ask *"What do you remember about me?"* — that's your live verification.
Prefer to do it by hand? `conectica onboard --print-only` prints the exact config block:
```json
{
"mcpServers": {
"conectica": {
"command": "python",
"args": ["-m", "conectica.mcp_server"],
"env": { "CONECTICA_DIR": "/Users/you/ConecticaVault" }
}
}
}
```
Now Claude can `recall` your full cross-AI context at the start of any chat and `remember`
new durable facts back into the same vault that ChatGPT and Gemini read from.
## Tests
```bash
python -m unittest discover -s tests -v # 42 tests, stdlib only — no MCP SDK required
```
## Where the export files come from (2026 reality)
All three majors shipped memory export in March 2026 (GDPR Article 20 + competition), but
the formats are uneven and there's no clean memory API — so the adapters normalize the mess:
- **ChatGPT** — JSON of stored facts/preferences
- **Claude** — structured memory export from claude.ai
- **Gemini** — via Google Takeout (ZIP)
- **Grok** — xAI memory/personalization export (`{"grok_memories": [...]}`)
- **DeepSeek** — memory export (`{"deepseek_memories": [...]}`)
EU/EEA availability of the in-app import tools is restricted; importing your own export
file into your own vault sidesteps that entirely.
## Roadmap (the honest next 20%)
1. **Semantic dedup + recall** — swap the content-hash dedup and FTS for embeddings
(local model via sentence-transformers, or pgvector if you outgrow SQLite). The
interfaces in `store.py` are designed for this drop-in.
2. **Encryption at rest** — age/libsodium per-file encryption; keep markdown plaintext
optional for the privacy-conscious vs. Obsidian-readable tradeoff.
3. **Sync** — it's just files: `git`, iCloud, Syncthing, or Drive. No server to build.
After syncing the notes to another machine, `conectica reindex` rebuilds the search
index from the markdown so the vault and its index agree again.
4. **Scoped sharing** — per-client memory scopes (let Claude see writing style without
exposing legal/health context), the way Anuma gates by category.
5. **Provenance & conflict resolution** — when two AIs assert contradictory facts, surface
it instead of silently picking one.
6. **More adapters** — Grok and DeepSeek have landed; Manus is next (note: Manus is an
autonomous *agent*, not a chat-with-memory product — confirm it exposes an exportable
memory before building the adapter). Each new source is a ~40-line file in `normalize.py`;
the launch does not depend on any of them beyond the core three.
## License
MIT — see [LICENSE](LICENSE) for details.
