PixelRAG is the official open-source codebase for the paper "PIXELRAG: Web Screenshots Beat Text for Retrieval-Augmented Generation," an Apache-2.0 Python project from Berkeley SkyLab, BAIR and Berkeley NLP that renders web pages, PDFs and images to screenshot tiles and retrieves over those images instead of parsed text, built for RAG engineers, agent developers and researchers who need tables, charts, diagrams and layout to survive retrieval.

What it is

PixelRAG lives in the retrieval-augmented generation ecosystem and exposes two core operations: render a page to screenshots, and search a visual index. Instead of parsing a document into text chunks, it renders documents as screenshots and retrieves over the images directly. Visual structure that HTML parsing throws away — tables, charts, layout, infographics — stays intact, so the reader model can answer questions about it. Wikipedia's 8.28M articles ship as a pre-built index, while the pipeline itself is described as general-purpose. Rendering is handled by the standalone pixelshot command, and embedding by a Qwen3-VL-Embedding model that is LoRA-fine-tuned on screenshot data.

The concrete problem is the one text-based RAG hits constantly: the page is parsed to text chunks and the table is lost, so the reader model cannot find the answer. PixelRAG renders the page to screenshot tiles, retrieves the right tile, and the reader reads the number straight off the image. It therefore replaces the HTML-to-text parsing front end of a RAG pipeline, in Python, in the AI development platform space. Its topics — agent, ai, memory, multimodal, rag, search, searchengine, vision, vlm — describe that position accurately.

Key capabilities

• pixelshot renders any page or document to screenshot tiles, for example pixelshot https://en.wikipedia.org/wiki/Python --output ./tiles, using Playwright/CDP on the local machine.
• A live hosted search endpoint at https://api.pixelrag.ai/search serves a pre-built index of 8.28M Wikipedia pages with no setup and no API key, taking a queries array and an n_docs count.
• The hosted endpoint accepts an image as the query, enabling visual search, alongside ordinary text queries.
• A Qwen3-VL-Embedding model, LoRA-fine-tuned on screenshot data, embeds page images into a space where visual content is retrievable.
• The pixelrag umbrella command exposes the full pipeline, and stages can be installed individually rather than all at once.
• A Claude Code plugin, the pixelbrowse skill, lets Claude screenshot a page with pixelshot and read the image instead of fetching raw HTML, with no MCP server and no backend.
• The same screenshot tool is available to opencode users through the @startrail/pixelbrowse npm package, configured in opencode.json.

Who uses it and how

• Teams building RAG over visually dense sources such as financial tables, infographics and scanned or image-heavy pages, where the answer lives in the pixels rather than the text layer.
• Claude Code users who install the pixelbrowse skill and ask Claude to screenshot a page and summarize it, for example claude -p "screenshot https://news.ycombinator.com and summarize the top stories", or run /screenshot https://example.com interactively.
• opencode users who add @startrail/pixelbrowse to their plugin list and get the same screenshot tool with pixelshot on PATH.
• Developers evaluating retrieval quality without infrastructure: the browser demo at pixelrag.ai and the Colab notebook demos/quickstart.ipynb render a page and search the hosted index with images inline.
• Researchers reproducing or extending the paper's results, with pixelshot usable as a standalone capture step in their own pipelines.

Getting started

Install the package with pip install pixelrag, or isolate the CLI while keeping pixelshot on PATH with uv tool install pixelrag or pipx install pixelrag. Search against the hosted 8.28M-page Wikipedia index immediately by POSTing to https://api.pixelrag.ai/search, or try it in the browser at pixelrag.ai.

How it compares

The facts provided name no paid products that PixelRAG replaces, and they name no comparable open-source tool either, so on the evidence available it stands alone in this registry. Its distinguishing property is architectural rather than commercial: it retrieves over rendered images rather than parsed text, which is a different retrieval substrate from the text-chunk pipelines that dominate the rag topic. The licence is Apache-2.0, so the code itself carries no cost model beyond the compute used to render, embed and index documents.

When to use it — and when not to

A self-hoster must operate headless browser rendering through Playwright/CDP for pixelshot, and for any corpus other than the hosted Wikipedia index must run the embedding and index-building stages, including the Qwen3-VL-Embedding model, which makes this heavier than a text-chunk pipeline. It is a poor fit for teams whose answers live entirely in plain text and who want the cheapest possible retrieval, or for environments that cannot run a headless browser. Note also that the README excerpt supplied here is truncated inside the pipeline-stage table, and the underlying work is an arXiv preprint rather than a peer-reviewed publication, so the per-stage install instructions and the paper's claims should be checked against the repository itself.

pip install pixelrag

# Render any page or document to screenshot tiles
pixelshot https://en.wikipedia.org/wiki/Python --output ./tiles

# Search a hosted index of 8.28M Wikipedia pages — no setup, runs against the live API
curl -X POST https://api.pixelrag.ai/search \
  -H "Content-Type: application/json" \
  -d '{"queries": [{"text": "What is the capital of France?"}], "n_docs": 5}'

uv tool install pixelrag                            # pixelshot on PATH (or: pipx install pixelrag)
claude plugin marketplace add StarTrail-org/PixelRAG
claude plugin install pixelbrowse@pixelrag-plugins

claude -p "screenshot https://news.ycombinator.com and summarize the top stories"
claude -p "screenshot https://arxiv.org/abs/2404.12387 and explain the key findings"

{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["@startrail/pixelbrowse"]
}

render ←── index ──→ embed       serve (independent)       train → serve (HTTP)

pip install 'pixelrag[serve]'

# Download a pre-built index from Hugging Face. The dataset repo holds four FAISS indexes
# (base/LoRA Wikipedia pixel, Wikipedia text, news pixel); grab just the base one (~217G) here.
huggingface-cli download StarTrail-org/pixelrag-faiss-indexes \
  --repo-type dataset --include "search_index_normed_v2/*" --local-dir ./index

# Serve, then query
pixelrag serve --index-dir ./index/search_index_normed_v2 --port 30001

curl -X POST http://localhost:30001/search \
  -H "Content-Type: application/json" \
  -d '{"queries": [{"text": "What is the capital of France?"}], "n_docs": 5}'

pip install 'pixelrag[index]'

# Create pixelrag.yaml
cat > pixelrag.yaml << 'EOF'
source:
  type: local
  path: ./my_docs

embed:
  model: Qwen/Qwen3-VL-Embedding-2B
  device: auto          # cuda on Linux, mps on macOS, cpu as fallback

output: ./my_index
EOF

# Build, then serve
pixelrag index build
pixelrag serve --index-dir ./my_index --port 30001

pip install 'pixelrag[index,pdf]'

## 1. Grab a sample PDF (or use your own)
curl -L -o paper.pdf https://raw.githubusercontent.com/StarTrail-org/PixelRAG/main/assets/pixelrag-paper.pdf

## 2. Create config (device: auto picks MPS on Mac, CUDA on Linux)
cat > pixelrag.yaml << 'EOF'
source:
  type: local
  path: ./paper.pdf

embed