# Interview Prep MCP Server

A personal MCP server that combines DSA problem tracking with spaced-repetition
revision scheduling and RAG-based concept explanations, so Claude can act as
a personalized interview prep coach grounded in your own solved problems and notes.

## What it actually does

- Logs every DSA problem you solve, with topic, difficulty, and how confident
  you felt about it.
- Tells you which topics you're weakest in, based on real logged data, not guesses.
- Schedules revisions using the SM-2 algorithm (the same algorithm Anki is built on) -
  problems you struggled with come back sooner, problems you nailed come back later.
- Retrieves relevant concept notes (sliding window, DP, graphs, etc.) using TF-IDF
  based retrieval, so Claude explains concepts grounded in your own notes rather
  than purely from its general training knowledge.

## Project structure

```
interview-prep-mcp/
  server.py              - MCP server entry point, defines all tools
  database.py             - SQLite schema and all DB operations
  spaced_repetition.py    - SM-2 algorithm implementation
  rag_engine.py           - chunks concept notes, builds TF-IDF index, retrieves
  concepts/                - your concept notes as markdown files
    sliding_window.md
    dynamic_programming.md
    graphs.md
    arrays_and_strings.md
    trees.md
    greedy.md
  seed_data.py             - optional, populates realistic sample data for a demo
  requirements.txt
```

## Setup

1. Create a virtual environment and install dependencies:

```
python -m venv venv
venv\Scripts\activate        (Windows)
source venv/bin/activate     (Mac/Linux)
pip install -r requirements.txt
```

2. Test the server runs on its own (it should just hang waiting for input,
   that means it's working - press Ctrl+C to stop):

```
python server.py
```

3. Connect it to Claude Desktop. Open (or create) the config file:

- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
- Mac: `~/Library/Application Support/Claude/claude_desktop_config.json`

Add this (replace the path with the actual full path to server.py on your machine):

```json
{
  "mcpServers": {
    "interview-prep": {
      "command": "python",
      "args": ["C:\\full\\path\\to\\interview-prep-mcp\\server.py"]
    }
  }
}
```

4. Restart Claude Desktop completely. You should see a small tools icon showing
   the interview-prep server is connected.

## Want to see it fully populated before showing someone?

Run this once to seed 25 realistic sample problems spread across array, sliding
window, dp, graph, tree and greedy topics, with varied confidence levels so weak
topics and a revision queue show up immediately:

```
python seed_data.py
```

This is entirely optional - skip it if you'd rather start from a real, empty
history and log your own problems from day one. You can always delete
`interview_prep.db` later to reset and go back to a clean slate.

## Trying it out

Once connected, just talk to Claude normally:

- "I just solved Two Sum, array topic, easy, confidence 5, took me 8 minutes"
- "What are my weak topics?"
- "What's due for revision today?"
- "What's my plan for today?" (combines revision queue + weak topics in one view)
- "I just revised Longest Substring Without Repeating Characters, quality 4"
- "Explain sliding window to me based on my notes"

## Extending it

- Add more concept notes: just drop more `.md` files into `concepts/`, using
  `## Heading` sections like the existing ones. The index rebuilds automatically
  next time a tool is called, since rag_engine.py hashes the concepts folder
  and only re-indexes when something changed.
- Add more tools in server.py using the `@mcp.tool()` decorator - for example,
  a tool that pulls your solved-problem history from LeetCode's public API
  automatically instead of manual logging.

## Why TF-IDF instead of neural embeddings

For a small, fixed set of technical concept notes, TF-IDF with cosine similarity
retrieves accurately without needing a multi-gigabyte torch/CUDA install just to
run a personal tool. If the concept notes grow into a large, varied corpus later,
swap `rag_engine.py` for sentence-transformers + FAISS - the rest of the server
does not need to change, since `retrieve(query, top_k)` is the only function
the rest of the code depends on.