PageIndex: Vectorless, Reasoning-based RAG

Reasoning-based RAG  ◦  No Vector DB, No Chunking  ◦  Context-Aware Retrieval  ◦  Reads Like a Human

🌐 Website  •   🖥️ Chat Platform  •   🔌 MCP & API  •   📖 Docs  •   💬 Discord  •   ✉️ Contact 

pip install pageindex
export OPENAI_API_KEY=...        # your own LLM key — PageIndex runs on it

from pageindex import PageIndexClient

client = PageIndexClient()                                  # local mode
doc_id = client.submit_document("report.pdf")["doc_id"]     # build the tree index
print(client.chat("What was the 2023 operating margin?", doc_id=doc_id))

No vector DB, no chunking, no embedding model — the whole thing runs on your machine, calling your own LLM provider. Jump to the quickstart ↓

📑 What is PageIndex?

Are you frustrated with vector database retrieval accuracy for long professional documents? Vector-based RAG retrieves by semantic similarity. But similarity ≠ relevance — what retrieval actually needs is relevance, and relevance requires reasoning. On professional documents that demand contextual understanding, domain expertise, and multi-step reasoning, similarity search misses what is relevant but not similar, and returns what is similar but not relevant.

Inspired by AlphaGo, PageIndex replaces the vector index with a hierarchical tree index and lets an LLM reason its way through it — the way a human expert flips to the right section of a long report. Retrieval happens in two steps:

1. Index — turn the document into a “table-of-contents” tree structure
2. Retrieve — search that tree with LLM reasoning, agentically

🎯 Why it works

PageIndex is a vectorless, reasoning-based RAG engine that mirrors how humans read, delivering traceable, explainable, and context-aware retrieval, without vector databases or chunking.

It is ideal for financial reports, legal documents, regulatory filings, technical manuals, medical literature, academic textbooks — any long, complex professional document.

PageIndex achieved state-of-the-art 98.7% accuracy on FinanceBench (financial document QA benchmark), vastly outperforming vector-based RAG — see Benchmarks.

⚡ Quickstart

1. Install

pip install pageindex

Local mode and the agent surfaces below require pageindex >= 0.2.10. Python 3.10+.

2. Set your LLM key

Local mode needs your own LLM provider key — PageIndex calls it both to index (node summaries) and to answer. Export it, or put it in a .env file next to your script:

export OPENAI_API_KEY=your_openai_key_here

# .env
OPENAI_API_KEY=your_openai_key_here

Any provider LiteLLM supports works — set that provider's key (ANTHROPIC_API_KEY, …) and pass a provider-prefixed model name (anthropic/claude-sonnet-4-6, bedrock/…). For a self-hosted OpenAI-compatible server (vLLM, TGI, Ollama), point OPENAI_BASE_URL at it and set OPENAI_API_KEY to whatever token it expects.

This is not a PageIndex key — local mode never talks to our servers. A PageIndex API key is only for cloud mode, where the managed LLM is included.

3. Index a document, then ask

from pageindex import PageIndexClient

client = PageIndexClient(                     # local mode — uses OPENAI_API_KEY
    index_model="gpt-5.6-luna",               # builds the tree: a cheap model is enough
    chat_model="gpt-5.6-sol",                 # answers questions: this is what drives accuracy
)
doc_id = client.submit_document("report.pdf")["doc_id"]

answer = client.chat("What was the 2023 operating margin, and where is it stated?",
                     doc_id=doc_id)
print(answer)

Those two are also the defaults, so PageIndexClient() on its own gives you the same thing — but the two roles are worth naming, because the rule of thumb is spend on the chat model, not the index model:

• index_model — a weak model is fine. Flash reads the hierarchy out of the PDF's own layout, so the model is not inventing the structure; it only writes the node summaries. Dropping to a cheaper model barely changes the tree, and it is a one-off cost per document either way.
• chat_model — use the best you can afford. This is the model that reasons over the tree, decides what to open, and reads the pages. It is where accuracy actually comes from, and it is billed per question (see Benchmarks).

What just happened:

• submit_document parsed the PDF and built its tree index, stored under ./.pageindex. Indexing is synchronous and one-off — later questions reuse the same doc_id.
• chat ran a document-QA agent over that tree: it read the table of contents, reasoned about which sections could hold the answer, opened only those pages, and answered from them.
• The answer is grounded in real sections and page numbers, so you can check it.

Or use PageIndex Cloud

Same client, same methods — pass an API key and the work happens on our servers, with the production OCR, tree-building, and retrieval pipeline behind it:

client = PageIndexClient(api_key="pi-...")
doc_id = client.submit_document("report.pdf", wait=True)["doc_id"]
print(client.chat("What was the 2023 operating margin?", doc_id=doc_id))

🛠️ Using PageIndex

🌲 Step 1: Build the tree index

submit_document defaults to Flash indexing: the structure is extracted from the PDF's own layout (no LLM), and a model is called only for node summaries and the tree-optimization expansion pass. It takes seconds.

doc_id = client.submit_document("report.pdf")["doc_id"]

Inspect what you got:

tree = client.get_document_structure(doc_id)    # titles, page ranges, summaries — no text
client.list_documents()                         # everything you have indexed

A PageIndex tree looks like this — a table of contents optimized for LLMs and agents:

{
  "title": "Financial Stability",
  "node_id": "0006",
  "start_index": 21,
  "end_index": 22,
  "summary": "The Federal Reserve ...",
  "nodes": [
    {
      "title": "Monitoring Financial Vulnerabilities",
      "node_id": "0007",
      "start_index": 22,
      "end_index": 28,
      "summary": "The Federal Reserve's monitoring ..."
    },
    {
      "title": "Domestic and International Cooperation and Coordination",
      "node_id": "0008",
      "start_index": 28,
      "end_index": 31,
      "summary": "In 2023, the Federal Reserve collaborated ..."
    }
  ]
}

See more example documents and generated tree structures.

client = PageIndexClient(
    index_model="gpt-5.6-luna",              # tree: node summaries + expansion pass
    chat_model="anthropic/claude-sonnet-4-6",# answering, on another provider
    storage_path=".pageindex",               # where indexed documents live
)

from pageindex import page_index_flash, page_index

result = page_index_flash("report.pdf")        # heuristic structure + LLM summaries
result = page_index("report.pdf")              # full LLM-built tree

python3 run_pageindex.py --pdf_path /path/to/your/document.pdf
python3 run_pageindex.py --md_path  /path/to/your/document.md   # markdown, by "#" heading level

--mode                  Processing mode: flash (default) or standard
--index-model           LLM model used to index the document (default: gpt-5.6-luna)
--optimize              Tree optimization for retrieval: full (default), merge, or off
--toc-check-pages       Pages to check for table of contents (default: 20)
--max-pages-per-node    Max pages per node (default: 10)
--max-tokens-per-node   Max tokens per node (default: 20000)
--if-add-node-id        Add node ID (yes/no, default: yes)
--if-add-node-summary   Add node summary (yes/no, default: yes)
--if-add-doc-description Add doc description (yes/no, default: yes)

💬 Step 2: Ask questions

chat() is the one-line surface. Underneath it is a document-QA agent, and you can talk to it over whichever protocol your stack already speaks:

client.chat("What changed in the risk factors?", doc_id=doc_id)            # → answer string
client.chat(question, doc_id=doc_id, stream=True)                          # → text chunks
client.chat_completions(messages, doc_id=doc_id)                           # OpenAI Chat Completions envelope
client.responses("...", doc_id=doc_id, reasoning={"effort": "high"})       # OpenAI Responses (agentic)
client.messages("...", model="claude-sonnet-4-6", doc_id=doc_id)           # Anthropic Messages

• chat — sugar over chat_completions: pass a string or a role/content history, get the answer back.
• chat_completions — the same engine with the full envelope: token usage, streaming metadata, finish_reason.
• responses — the agentic surface. The whole process transcript (including tool outputs) rides in items; append it to your next call's input to keep the agent's memory and the provider's prompt cache warm. Local mode, Responses-capable backends.
• messages — Claude-native, via the Anthropic SDK's tool runner (pip install 'pageindex[anthropic]'). Local mode.

Pass a list of ids to doc_id to search several documents at once, and keep it identical across a conversation's calls.

🤖 Step 3: Put PageIndex inside your own agent

Instead of calling PageIndex's agent, hand PageIndex's tools to yours. One call fills every slot:

# OpenAI Agents SDK
from agents import Agent, Runner
agent = Agent(**client.openai_agent_config(doc_id=doc_id))
result = Runner.run_sync(agent, "Summarize the auditor's concerns.")

# Anthropic SDK tool runner            (pip install 'pageindex[anthropic]')
runner = anthropic_client.beta.messages.tool_runner(
    **client.anthropic_runner_config(model="claude-sonnet-4-6", doc_id=doc_id),
    messages=[{"role": "user", "content": "Summarize the auditor's concerns."}],
)

# Claude Agent SDK                     (pip install 'pageindex[claude]')
options = ClaudeAgentOptions(**client.claude_agent_config(doc_id=doc_id))

# Anything else — plain Python functions for LangChain, PydanticAI, ...
tools = client.agent_tools()

Each *_config helper is sugar over the explicit pieces — client.agent_instructions() for the system prompt and client.as_openai_tools() / as_anthropic_tools() / as_claude_mcp() for the tools — so you can swap in your own prompt whenever you need to. Locally, doc_id is enforced at the tool layer, not just prompted: out-of-scope lookups return NOT_FOUND.

python3 examples/agentic_vectorless_rag_demo.py

☁️ Local or Cloud

The same PageIndexClient runs both. Omit api_key for local, pass one for cloud.

PageIndexCloudClient / PageIndexLocalClient pin the mode explicitly if you would rather not infer it from api_key.

The cloud service is also available as a ChatGPT-style chat platform, or via MCP and API. For dedicated or private deployment (VPC, on-prem), contact us or book a demo.

📊 Benchmarks

What indexing costs

Building a tree locally runs about $0.001 per page with index_model="gpt-5.6-luna" — so a 1,000-page textbook costs a little over a dollar and a few minutes, once, and every later question reuses it. Measured over nine PDFs, from a 9-page whitepaper to a 1,098-page textbook, 2,800 pages in total.

The index model is not the bottleneck. PageIndex is designed not to rely heavily on the model used at index time, so in our experiments a cheap model does not hurt quality.

Open-source PageIndex, running locally

PageIndex-OSS-Benchmark measures exactly the setup in the quickstart above — PageIndexClient() in local mode, flash indexing, no OCR — on 62 lookup questions over 34 PDFs (1,945 pages) drawn from MMLongBench-Doc-V2. Every question's answer is a fact stated in running text, so a wrong answer is a retrieval or reading failure, not a reasoning one.

Full results, data, and the runner are in the benchmark repo.

PageIndex leads a finance QA benchmark

Mafin 2.5, a reasoning-based RAG system for financial document analysis powered by PageIndex, reached a state-of-the-art 98.7% accuracy on FinanceBench, far ahead of vector-based RAG systems on SEC filings and earnings disclosures.

Explore the full benchmark results and the blog post.

🧭 Resources

• 📝 Blog: technical articles, research insights, and product updates.
• 🔧 Developer: MCP setup, API docs, and integration guides.
• 🧪 Cookbooks: hands-on, runnable examples and advanced use cases — try the Vectorless RAG and the OCR-free, vision-based Vision RAG notebooks in Colab.
• 📖 Tutorials: practical guides and strategies, including Document Search and Tree Search.

⭐ Support Us

Leave us a star 🌟 if you like our project. Thank you!

Please cite this work as:

Mingtian Zhang, Yu Tang and PageIndex Team,
"PageIndex: Next-Generation Vectorless, Reasoning-based RAG",
PageIndex Blog, Sep 2025.

@article{zhang2025pageindex,
  author = {Mingtian Zhang and Yu Tang and PageIndex Team},
  title = {PageIndex: Next-Generation Vectorless, Reasoning-based RAG},
  journal = {PageIndex Blog},
  year = {2025},
  month = {September},
  note = {https://pageindex.ai/blog/pageindex-intro},
}

🌐 Open-Source Ecosystem

PageIndex anchors a growing open-source ecosystem of long-context AI infra — OpenKB is an LLM knowledge base that compiles documents into an interlinked wiki. ChatIndex provides tree indexing and retrieval for long conversational histories and memory. ConDB is a KV-cache native context database for tree-based retrieval at scale. PageIndex MCP is PageIndex's MCP server.

Connect with Us

© 2026 Vectify AI