# How to Vibe Code Your Own Litmaps (and Stop Paying for It)

> Your Literature Review Assistant

- Site: https://litmaps.com
- Category: Research & Academic Discovery
- Platforms: Web app
- Verdict: **Solid side project** (62/100 vibecodeable)
- Estimated effort: 3-4 weeks part-time

## Verdict

Build a personal-use subset with Next.js, Turso, and an open academic dataset API, but expect significant debugging around force-directed graph performance and citation traversal.

Replicating Litmaps for personal research is a rewarding side project if you scope it down to importing a few seed papers and visualizing their immediate citation neighborhood via OpenAlex. The primary hurdles are handling the sheer volume of academic metadata without expensive enterprise databases and keeping the browser canvas buttery smooth when rendering complex citation graphs. While you won't match their proprietary indexing of 270M papers instantly, plugging into OpenAlex or Semantic Scholar APIs gives you a functioning engine in a few weekends.

### What you can't replicate

- Proprietary aggregated user behavioral data and custom graph ranking weights
- The combined user base and brand footprint following the ResearchRabbit acquisition
- Direct institutional licensing integrations

## What it does

An AI-powered research discovery and literature review assistant that indexes 270+ million academic papers and maps them as interactive citation networks.

### Core features

- Seed mapping via paper inputs
- Interactive 2D graph visualization of citation networks
- Proximity-based paper recommendations
- Automated literature alerts via email
- Zotero integration and BibTeX export
- Saved libraries and project workspaces

## The business

### Pricing

- Free: $0
- Pro: $10/mo
- Team: Custom

### Funding

$1.4M+ raised.
- Seed Round (~$1.0M USD)
- Extension / Series A (~$800k+ USD)
Investors: Icehouse Ventures, K1W1, Quidnet, Scholarly Angels, No Brand, AngelHQ, Exponential Partners

Founded 2016.
Team size: ~10 employees.

## The hard parts

- Indexing and querying millions of academic records with fast full-text/metadata search
- Rendering high-performance interactive force-directed citation graphs with thousands of nodes smoothly in the browser
- Graph-traversal algorithms to compute multi-hop relationships and proximity scoring
- Reliable OAuth sync with external reference managers like Zotero

## How to vibe code Litmaps

### Prerequisites

- Node.js (free): Required runtime for building and running the Next.js full-stack application.
- GitHub (free): Source control and deployment pipeline integration.
- OpenAlex / Semantic Scholar API Key (free): Provides programmatic access to academic papers, metadata, and citation edges.

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for scaffolding full-stack features and complex graph traversal algorithms in the terminal.
- Cursor: Ideal for fine-tuning interactive React canvas/SVG citation graph components and managing component states.

### Stack

- Frontend: Next.js with React and Tailwind CSS, utilizing D3.js or React Flow for citation graph rendering
- Backend: Next.js API routes handling graph traversal and third-party API orchestration
- Database: Turso (SQLite at the edge) for user maps and saved paper bookmarks
- Auth: better-auth for secure self-hosted authentication
- Other: Vercel AI SDK, Resend for email alerts

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API functions with zero-config preview deploys.): $0-20/mo
- Turso (Serverless SQLite database for storing user project maps, seed lists, and bookmarks.): $0/mo

### Build guide

1. **Project Scaffolding and Database Setup** — Initialize the Next.js application with TypeScript and Tailwind CSS, configure better-auth, and set up Turso database schema for users, maps, and saved papers.

```
Create a new Next.js 16 app with TypeScript, Tailwind CSS, and App Router. Set up better-auth with email/password authentication backed by a Turso SQLite database. Create database tables for users, maps (id, title, userId, createdAt), map_papers (mapId, paperId, positionX, positionY), and user_bookmarks. Include proper migration scripts and environment variable validation.
```

2. **Academic API Integration Service** — Build a robust wrapper service around the OpenAlex or Semantic Scholar API to search papers, fetch metadata, and extract incoming/outgoing citation edges.

```
Create a TypeScript service layer in `lib/academic.ts` that interacts with the OpenAlex API. Implement functions to search papers by keywords (returning title, abstract, publication year, citation count, DOI, and open access status) and fetch inbound/outbound citation lists for a given paper ID. Add robust error handling, rate-limiting protection, and caching using local memory or Turso.
```

3. **Seed Mapping and Graph Traversal Logic** — Implement the backend logic that accepts seed paper IDs, queries their citation networks, and computes network proximity scores for recommendations.

```
Implement server actions or API routes in Next.js for seed mapping. When a user inputs seed paper IDs, query the academic API to fetch first-degree and second-degree citation connections. Calculate a basic proximity score based on shared citations and co-references, and format the output nodes and edges for network visualization. Save the generated map state to the Turso database.
```

4. **Interactive Citation Graph Visualization** — Build the core interactive 2D canvas/SVG graph interface mapping papers across time and citation metrics using D3.js or React Flow.

```
Build an interactive citation graph component using D3.js force simulation or React Flow. The graph should plot papers with X-axis as publication year and Y-axis as citation count or network centrality. Nodes should be clickable to view paper details in a side drawer, support zooming and panning, and visually distinguish seed papers from recommended papers with clear connection edges.
```

5. **Library Management, Zotero Sync, and Exports** — Add bookmark management, BibTeX export functionality, and a basic Zotero collection import option.

```
Add library management views where users can organize saved papers into custom folders, export selected papers as BibTeX or RIS citation files, and implement a mock/real OAuth sync endpoint to import collections from a Zotero account via the Zotero Web API.
```

6. **Automated Email Alerts and Polish** — Set up a cron job or scheduled task using Resend to send periodic literature summary alerts for user maps matching new publications.

```
Configure a Vercel Cron route that runs weekly, checks user maps for newly published papers added to the academic index matching their seed topics, and uses Resend to send an automated digest email summarizing new relevant research. Polish the UI with toast notifications, loading skeletons, and dark mode support.
```

### Cost vs paying

**Starting costs (one-time):**

- Domain name (optional): $12 one-time
- AI coding tool subscription (Claude Pro / Cursor): $20
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Vercel Hobby Hosting: $0
- Turso Database: $0
- Resend Email API (Free tier): $0
- OpenAlex API: $0
- Total: $0/mo

- Paying for the SaaS instead: $10/mo
- Build time: 25-35 hours
- AI tool credits: $20
- Break-even: Free build (purely for learning and personal workflow customization)

## Sources

- [Litmaps Official Website](https://www.litmaps.com)
- [PitchBook - Litmaps Company Profile](https://pitchbook.com/profiles/company/257321-75)