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

> Your personal research assistant

- Site: https://zotero.org
- Category: Reference Management & Research
- Platforms: macOS app, Windows app, Linux app, iOS app, Android app, Web app
- Verdict: **Serious undertaking** (35/100 vibecodeable)
- Estimated effort: 4-6 months of serious part-time work

## Verdict

You can build a personal document library and metadata scraper subset, but the massive ecosystem of site translators and cross-platform desktop integration will stall you.

Zotero has been built by a dedicated team over two decades. A solo developer can build a personal clone that stores references, extracts metadata via generic scrapers, parses PDFs, and formats simple citations. However, replicating the thousands of site-specific translators for academic publishers, the robust offline-first SQLite synchronization engine, and native word processor plugins represents a massive engineering undertaking.

### What you can't replicate

- The massive library of community-maintained site translators for paywalled journals
- Decades of institutional trust and standard academic workflow integration
- Seamless real-time plugins for Microsoft Word, Google Docs, and LibreOffice across all operating systems

## What it does

Zotero is a free, easy-to-use tool to help you collect, organize, annotate, cite, and share research.

### Core features

- Local SQLite document database with full-text search indexing
- Web browser extension metadata scrapers (translators)
- PDF and EPUB annotation engine with highlighting and notes
- Citation and bibliography generation supporting thousands of style formats
- Collection trees, tags, and saved smart searches
- Multi-device synchronization for database records and file attachments

## The business

### Pricing

- Free: Free
- 2 GB Storage: $20/year
- 6 GB Storage: $60/year
- Unlimited Storage: $120/year

### Funding

Millions (Grant-funded origin, self-sustaining via storage subscriptions) raised.
- Institutional grants from Andrew W. Mellon Foundation
- IMLS
- Alfred P. Sloan Foundation
Investors: Andrew W. Mellon Foundation, Alfred P. Sloan Foundation, US Institute of Museum and Library Services, George Mason University

Founded 2006.
Team size: Small core non-profit staff + global open-source community.

## The hard parts

- Maintaining thousands of brittle site-specific translation scrapers for academic paywalls and repositories
- Building robust native cross-platform desktop UI clients that manage thousands of massive PDF binaries
- Writing word processor plugins for Microsoft Word, LibreOffice, and Google Docs to handle dynamic citations
- Implementing safe multi-device database sync with conflict resolution and differential file attachments

## How to vibe code Zotero

### Prerequisites

- Node.js (free): Required for running the local build tooling and backend scripts.
- Rust & Tauri (free): Required for compiling the cross-platform native desktop application shell.
- GitHub (free): Repository hosting for source code version control.

### Recommended AI tools

- Claude Code: Best-in-class terminal agent for scaffolding complex multi-file TypeScript and Rust desktop architectures.
- Cursor: Essential for writing and refining React frontend components and SQLite interaction layers.

### Stack

- Frontend: React + TypeScript + Tailwind CSS inside a Tauri desktop shell
- Backend: Node.js local loopback server or embedded Rust backend commands
- Database: Local SQLite database via libSQL/better-sqlite3
- Auth: None (local-first personal software)
- Payments: None
- Other: pdf.js for local PDF rendering and text extraction, citeproc-js or equivalent CSL processor for bibliography formatting

### Hosting

- Cloudflare R2 (Optional remote object storage for personal PDF backups with zero egress fees): $0-5/mo

### Build guide

1. **Project Scaffolding & Tauri Desktop Shell** — Initialize a Tauri desktop project with a React and TypeScript frontend, configuring native window bindings, menus, and local file system access permissions.

```
Create a new Tauri desktop application using React, TypeScript, and Vite. Set up the project directory structure with modular folders for components, services, and database utilities. Configure Tauri permissions in tauri.conf.json to allow local file system access, local SQLite storage reading/writing, and clipboard interactions. Ensure the app builds successfully as a local desktop binary for macOS and Windows, and implement a clean layout with a sidebar navigation pane and a main item list view.
```

2. **Local SQLite Database Schema & Full-Text Search** — Design and implement the local SQLite schema to store items, collections, tags, notes, and file attachment paths, complete with FTS5 full-text search indexing.

```
Write the complete SQLite database initialization script using better-sqlite3 or libSQL. Define relational tables for items (with fields for item type, title, abstract, date, DOI, URL), creators (authors, editors), collections (hierarchical folders), item_collections junction table, tags, item_tags, notes, and attachments. Implement an FTS5 virtual table synchronized via triggers to enable lightning-fast full-text search across item titles, abstracts, notes, and PDF text contents. Write helper functions in TypeScript for CRUD operations on all entities.
```

3. **Metadata Scraper & Browser Extension Stub** — Build a local HTTP loopback server and a basic browser extension or DOM extraction utility to parse webpage metadata and ingest items into the database.

```
Implement a local HTTP server running on a background port within the desktop application that listens for incoming JSON payloads containing bibliographic metadata extracted from web pages. Create a Manifest V3 browser extension script containing scrapers for general HTML meta tags (Dublin Core, OpenGraph, Highwire Press tags) and arXiv. When the user clicks the extension icon, it parses the active page metadata and POSTs the structured item to the local desktop app loopback endpoint, which validates and saves it into SQLite.
```

4. **PDF Viewer, Annotation & Text Extraction** — Integrate pdf.js to render local PDF documents within the desktop app interface and support text highlighting, annotations, and linked notes.

```
Integrate pdf.js into a React component view within the Tauri application to render local PDF files selected from item attachments. Implement text selection, highlighting tools that store coordinate bounding boxes in SQLite, and a side panel for associating sticky notes and annotations with specific highlights. Ensure extracted text streams from the PDF are automatically indexed into the SQLite FTS5 search engine for comprehensive document searchability.
```

5. **Citation Style Processor (CSL) & Bibliography Export** — Integrate Citation Style Language (CSL) processing capabilities to format references and generate bibliographies in various academic styles.

```
Integrate citeproc-js or a robust TypeScript CSL formatting library into the application. Download standard citation style files (such as APA, Chicago, IEEE, MLA) and implement a formatting engine that takes selected item records from the SQLite database and outputs formatted inline citations and structured bibliographies. Create a user interface panel allowing users to preview and copy formatted bibliographies or export them directly to clipboard and rich text files.
```

6. **Collections, Tags, and Advanced Organization** — Build the organization interface supporting nested collections, keyword tagging, and smart saved searches.

```
Build the React sidebar component representing a hierarchical tree of collections and a tag cloud. Implement drag-and-drop or context menu actions to assign items to collections and apply keyword tags. Implement a saved searches feature that allows users to create dynamic smart collections based on stored SQL query rules or filter criteria (e.g., items tagged 'thesis' created after 2024), automatically updating the main item list view in real time.
```

### Cost vs paying

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

- AI Coding Assistant Subscriptions: $20
- Total: ~$20 one-time

**Ongoing costs (monthly):**

- Optional Cloud PDF Backup Storage: $0 - $5/mo
- Total: ~$0 - $5/mo

- Paying for the SaaS instead: $0 to $10/mo (Optional storage tiers)
- Build time: 80-120 hours
- AI tool credits: $20 (One month of Claude Pro / Cursor Pro)
- Break-even: Not applicable (Open-source alternative exists for free)

## Sources

- [Zotero Storage Pricing & Plans](https://www.zotero.org/support/storage)
- [Zotero About & History Documentation](https://www.zotero.org/support/about)
- [Zotero Credits & Third-Party Software Architecture](https://www.zotero.org/support/credits)
- [GitHub - Zotero Source Code & Connectors](https://github.com/zotero)
- [Wikipedia - Zotero Overview](https://en.wikipedia.org/wiki/Zotero)