Metadata-Version: 2.4
Name: crossmem
Version: 0.1.0
Summary: Cross-project memory for AI coding agents
Keywords: ai,memory,mcp,developer-tools,cross-project
Author: Md Niajul Hasan
Author-email: Md Niajul Hasan <niajul1992@gmail.com>
License-Expression: MIT
License-File: LICENSE
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Software Development :: Libraries
Requires-Dist: click>=8.0
Requires-Dist: mcp>=1.27.0
Requires-Dist: pytest>=8.0 ; extra == 'dev'
Requires-Dist: ruff>=0.4 ; extra == 'dev'
Requires-Python: >=3.12
Provides-Extra: dev
Description-Content-Type: text/markdown

# crossmem

Your AI assistant remembers everything you've ever solved — across every project and every tool.

## The problem

You're working on project B. You need credential masking. You know you solved this in project A three months ago — but your AI assistant has no idea. It starts from scratch, suggests a different approach, and you waste an hour getting back to where you already were.

Here's what's happening under the hood:

```
~/.claude/projects/
├── project-A/memory/MEMORY.md    ← Claude remembers here
├── project-B/memory/MEMORY.md    ← ...but can't see here
└── project-C/memory/MEMORY.md    ← ...or here

~/.gemini/GEMINI.md               ← Gemini's memories (separate silo entirely)
```

Every project is a silo. Every tool is a silo. Knowledge doesn't compound — it resets.

## The fix

```bash
$ crossmem ingest
Ingested: 298 memories across 10 projects (Claude Code + Gemini CLI)

$ crossmem search "credential masking"
Found 3 results for "credential masking":

[1] project-A / Security
    Source: MEMORY.md
    - Credentials masked in experience_memory before persisting (_mask_actions)...

[2] project-B / Security
    Source: MEMORY.md
    - Credentials masked via _mask_context_credentials() + _mask_text()...

[3] project-A / Security
    Source: GEMINI.md
    - Credential masking pattern: _mask_actions for persistence, _mask_text for logs...
```

Three results. Two projects. Two AI tools. One query. The pattern was already solved — twice.

> Unlike Mem0 (cloud-based, API-key required) or Basic Memory (single-tool), crossmem is local-only, zero-config, and aggregates across both tools and projects.

## Install

```bash
pip install crossmem
# or
uv pip install crossmem
```

## Quick start

```bash
pip install crossmem        # 1. Install
crossmem ingest             # 2. Index all your AI memories
crossmem search "retry"     # 3. Search across every project
```

That's it. Three commands, zero config. crossmem finds Claude Code and Gemini CLI memory files automatically.

To give your AI tools direct access, add the MCP server to your config (see [MCP Server](#mcp-server) below) — then `mem_recall()` and `mem_search()` just work inside your coding sessions.

## Usage

```bash
# Ingest Claude Code + Gemini CLI memories
crossmem ingest

# Search across every project
crossmem search "JWT token rotation"
crossmem search "retry strategy" -p backend-api
crossmem search "docker compose" -n 5

# Sync Claude memories → Gemini CLI
crossmem sync                        # sync everything
crossmem sync -p backend-api        # sync one project + shared patterns

# Watch for changes and auto-sync
crossmem sync-watch                  # polls every 30s
crossmem sync-watch --interval 10    # custom interval

# Visualize the knowledge graph
crossmem graph

# See what's in the database
crossmem stats
```

## How it works

1. **Ingest** — Reads Claude Code (`~/.claude/projects/*/memory/*.md`) and Gemini CLI (`~/.gemini/GEMINI.md`), splits into granular chunks, deduplicates by content hash
2. **Index** — Stores in SQLite with FTS5 full-text search (porter stemming + unicode61 tokenizer)
3. **Search** — Multi-word queries use AND logic by default. Quoted phrases for exact matches
4. **Learn** — AI tools save new discoveries via `mem_save` during sessions. Knowledge compounds automatically
5. **Sync** — Translates Claude's structured markdown into Gemini's flat bullet format, preserving each tool's own memories

## MCP Server

crossmem runs as an MCP server so AI coding tools can search, recall, and save memories in real-time.

### Setup

Add to your tool's MCP config:

**Claude Code** (`~/.mcp.json` for global, or `.mcp.json` in project root):
```json
{
  "mcpServers": {
    "crossmem": {
      "command": "crossmem-server"
    }
  }
}
```

**Gemini CLI** (`~/.gemini/settings.json`):
```json
{
  "mcpServers": {
    "crossmem": {
      "command": "crossmem-server"
    }
  }
}
```

> **Note:** If `crossmem-server` isn't on PATH, use:
> `"command": "uvx", "args": ["--from", "crossmem", "crossmem-server"]`

### Tools

| Tool | Description |
|------|-------------|
| `mem_recall` | Load project context + cross-project patterns at session start (auto-detects project from cwd) |
| `mem_search` | Search across all memories (query, project filter, limit) |
| `mem_save` | Save a discovery during a session — immediately searchable |
| `mem_ingest` | Refresh the index when memory files change |

### Start manually

```bash
crossmem serve    # starts MCP server on stdio
```

## Supported tools

| Tool | Ingestion |
|------|-----------|
| Claude Code | `~/.claude/projects/*/memory/*.md` |
| Gemini CLI | `~/.gemini/GEMINI.md` |

Ingestion is pluggable — PRs welcome for new tools.

## License

MIT
