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

> AI for research discovery and evaluation

- Site: https://scite.ai
- Category: Academic Research & Discovery SaaS
- Platforms: Web app, Browser extension
- Verdict: **Don't bother** (15/100 vibecodeable)
- Estimated effort: 3-4 weeks part-time for the open-access subset

## Verdict

Build a personal open-access PDF search subset instead of paying, but recognize that Scite's proprietary publisher licensing moats make a true full-corpus clone impossible.

Scite's core value is entirely bound up in its legal data moat—direct licensing agreements with 40+ major academic publishing houses giving it rights to mine 300M+ paywalled articles and 1.6B+ citations. A solo developer cannot replicate this corpus without facing severe copyright infringement. For a personal-use clone restricted strictly to open-access corpora (arXiv, PubMed Central Open Access subset, Unpaywall), you can build a rudimentary paper-search and RAG assistant, but you will miss the proprietary Smart Citation classification and paywalled content that justifies Scite's subscription.

### What you can't replicate

- Direct publishing agreements with Wiley, SAGE, and 30+ other academic publishers
- Proprietary 1.6B+ Smart Citation intent classification index
- Comprehensive patent, clinical trial, and regulatory datasets (FAERS, MAUDE)

## What it does

An AI-powered research platform that helps users discover and evaluate scientific literature through Smart Citations and a grounded RAG assistant.

### Core features

- Smart Citation intent classification (supporting/contradicting/mentioning)
- Grounded RAG Assistant with inline sentence-level citations
- Full-text search inside academic article bodies
- Reference list auditing for retractions and disputes
- Cross-corpus ingestion (preprints, clinical trials, patents, grants)
- Reference manager integrations (Zotero)
- User collections and paper organization

## The business

### Pricing

- Basic: $20/mo
- Pro: $50/mo
- Team: $50/seat/mo
- Enterprise: Custom

### Funding

$21M raised.
- Seed Round
- Corporate Acquisition by Research Solutions
Investors: Venture funds, Strategic angels

Founded 2018.
Team size: 136 (via parent Research Solutions ecosystem).

## The hard parts

- The Data Wall & Copyright: Cannot legally index 300M+ paywalled publisher PDFs without direct licensing agreements (Wiley, SAGE, etc.)
- Smart Citation extraction pipeline: Parsing complex XML/PDF scientific layouts to pinpoint citation markers and classify intent
- STM-Scale RAG: Chunking dense technical papers with mathematical notation and chemical formulas without losing semantic context
- Real-time citation tracking across billions of parsed citation links

## How to vibe code Scite

### Prerequisites

- Node.js (free): Required runtime for Next.js and ingestion scripts
- GitHub (free): Repository hosting and CI/CD deployment connection

### Recommended AI tools

- Claude Code: Best-in-class terminal agent for scaffolding complex RAG ingestion pipelines and vector storage
- Cursor: Ideal for iterative UI work on the chat interface and search dashboard

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js API routes / Server Actions
- Database: Supabase (Postgres with pgvector for open-access chunk embeddings)
- Auth: better-auth
- Payments: None (personal use)
- Other: Vercel AI SDK, Cohere Rerank, Anthropic API

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API endpoints): $0-20/mo
- Supabase (Storing user collections, paper metadata, and vector embeddings via pgvector): $0-25/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize a Next.js application with TypeScript, Tailwind CSS, and shadcn/ui components. Configure Supabase with pgvector extension enabled for storing open-access academic paper embeddings.

```
Create a new Next.js 16 project using TypeScript, App Router, and Tailwind CSS. Initialize shadcn/ui configuration with base styles. Set up Supabase client utilities and write migration SQL files to create tables for 'papers' (id, doi, title, abstract, full_text, published_date, source_url), 'chunks' (id, paper_id, content, embedding vector(1536)), and 'citations' (id, citing_paper_id, cited_paper_id, context_sentence, intent_classification). Ensure pgvector extension is enabled in the migration script. Write an initialization test verifying database connectivity.
```

2. **Open Access Ingestion Pipeline** — Build a background ingestion script that fetches open-access papers and preprints from external open APIs (e.g., PubMed Central Open Access subset, arXiv API, Unpaywall), chunks their text, and stores vectors.

```
Build a TypeScript ingestion script in lib/ingestion/ that queries the PubMed Central Open Access API and arXiv API for recent papers in a specific field. Parse the XML/PDF responses to extract title, abstract, sections, and reference lists. Implement a text-chunking utility that splits academic text into 500-token chunks with 50-token overlap. Use OpenAI text-embedding-3-small to generate vector embeddings for each chunk, and batch insert papers, chunks, and embeddings into the Supabase database. Add robust error handling for rate limits and malformed XML.
```

3. **Smart Citation Intent Classifier** — Implement an LLM-based classification pipeline that analyzes citation contexts within papers and classifies them into supporting, contrasting, or mentioning categories.

```
Create an AI classification module in lib/classifier/ that takes a target paper's reference list and the sentences surrounding each citation marker in downstream papers. Using the Vercel AI SDK and Anthropic Claude Haiku, prompt the model to classify each citation intent as 'supporting', 'contrasting', or 'mentioning' based strictly on the sentence context. Store these classified citations in the 'citations' table with their respective intent tags and exact context snippets. Write an automated test suite with sample citation sentences to verify classification accuracy.
```

4. **Full-Text Hybrid Search & Vector Retrieval** — Develop a hybrid search engine combining Postgres full-text search (BM25 style via tsvector) and vector similarity search over paper chunks, enhanced with Cohere Rerank.

```
Implement a search service in lib/search/ that performs hybrid search across the ingested scholarly database. Combine PostgreSQL full-text search (tsvector on title, abstract, and chunks) with pgvector cosine similarity search. Pass the combined result set of top 50 matches through the Cohere Rerank API to re-order results by relevance. Expose this via a Next.js API endpoint /api/search supporting query filters by date range, author, and citation intent counts.
```

5. **Grounded RAG Assistant Chat Interface** — Build a conversational RAG assistant UI where users can ask research questions and receive answers strictly grounded in retrieved literature with inline verifiable citations.

```
Build a chat interface component using Tailwind CSS and shadcn/ui resembling a research assistant dashboard. Implement the corresponding API route at /api/assistant using Vercel AI SDK's streamText with Claude Sonnet. The backend must first query the hybrid search engine for relevant paper chunks, inject them into the system prompt with strict grounding instructions ('Only answer based on the provided literature; cite exact sentence IDs inline'), and stream the response back. Render inline citation badges that open a modal preview of the cited paper chunk and its Smart Citation status.
```

6. **Collections & Reference Manager Integration** — Add user collection management to save papers, organize them into folders, and provide a basic export format compatible with reference managers like Zotero (BibTeX / RIS).

```
Implement a collections system using better-auth for user session management. Create database tables for 'collections' and 'collection_papers'. Build a dashboard UI allowing users to create folders, save papers from search or assistant results, and view collection details. Add an export feature that generates BibTeX (.bib) and RIS format strings for any collection so users can import their saved papers directly into Zotero or Mendeley.
```

### Cost vs paying

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

- Custom domain (optional): $12 one-time
- AI API starting credits (Anthropic/OpenAI): $25 one-time
- Total: ~$37 one-time

**Ongoing costs (monthly):**

- Supabase Pro (Vector DB storage & compute): $25/mo
- Vercel / API usage (LLM embeddings & queries): $15/mo
- Total: ~$40/mo

- Paying for the SaaS instead: $20/mo to $50/mo
- Build time: 40-60 hours
- AI tool credits: $20 (Claude Code / Cursor Pro)
- Break-even: Never (paying is cheaper and gives access to 300M+ paywalled papers you cannot legally index)

## Sources

- [Scite Website - Home](https://scite.ai/)
- [Scite Pricing](https://scite.ai/pricing)