paperswithcode-curator

*Date: August 7, 2026

Author: Tanvir

Category: RAG Systems, Personal Knowledge Hubs & Local LLMs*

TL;DR: Keeping up with modern machine learning research is exhausting. Reading the PDF is only half the battle—to understand if a paper actually matters, you need to see the official code, its popularity (GitHub stars), and how it ranks on global benchmarks. Realizing that existing ArXiv search engines strip out this crucial engineering context, I decided to build PWC-Curator—a self-hosted, glassmorphic splitscreen workspace that acts as a living curator for my research. In this post, I detail the layout parsing struggles of double-column academic papers, the mathematics behind a real-time keyword/semantic search slider, and how I deployed the system completely local-first on a standard self-hosted setup.

1. The Morning Ritual That Broke Me

Every single morning, I follow a familiar ritual: I open my browser, grab a coffee, and stare at the daily list of machine learning publications.

But over the past year, this routine has transformed from an exciting look at the future into a source of pure information anxiety. We are currently living through a scientific gold rush, but the sheer velocity of papers means that we are constantly drowning in PDF files we never have time to read.

Worse, I kept running into what I call The ArXiv Trap:

I would find a paper with an incredibly promising title.
I would spend 20 minutes reading the abstract and methodology.
Only to discover later that the code was never released, or the repository was abandoned, or the model’s benchmark claims fell apart when tested against real-world datasets.

That’s when I had an epiphany: An academic paper is not just an isolated PDF document. To evaluate a model’s true impact, you must analyze its entire ecosystem:

                  +---------------------------------------+
                  |         The Research Ecosystem        |
                  +---------------------------------------+
                                      |
       +------------------------------+------------------------------+
       |                              |                              |
       v                              v                              v
[Academic Text]              [Engineering Reality]         [Evaluation Standing]
- Core Methodology           - Official Repo URL           - Dataset Name
- Structural Chunks          - Live GitHub Stars           - Target Metric Value
- Formulas & Sections        - Frameworks (PyTorch/JAX)    - Global SOTA Rank

I didn’t want another simple PDF chatbot. I wanted a living knowledge catalog—a splitscreen workspace where I could bookmark papers, automatically pull their engineering footprints, and converse with my curated catalog with hyper-precise page references.

So, I built PWC-Curator.

2. Reimagining the Research Workflow: Active Curation

I wanted the ingestion process to feel active, satisfying, and completely seamless. Instead of uploading a local PDF manually, the core interaction in PWC-Curator centers around Active Curation:

Pasting a Link: I paste any Papers with Code URL (e.g., https://paperswithcode.com/paper/attention-is-all-you-need) or an ArXiv ID directly into my curation bar.
Scraping the Context: The backend uses BeautifulSoup to automatically scrape the page, extracting the repository link, current live GitHub stars, framework tags, associated machine learning tasks (like Machine Translation), and full evaluation tables.
Real-Time Progress Streams: Since downloading, parsing, and embedding a full PDF takes a few seconds, I built a simulated retro log console in the UI. Using Server-Sent Events (SSE), the backend streams active status messages directly to my screen (e.g., "[PARSER] Truncating Bibliography on Page 11..."), turning a boring wait time into an engaging, transparent feedback loop.

Once the stream finishes, the paper is added to my Curated Research Catalog as a sleek, interactive glassmorphic card—complete with neon framework tags and a live star count badge.

3. The Math Behind the Search Slider: Dual-Index Fusion

One of the major frustrations with standard vector search (Dense Retrieval) is that it is often too conceptual. If I search my database for a highly specific term—such as the hyperparameter name "AdamW" or the evaluation metric "Perplexity"—semantic embeddings can occasionally miss the exact keyword matches in favor of general optimization or language modeling themes.

To solve this, I designed a dual-index search engine that integrates Lexical (Sparse) and Semantic (Dense) indexing into a single, cohesive search bar:

The Lexical Index (BM25-Style): Powered by PostgreSQL GIN full-text search dictionaries. This ensures that exact key terms are retrieved with absolute precision.
The Semantic Index (Vector-Style): Powered by 768-dimensional local nomic-embed-text vectors stored in a pgvector column and queried via a high-speed HNSW index.

To balance these two search modes, I added a real-time search slider to my UI. Behind the scenes, the slider value ($w$) acts as an interpolation coefficient that merges lexical and semantic rankings on the fly:

\[S_{Combined}(c) = w \cdot (1.0 - S_{Dense}(c)) + (1 - w) \cdot \frac{S_{Sparse}(c)}{1 + S_{Sparse}(c)}\]

$S_{Dense}(c)$: Represents the cosine distance of the chunk’s embedding to the query vector.
$S_{Sparse}(c)$: Represents the text density search rank (ts_rank_cd) of the query terms inside the chunk.
$w \in [0, 1]$: The user’s slider weight. Shifting the slider left prioritizes exact keyword lookups; shifting it right expands the search into thematic, conceptual relationships.

This hybrid approach gives me total control over how I explore my curated library.

4. Taming the PDF Layout Nightmare

Double-column scientific paper PDFs are a formatting nightmare. Standard PDF-to-text libraries read text line-by-line across the entire page, merging adjacent columns together and producing unreadable paragraphs.

To prevent this layout destruction, I built a coordinate-aware parser using PyMuPDF:

Reading Order Reconstruction: The parser detects the vertical dividing margin of double-column grids, splitting each page into separate column bounding boxes before extracting text blocks.
Section Boundary Tracking: It monitors font sizes and bold styles, automatically detecting section headers (e.g., 3. Proposed Method) and associating each text paragraph with its respective chapter.
Bibliography Truncation: To keep irrelevant citation blocks from polluting my search space, the parser automatically detects the references section and trims it, keeping only the high-value core methodology.
Page-Mapped Citations: Every extracted paragraph preserves its exact page number, laying the foundation for hyper-precise page-level references inside our chat window.

5. Local Ingestion in Action: Testing the Pipeline

I deployed PWC-Curator entirely inside a containerized Docker network on my self-hosted environment (which can be a local machine, home server, or private cloud instance). The backend connects directly to a host-level Ollama daemon, running nomic-embed-text for vectors and llama3.1:8b for text generation.

When I curated the seminal paper Attention is All You Need, the live console log captured the entire structural ingestion process:

[SYSTEM] Starting real-time curation for paperswithcode.com attention-is-all-you-need...
[SCRAPER] Discovered official repo: https://github.com/tensorflow/tensor2tensor
[SCRAPER] Current stars: 12,450 | Frameworks: ['tensorflow', 'pytorch']
[SCRAPER] Discovered 2 SOTA benchmarks: WMT2014 English-to-German, WMT2014 English-to-French
[DOWNLOADER] Streaming PDF from https://arxiv.org/pdf/1706.03762...
[PARSER] Truncating Bibliography section on Page 11.
[PARSER] Reconstructed double-column layouts | Extracted 201 paragraphs.
[VECTORIZER] Embedded 201 chunks using nomic-embed-text in 4.2 seconds!
[DATABASE] Transaction complete. Saved 1 paper and 201 vector chunks.
[SYSTEM] Real-time ingestion completed successfully!

Now, when I ask my splitscreen chatbot:

User: “What were the BLEU score results on English-to-German translation?”

The local LLM retrieves the exact paragraph from page 7 and streams a precise answer:

Chatbot: The Transformer model achieved a state-of-the-art BLEU score of 28.4 on the WMT 2014 English-to-German translation task, outperforming the previous best ensemble models by over 2.0 BLEU [Source #1 (Section 5.1, Page 7)].

Clicking [Source #1 (Section 5.1, Page 7)] instantly pops open an elegant overlay window displaying the exact underlying text chunk, letting me double-check the LLM’s claims in real-time.

6. Making the Stack Portable

I wanted this system to be highly reusable—something any machine learning practitioner or developer could deploy on their own local machine or private cloud.

By containerizing the setup, I isolated the core components into three Docker services:

acr-postgres: Pre-loaded with the pgvector extension and custom text search indexes.
acr-backend: A fast, asynchronous FastAPI server running the scraper, PyMuPDF parser, and RAG prompt orchestrator.
acr-web-proxy: An Nginx container that acts as a reverse proxy, hosting the static glassmorphic frontend and routing API/SSE traffic seamlessly.

Anyone can clone the repository, run ollama pull nomic-embed-text and ollama pull llama3.1:8b, and spin up their own personal curator with a single command:

docker compose up -d --build

7. The Living Roadmap

Building PWC-Curator has completely transformed how I digest AI literature. It has turned research from a passive reading chore into an interactive, structured, and auditable learning experience.

As I continue to use the system, my roadmap for the future includes:

Codebase Querying: Letting the RAG agent fetch and analyze files from the paper’s official GitHub repository alongside the text chunks.
In-Browser PDF Scrolling: Integrating an interactive PDF sidebar that automatically scrolls to the exact cited page and coordinates when clicking a citation.
Multi-Paper Comparisons: Enabling the LLM to generate auto-synthesized comparisons across several papers in my catalog.

Check Out the Project

If you want to spin up your own research curator or explore the codebase, the project is fully open-source:

GitHub Repository: mailtotanvir/paperswithcode-curator
Detailed Setup Instructions: README.md