# vite-mf-monorepo-rag

Local RAG system for semantic recall of the `vite-mf-monorepo` legacy codebase from Claude Code.

## Goal

Allow Claude Code, when working in the Next.js project, to find legacy code and patterns by meaning — not by filename. Instead of searching by file name or regex, Claude Code calls `recall("how was token refresh handled?")` and gets back the most semantically relevant chunks from the legacy codebase.

## How it works
```
1. INDEXING (one-time, then re-run when legacy changes)
   pnpm index
   → walks vite-mf-monorepo (349 files)
   → chunks each file into overlapping segments
   → embeds each chunk via nomic-embed-text (Ollama, local)
   → stores chunks + embeddings in MongoDB Atlas (legacy_chunks)

2. RECALL (at query time, triggered by Claude Code)
   Claude Code calls the recall() MCP tool with a natural language query
   → query is embedded via nomic-embed-text
   → vector search in MongoDB Atlas finds the top N most similar chunks
   → Claude Code receives file paths + content ranked by semantic similarity
```

## Stack

| Component | Choice |
|---|---|
| Embeddings | nomic-embed-text via Ollama (local, 768 dimensions) |
| Vector store | MongoDB Atlas M0 — `rag-cluster` / `rag` / `legacy_chunks` |
| Vector index | Atlas Vector Search — cosine similarity, filters on `filePath`, `package`, `app` |
| MCP server | Local stdio server exposing `recall()` to Claude Code |
| Language | TypeScript |

## Prerequisites

### Ollama

Ollama must be running locally — it handles all embedding generation.

1. Download and install from [ollama.com](https://ollama.com)
2. Pull the embedding model:
```bash
ollama pull nomic-embed-text
```

3. Verify:
```bash
ollama list
```

Ollama must be running in the background before indexing or using recall.

## Structure
```
src/
  indexer/
    index.ts      # indexing pipeline entry point
    walk.ts       # recursive file walker with ignore rules
    classify.ts   # classifies files as app or package
    chunk.ts      # splits large files into overlapping chunks
  retriever/
    recall.ts     # embeds query + runs Atlas vector search
  mcp/
    server.ts     # stdio MCP server exposing recall() to Claude Code
```

## Indexed projects

- **Legacy** (`vite-mf-monorepo`) — indexed in MongoDB Atlas
- **Next** (`nextjs-multizone-tmdb`) — read live by Claude Code, not indexed

## Indexing rules

**Indexed:** `.ts`, `.tsx`, `.md` — source files and config files

**Ignored:** `node_modules`, `dist`, `__mf__temp`, `.netlify`, `scripts/`, `*.test.ts`, `*.spec.ts`, `*.d.ts`, `*.css`, `*.json`, `*.sh`, `.env*`, `vitest.config.ts`, `vitest.setup.ts`

## Setup
```bash
pnpm install
cp .env.example .env  # fill in MONGODB_URI and LEGACY_PATH
```

## Environment variables

| Variable | Description |
|---|---|
| `MONGODB_URI` | MongoDB Atlas connection string |
| `LEGACY_PATH` | Absolute path to the `vite-mf-monorepo` root |

## MCP server setup (nextjs-multizone-tmdb)

The MCP server must be registered in the Next.js project so Claude Code can call `recall()`.

Create `.mcp.json` at the root of `nextjs-multizone-tmdb`:
```json
{
  "mcpServers": {
    "rag-legacy": {
      "type": "stdio",
      "command": "pnpm",
      "args": ["--prefix", "/absolute/path/to/vite-mf-monorepo-rag", "run", "mcp"],
      "env": {
        "MONGODB_URI": "your_mongodb_uri",
        "LEGACY_PATH": "/absolute/path/to/vite-mf-monorepo"
      }
    }
  }
}
```

Then in Claude Code, run `/mcp` and accept the server when prompted.

## Scripts
```bash
pnpm index        # run the full legacy indexing pipeline
pnpm mcp          # start the MCP server (Claude Code does this automatically)
pnpm build        # compile TypeScript
pnpm lint         # ESLint
pnpm type-check   # type check without compilation
```

## Re-indexing

Run `pnpm index` whenever the legacy codebase changes. The pipeline clears `legacy_chunks` and re-indexes everything from scratch.