Reasoning-based RAG ◦ No Vector DB, No Chunking ◦ Context-Aware Retrieval ◦ Reads Like a Human
🌐 Website • 🖥️ Chat Platform • 🔌 MCP & API • 📖 Docs • 📝 Blog • ✉️ Contact
- [Aug '26] 🔥 PageIndex SDK:
pip install -U pageindexnow ships local mode: index, retrieve, and chat entirely on your machine with your own LLM key, or point the same client at PageIndex Cloud with an API key. - [Aug '26] ⚡ PageIndex Flash: tree structure generation from PDFs in seconds, with structure extracted heuristically from the document's own layout info instead of built by an LLM.
- Scale PageIndex to Millions of Documents: PageIndex File System is a file-level tree indexing layer that lets PageIndex reason over an entire corpus, not just a single document.
- PageIndex Chat: a human-like document analysis agent for long professional documents.
Are you frustrated with vector database retrieval accuracy for long and complex 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 turns to and reads the right section of a long report. Retrieval happens in two steps:
- Index: generate a tree-structure index for each document
- Retrieve: agentically search that tree with LLM reasoning
PageIndex is a vectorless, reasoning-based RAG engine that mirrors how humans read, delivering traceable, explainable, and context-aware retrieval, with no vector DBs or chunking.
| Vector RAG | PageIndex | |
|---|---|---|
| Index | vector index | tree index |
| Unit | fixed-size chunks | natural sections |
| Retrieval | semantic similarity search | LLM reasoning over the tree |
| Result | opaque, “vibe retrieval” | traceable to explicit references |
| Context | query embedding only | full context: conversation history, domain knowledge, etc. |
It is ideal for financial reports, legal documents, regulatory filings, technical manuals, medical literature, academic textbooks, and any other 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).
pip install -U pageindeximport os
from pageindex import PageIndexClient
os.environ["OPENAI_API_KEY"] = "your-openai-key"
client = PageIndexClient(
index="gpt-5.6-luna", # model to build the tree index
chat="gpt-5.6-sol", # model to search the tree
)
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)index=: a basic model is sufficient. The tree structure itself is extracted from the document layout without an LLM; the index model only summarizes and refines it, which a basic model does well.chat=: use the best model you can afford. The chat model searches the tree to retrieve information. See Query cost and accuracy.
See the SDK client usage guide to configure other models and more, or integrate PageIndex with your own agent.
To request inline page-level citations, pass a system message together with the question:
messages = [
{"role": "system", "content": """Cite only statements supported by tool outputs
using <cite doc="{docName}" page="{pageNumber}"/>"""},
{"role": "user", "content": "Summarize the document."},
]
answer = client.chat(messages, doc_id=doc_id)The model fills in the document name and page number, for example:
Revenue increased during the reporting period. <cite doc="report.pdf" page="12"/>
Two ways to use PageIndex: (a) directly through the SDK client, or (b) integrate it into your own agent.
End to end in three steps: set up, index, ask. Expand a step below for its full options.
⚙️ Step 1: Initialize the client
Create a local client and choose the models used for indexing and retrieval:
from pageindex import PageIndexClient
import os
client = PageIndexClient(
index_model="gpt-5.6-luna",
chat_model="gpt-5.6-sol",
storage_path=".pageindex",
)-
index_modelbuilds the tree index. A basic model is sufficient. -
chat_modelsearches the tree and answers questions. Use the best model you can afford. -
storage_pathspecifies where indexed documents are stored locally.
index_model= / chat_model= are the flat spellings of the quickstart's index= / chat=; either spelling works.
Model names follow LiteLLM's naming convention. Choose the format that matches your provider:
OpenAI: use the model name directly and set OPENAI_API_KEY:
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
chat_model = "gpt-5.6-sol"Anthropic: prefix the model name with anthropic/ and set ANTHROPIC_API_KEY:
os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-api-key"
chat_model = "anthropic/claude-sonnet-4-6"OpenRouter: prefix the provider and model name with openrouter/ and set OPENROUTER_API_KEY:
os.environ["OPENROUTER_API_KEY"] = "your-openrouter-api-key"
chat_model = "openrouter/anthropic/claude-sonnet-4-6"For model names and API key settings for other providers, see the LiteLLM provider documentation.
🌲 Step 2: Build the tree index
submit_document defaults to PageIndex 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 indexedA PageIndex tree looks like a table of contents optimized for LLMs and agents:
See more example documents and generated tree structures.
💬 Step 3: 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:
Get a simple answer with chat():
client.chat("What changed in the risk factors?", doc_id=doc_id)Pass a string or role/content history and get the answer back.
Stream the answer:
client.chat("...", doc_id=doc_id, stream=True)Returns the answer as text chunks.
Use the OpenAI Chat Completions format:
client.chat_completions(messages, doc_id=doc_id)Returns the full envelope, including token usage, streaming metadata, and finish_reason.
Use the OpenAI Responses format:
client.responses("...", doc_id=doc_id, reasoning={"effort": "high"})Returns the agent's process transcript in items. Append those items to the next call's input to preserve memory and benefit from provider prompt caching. This requires a Responses-compatible backend in local mode.
Use the Anthropic Messages format:
client.messages("...", model="claude-sonnet-4-6", doc_id=doc_id)Uses Anthropic's native Messages API and tool runner. Install it with pip install 'pageindex[anthropic]'.
Pass a list of ids to doc_id to search several documents at once, and keep it identical across a conversation's calls.
PageIndex can also be integrated into your own agent. Each example below covers a different framework:
OpenAI Agents SDK
Ships with the SDK, no extras needed:
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.")
print(result.final_output)openai_agent_config() returns the instructions and tools an Agent needs. To use your own prompt or pick tools yourself, assemble the pieces directly:
agent = Agent(
name="PageIndex",
instructions=client.agent_instructions(doc_id=doc_id), # or your own prompt
tools=client.as_openai_tools(doc_id=doc_id), # include_management=True adds deletion
model=client.chat_model, # local clients only
)Anthropic SDK tool runner
Install with pip install 'pageindex[anthropic]':
import anthropic
runner = anthropic.Anthropic().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."}],
)
final = runner.until_done()
print(final.content[-1].text)anthropic_runner_config() fills every tool_runner slot except messages. The explicit form:
runner = anthropic.Anthropic().beta.messages.tool_runner(
model="claude-sonnet-4-6",
max_tokens=8192,
system=client.agent_instructions(doc_id=doc_id),
tools=client.as_anthropic_tools(doc_id=doc_id), # asynchronous=True for AsyncAnthropic
max_iterations=10,
messages=[{"role": "user", "content": "Summarize the auditor's concerns."}],
)Claude Agent SDK
Install with pip install 'pageindex[claude]'. The Claude Agent SDK is async-native:
from claude_agent_sdk import ClaudeAgentOptions, ResultMessage, query
options = ClaudeAgentOptions(**client.claude_agent_config(doc_id=doc_id))
async for message in query(prompt="Summarize the auditor's concerns.", options=options):
if isinstance(message, ResultMessage):
print(message.result)claude_agent_config() supplies the system prompt, the PageIndex MCP server, and its tool pre-approval. The explicit form:
options = ClaudeAgentOptions(
system_prompt=client.agent_instructions(doc_id=doc_id),
mcp_servers={"pageindex": client.as_claude_mcp(doc_id=doc_id)},
allowed_tools=["mcp__pageindex"],
)Other agent frameworks
tools = client.agent_tools(doc_id=doc_id) # plain functions returning JSONagent_tools() returns plain Python functions that work with LangChain, PydanticAI, and any other agent framework.
Every helper above accepts doc_id= to point the agent at specific documents and include_management=True to also expose document deletion (off by default). Locally, doc_id is enforced at the tool layer, not just prompted: out-of-scope lookups return NOT_FOUND.
Building a tree locally runs about $0.001 per page with gpt-5.6-luna as the index model, so a 1,000-page textbook costs a little over a dollar and a few minutes, once, and every later question reuses it. PageIndex is designed not to rely heavily on the model used at index time, so in our experiments a basic model does not hurt quality.
Indexing time also scales predictably with document length. In the same local setup, the benchmark documents (9 to 1,098 pages) finished in roughly 13 seconds to 4.5 minutes.
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 reached a state-of-the-art 98.7% accuracy on FinanceBench (financial document QA benchmark), vastly outperforming vector-based RAG.
探索 the full FinanceBench evaluation results and the blog post.
The open-source version is ideal for text-heavy PDFs and local workflows. With PageIndex Cloud, document indexing and storage run in the cloud: PageIndex handles parsing, OCR, image understanding, tree-index construction, and managed storage for you. The chat and retrieval layer remains compatible with your model, so you can search the cloud-hosted index using the model provider your application already uses.
Moving indexing and storage from Local to Cloud only requires a PageIndex API key:
import os
from pageindex import PageIndexClient
os.environ["PAGEINDEX_API_KEY"] = "your-pageindex-key"
os.environ["OPENAI_API_KEY"] = "your-openai-key"
client = PageIndexClient(
index="cloud", # build and store the index in PageIndex Cloud
chat="gpt-5.6-sol", # use your preferred compatible model for chat
)
# The rest of your code stays the same (wait=True: cloud indexing is asynchronous)
doc_id = client.submit_document("report.pdf", wait=True)["doc_id"]
print(client.chat("What was the 2023 operating margin?", doc_id=doc_id))| Capability | Local (this repo) | Cloud (get an API key) |
|---|---|---|
| Best for | text-heavy PDFs and local workflows | scanned, image-heavy, and large document collections |
| Indexing | runs locally | runs in PageIndex Cloud, with production OCR and image understanding |
| Storage | local | managed in PageIndex Cloud |
| Chat model | your model | your model, or the managed chat included with your key |
| Citations | page-level | line-level |
| Image understanding | — | ✅ |
| Multi-document scale | manual | PageIndex File System |
| MCP server | — | ✅ |
- Scale PageIndex to Millions of Documents: PageIndex File System is a Cloud-only, file-level tree indexing layer that lets PageIndex reason over an entire corpus, not just a single document.
- Get a PageIndex API key
- Read the PageIndex Cloud documentation
For dedicated deployment (VPC or on-premises), contact us or book a demo.
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.
Or use the BibTeX citation.
@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},
}
© 2026 Vectify AI
{ "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 ..." } ] }