┌──────────────────────────────────────────────────────┐
│                    WEB UI (React)                      │
│                                                        │
│  ┌────────────┐  ┌────────────┐  ┌─────────────────┐  │
│  │ Broad Graph │→│Focused Graph│→│  Memory Feed     │  │
│  │ (d3-force)  │  │ (d3-force) │  │  (Card Layout)  │  │
│  └────────────┘  └────────────┘  └─────────────────┘  │
│                                                        │
│  ┌─────────────────────────────────────────────────┐   │
│  │              Global Search Bar                   │   │
│  └─────────────────────────────────────────────────┘   │
└──────────────────────┬───────────────────────────────┘
                       │ HTTP API
                       ▼
┌──────────────────────────────────────────────────────┐
│               BACKEND API (FastAPI)                    │
│                                                        │
│  ┌──────────┐ ┌──────────┐ ┌───────────┐ ┌────────┐  │
│  │  Graph   │ │  Memory  │ │  Search   │ │ Temp   │  │
│  │  Manager │ │  Store   │ │  Engine   │ │ Manager│  │
│  └──────────┘ └──────────┘ └───────────┘ └────────┘  │
└──────────────────────┬───────────────────────────────┘
                       │
          ┌────────────┼────────────┐
          ▼            ▼            ▼
    ┌──────────┐ ┌──────────┐ ┌──────────┐
    │  SQLite  │ │ ChromaDB │ │Filesystem│
    │ (graph + │ │ (vector  │ │ (recall  │
    │ metadata)│ │  search) │ │  files)  │
    └──────────┘ └──────────┘ └──────────┘

┌──────────────────────────────────────────────────────┐
│              MCP SERVER (FastMCP)                      │
│                                                        │
│  Tools: search_memory, save_conversation,              │
│         get_context, list_topics, warm_node,           │
│         get_recall_file, push_chunk                    │
│                                                        │
│  (Wraps the same Backend API)                          │
└──────────────────────────────────────────────────────┘

neurigraph/
├── backend/
│   ├── main.py                 # FastAPI app entry point
│   ├── graph_manager.py        # Knowledge graph CRUD (SQLite)
│   ├── memory_store.py         # Conversation chunk storage + recall files
│   ├── search_engine.py        # Keyword + vector search cascade
│   ├── temperature_manager.py  # Hot/warm/cold state + warming logic
│   ├── summarizer.py           # LLM-based summary + keyword extraction
│   ├── mcp_server.py           # FastMCP server wrapping the API
│   ├── models.py               # Pydantic models / data schemas
│   ├── database.py             # SQLite + ChromaDB initialization
│   └── config.py               # Settings, paths, thresholds
├── frontend/
│   ├── src/
│   │   ├── app/                # Next.js pages or Vite routes
│   │   ├── components/
│   │   │   ├── BroadGraph.tsx       # Layer 1 force graph
│   │   │   ├── FocusedGraph.tsx     # Layer 2 force graph
│   │   │   ├── MemoryFeed.tsx       # Card-based memory browser
│   │   │   ├── MemoryCard.tsx       # Individual memory chunk card
│   │   │   ├── SearchBar.tsx        # Global search
│   │   │   ├── NodeDetail.tsx       # Node info sidebar
│   │   │   └── ViewToggle.tsx       # Feed / Table / Tree view switch
│   │   ├── lib/
│   │   │   └── api.ts               # Backend API client
│   │   └── styles/
│   ├── package.json
│   └── tailwind.config.js
├── data/
│   ├── neurigraph.db           # SQLite database
│   ├── chroma/                 # ChromaDB persistent storage
│   └── recall-files/           # Markdown transcripts + artifacts
│       └── {topic}-{date}/
│           ├── transcript.md
│           ├── summary.md
│           ├── keywords.txt
│           └── artifacts/
├── requirements.txt
├── package.json
└── README.md

-- Layer 1: Broad topic nodes
CREATE TABLE broad_nodes (
    id TEXT PRIMARY KEY,
    name TEXT NOT NULL,
    description TEXT,
    color TEXT DEFAULT '#6366f1',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    access_count INTEGER DEFAULT 0
);

-- Layer 2: Focused sub-topic nodes
CREATE TABLE focused_nodes (
    id TEXT PRIMARY KEY,
    broad_node_id TEXT NOT NULL REFERENCES broad_nodes(id),
    name TEXT NOT NULL,
    description TEXT,
    color TEXT DEFAULT '#8b5cf6',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    access_count INTEGER DEFAULT 0
);

-- Edges between focused nodes (cross-connections)
CREATE TABLE node_edges (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    source_node_id TEXT NOT NULL,
    target_node_id TEXT NOT NULL,
    relationship TEXT,         -- e.g., "related_to", "depends_on", "see_also"
    weight REAL DEFAULT 1.0,   -- strength of connection (used for warming)
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    UNIQUE(source_node_id, target_node_id)
);

-- Memory chunks (Y-axis depth)
CREATE TABLE memory_chunks (
    id TEXT PRIMARY KEY,
    focused_node_id TEXT NOT NULL REFERENCES focused_nodes(id),
    summary TEXT NOT NULL,
    keywords TEXT NOT NULL,          -- comma-separated
    token_count INTEGER,
    recall_file_path TEXT NOT NULL,  -- path to transcript.md
    artifacts_path TEXT,             -- path to artifacts/ folder
    source_model TEXT,               -- "claude", "chatgpt", "gemini", etc.
    temperature TEXT DEFAULT 'hot',  -- "hot", "warm", "cold"
    is_compressed BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    access_count INTEGER DEFAULT 0
);

-- Access log (for warming algorithm)
CREATE TABLE access_log (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    node_id TEXT NOT NULL,
    node_type TEXT NOT NULL,         -- "broad", "focused", "chunk"
    accessed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

GET    /api/graph/broad                    # List all broad nodes
POST   /api/graph/broad                    # Create a broad node
GET    /api/graph/broad/{id}/focused       # List focused nodes for a broad node
POST   /api/graph/broad/{id}/focused       # Create a focused node under a broad node
GET    /api/graph/focused/{id}             # Get focused node details + connections
POST   /api/graph/edges                    # Create edge between focused nodes
GET    /api/graph/edges/{node_id}          # Get all edges for a node

GET    /api/memory/{focused_node_id}           # List memory chunks (paginated, sorted)
GET    /api/memory/chunk/{chunk_id}            # Get full chunk (decompress if cold)
POST   /api/memory/{focused_node_id}/push      # Push a new conversation chunk
DELETE /api/memory/chunk/{chunk_id}             # Delete a memory chunk

GET    /api/search?q={query}                   # Global search across all memories
GET    /api/search?q={query}&scope={node_id}   # Scoped search within a node

GET    /api/temperature/status                 # Current temperature states
POST   /api/temperature/warm/{node_id}         # Manually warm a node + connected nodes
POST   /api/temperature/maintenance            # Run cooling cycle (called on schedule)

@mcp.tool()
async def search_memory(query: str, scope: str = None) -> str:
    """Search across all memories. Returns ranked results with summaries.
    Optionally scope to a specific broad or focused node ID."""

@mcp.tool()
async def save_conversation(
    content: str,
    broad_topic: str,
    focused_topic: str,
    source_model: str = "unknown"
) -> str:
    """Save a conversation chunk. Auto-generates summary and keywords.
    Creates broad/focused nodes if they don't exist."""

@mcp.tool()
async def get_context(broad_topic: str = None, focused_topic: str = None) -> str:
    """Retrieve relevant context for the current conversation.
    Returns summaries from matching nodes. Warms connected nodes."""

@mcp.tool()
async def list_topics() -> str:
    """List all broad topics and their focused sub-topics.
    Returns the full graph structure."""

@mcp.tool()
async def get_recall_file(chunk_id: str) -> str:
    """Retrieve the full transcript for a specific memory chunk.
    Decompresses if the chunk is cold."""

@mcp.tool()
async def push_chunk(
    focused_node_id: str,
    transcript: str,
    artifacts: list[str] = None
) -> str:
    """Push a new conversation chunk to a specific focused node.
    Generates summary, extracts keywords, creates recall file."""

@mcp.tool()
async def warm_node(node_id: str) -> str:
    """Manually warm a node and its connected nodes.
    Decompresses cold chunks and caches them."""

SUMMARIZE_PROMPT = """Analyze the following conversation transcript and return JSON:
{
  "summary": "A 100-300 word summary capturing the key points, decisions, and outcomes",
  "keywords": ["keyword1", "keyword2", ...],
  "suggested_broad_topic": "One or two word broad category",
  "suggested_focused_topic": "More specific sub-topic"
}

TRANSCRIPT:
{transcript}
"""

async def search(query: str, scope: str = None) -> list[SearchResult]:
    # Step 1: Keyword search (fast, exact)
    keyword_results = await keyword_search(query, scope)

    # Step 2: Vector search on summaries (semantic)
    vector_results = await chroma_search(query, scope, n_results=20)

    # Step 3: Merge and rank
    combined = merge_results(keyword_results, vector_results)

    # Step 4: If confidence is low, do full-text transcript search
    if combined[0].score < 0.7:
        transcript_results = await fulltext_search(query, scope)
        combined = merge_results(combined, transcript_results)

    return combined[:10]

# Cooling rules:
# - Not accessed in 1 hour  → warm (still uncompressed, just deprioritized)
# - Not accessed in 7 days  → cold (transcript gzipped, only summary/keywords indexed)
# - Not accessed in 30 days → deep cold (artifacts also compressed)

# Warming rules:
# - When node X is accessed, find all edges from node X
# - For each connected node Y with weight W:
#     - If Y is cold and W > 0.5: warm Y (decompress transcript)
#     - If Y is cold and W <= 0.5: leave cold but pre-cache summary
# - Warming is async / non-blocking

async def create_recall_file(focused_node_id, transcript, summary, keywords, artifacts=None):
    # Generate folder name
    node = get_focused_node(focused_node_id)
    date = datetime.now().strftime("%Y-%m-%d")
    slug = slugify(node.name)
    folder = f"data/recall-files/{slug}-{date}-{uuid4().hex[:6]}"

    os.makedirs(folder, exist_ok=True)

    # Write files
    write_file(f"{folder}/transcript.md", transcript)
    write_file(f"{folder}/summary.md", summary)
    write_file(f"{folder}/keywords.txt", "\n".join(keywords))

    if artifacts:
        os.makedirs(f"{folder}/artifacts", exist_ok=True)
        for artifact in artifacts:
            copy_to(artifact, f"{folder}/artifacts/")

    # Embed summary in ChromaDB
    chroma_collection.add(
        documents=[summary],
        metadatas=[{"focused_node_id": focused_node_id, "chunk_id": chunk_id}],
        ids=[chunk_id]
    )

    return folder

I'm building Neurigraph, a persistent AI memory system. Here is the full build plan:
[paste this document or reference it]

Today is Day [N]. Please implement everything listed under Day [N].

The project structure is:
[paste the file structure section]

The database schema is:
[paste the schema section]

Start by creating any files that don't exist yet, then implement the functionality.
Test everything before moving on.

Build a React frontend for a memory management system called Neurigraph.

Tech stack: Vite + React 18 + TypeScript + Tailwind CSS + shadcn/ui + react-force-graph-2d

The backend API is at http://localhost:8000 with these endpoints:
[paste the API endpoints section]

Build these components:
[paste the Frontend Components section]

The UX flow is:
1. User sees a draggable force-directed graph of broad topic nodes
2. Clicking a broad node shows a second force-directed graph of focused sub-topic nodes
3. Clicking a focused node shows a scrollable feed of memory cards
4. Each card shows: date, summary, expandable transcript, keyword pills, artifact links
5. A global search bar is always visible at the top
6. User can toggle between Feed, Table, and Tree views