The maintainer has not written a description at the source.
Repo VectifyAI/pageindex-search-python, read from GitHub 1 min ago. VectifyAI has not joined Take My Repo.
VectifyAI/pageindex-search-python is a public repo on GitHub by VectifyAI. It declares the MIT license on GitHub. It is written mainly in Python, has 1 stars and last changed on 2026-11-06. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-18.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Python client for Page Search API by PageIndex. Upload a PDF, ask up to 10 questions at once, and get back the pages that answer each one, ranked by relevance. Every page is read.
pip install pageindex-search
Create an API key in the console and set it:
export PAGEINDEX_SEARCH_API_KEY=pis_live_...from pageindex_search import PageSearch client = PageSearch() doc = client.documents.upload("3M_2018_10K.pdf") result = client.search(["What was capital expenditure in 2018?", "Who is the CEO?"], document=doc) for answer in result.results: print(answer.question) for page in answer.pages: print(f" page {page.page}: {page.relevance}") print(f"cost ${result.usage.cost_usd}, credit left ${result.usage.balance_usd}")
Upload a document once and search it as often as you like; uploading the same file again returns the same document. Documents are kept until you delete them:
for doc in client.documents.list(): # every document, newest first, a page at a time print(doc.id, doc.filename, doc.pages) client.search(["What was revenue in 2018?"], document="doc_60a07bcef3094b68806070f2") # search one again by its id client.documents.delete("doc_60a07bcef3094b68806070f2")
With many documents, search across them: the documents likely to answer are found first, then their pages.
result = client.search("What was capital expenditure in 2018?") # every document of yours for doc in result.results[0].documents: print(doc.filename, [(p.page, p.relevance) for p in doc.pages])
To find only which documents answer, use client.documents.search.
Group documents into collections, and search within one:
reports = client.collections.create("Annual reports") client.documents.upload("3M_2018_10K.pdf", collection=reports) # or later: client.collections.add(reports, [doc]) result = client.search("What was capital expenditure in 2018?", collection=reports)
A document may be in many collections; deleting a collection leaves its documents.
Give documents your own metadata (strings, numbers and booleans) and filter by it:
doc = client.documents.upload("3M_2018_10K.pdf", metadata={"ticker": "MMM", "year": 2018}) client.documents.update(doc, metadata={"audited": True}) # None removes a key recent = client.documents.list(filter={"year": {"$gte": 2020}}) result = client.search("Who is the CEO?", filter={"ticker": {"$in": ["MMM", "AAPL"]}})
Filters take $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $and and $or.
Read pages: their text, or a page as a picture. Each page a search lists says how it is best read (page.read:
"text", or "image" for a scan or a chart, whose text may be incomplete); include_text=True lists it with its
text.
texts = client.documents.pages(doc, [38, 39]) # each with .text and .read png = client.documents.page_image(doc, 38) # PNG bytes part = client.documents.page_image(doc, 38, box=(0, 0.3, 1, 0.6)) # a band of it, sharper
client.tools() gives an LLM agent seven tools over your documents: list_collections (free: your collections, to search one the
question names), list_documents (free: documents whose metadata
meets a filter, with your metadata's keys and values in its description, so the agent can write filters),
search_documents (which documents answer a question, for when a filter cannot pick them), search_pages (with each
page's text),
read_pages (text, with a picture of any page that is one), view_pages (pages as pictures) and zoom_page
(part of a page, sharper, for small print). When there are outlines to read (the collection makes them, or some of
your documents have theirs), an eighth: get_document_outline (free: every heading and its page, one page a line), with
which the agent finds the main parts by the outline and the mentions scattered elsewhere by search.
tools = client.tools(collection=reports) # or filter=..., or neither for all your documents response = anthropic.messages.create(model=..., tools=tools.definitions, messages=messages) for block in response.content: if block.type == "tool_use": content = tools.run(block.name, block.input).anthropic() # the tool_result content
For OpenAI, pass tools.openai; tools.run() gives .text and .images, each image with .data_url. With the
OpenAI Agents SDK (pip install "pageindex-search[agents]"), tools.openai_agents() gives the tools ready to use:
from agents import Agent, Runner agent = Agent(name="Reports", instructions="Answer from the documents.", tools=tools.openai_agents()) print(Runner.run_sync(agent, "What was capital expenditure in 2018?").final_output)
An outline lists every heading in a document and the page it is on. Turn outlines on for a collection, and its documents get theirs, as does each one added after; each is made once, paid by its pages (see pricing). The agent's tools for that collection then read them.
client.collections.outlines(reports, on=True) # its documents' outlines are made, a minute or two each print(client.documents.outline(report)) # p.12 Outlook | Group financial targets # p.13 Who we are | Our strategy | ... tools = client.tools(collection=reports) # with get_document_outline
documents.make_outline(document) makes one document's, whatever its collection.
The same tools work in Claude Desktop, Cursor and other MCP clients. Add this to the client's MCP settings:
{
"mcpServers": {
"page-search": {
"command": "uvx",
"args": ["--from", "pageindex-search[mcp]", "pageindex-search-mcp", "--collection", "col_..."],
"env": {"PAGEINDEX_SEARCH_API_KEY": "pis_live_..."}
}
}
}Leave out --collection for all your documents, or pass --filter '{"year": 2024}' for those whose metadata meets it.
In Python, tools.mcp() gives the server to run yourself.
Add CITATIONS to the agent's instructions, and it cites each sentence with <cite doc="report.pdf" page="12"/>;
with CITATIONS_WITH_BOXES, also box="x0,y0,x1,y1", the part of the page the answer is in (the agent looks at each
page it cites, for a few seconds more). client.citations(answer) finds them:
from pageindex_search import CITATIONS_WITH_BOXES instructions = "Answer only from the documents. " + CITATIONS_WITH_BOXES for c in client.citations(answer): png = client.documents.page_image(c.document_id, c.page, box=c.box) # the page, or that part of it
PageSearch(api_key=None, base_url=None, timeout=120, max_retries=2) |
The key defaults to PAGEINDEX_SEARCH_API_KEY. |
documents.upload(file, collection=None, metadata=None, wait=True) |
A path, bytes or an open file. Returns a Document, ready to search unless wait=False. |
search(questions, document=None, documents=None, collection=None, filter=None, max_documents=None, document_top_k=None, top_k=None, include_text=False, start_page=None, end_page=None, idempotency_key=None) |
Up to 10 questions. For each, the pages that help, under the documents they are in: of one document, or across documents (those named, a collection's, those meeting filter, or all), whose most relevant are opened: those likely to answer, at most max_documents (default 3), or exactly document_top_k. Each document lists the pages likely to help, or exactly top_k, each with how it is best read, and with include_text, its text; without top_k, more_pages lists the next most relevant, without text. With one document, start_page and end_page (from 1, included) search only those pages, and are charged only for them. A search retried after a timeout is not charged twice. |
documents.search(questions, document_ids=None, collection=None, filter=None, top_k=None, idempotency_key=None) |
Up to 10 questions of your documents (all of them, up to 1,000, those named, or a collection's). Each answer lists the documents likely to hold it, which may be none, or exactly top_k; without top_k, more_documents lists the next most relevant. Each document is priced at the document search price. |
documents.list(limit=20, offset=0, collection=None, filter=None) |
Your documents, newest first, or a collection's, or those whose metadata meets filter: limit of them after the first offset. Loop over it for every document; .data, .has_more and .total (how many in all) are one page. |
documents.get(id), documents.delete(document) |
One document; delete one. |
documents.pages(document, pages=None, start=None, end=None), documents.page_image(document, page, box=None) |
The text of up to 50 pages, each with how it is best read: those from start to end, then those named in pages; a page as PNG bytes, or with box (x0, y0, x1, y1 as fractions of the page from its top left) part of it, sharper. |
documents.bookmarks(document) |
The PDF's own bookmarks, in their order: each with its title, level (from 1) and page. Free. |
tools(collection=None, filter=None, outline=None) |
Tools for an LLM agent: .definitions (Anthropic), .openai, .openai_agents() (OpenAI Agents SDK), .mcp() (an MCP server), and .run(name, input). With get_document_outline when there are outlines to read; outline=True or False says so instead. |
collections.outlines(collection, on=None) |
Whether the collection makes outlines, how many of its documents have theirs and what making the rest costs; on=True turns them on (its documents' are made, each paid once by its pages, and each added after), on=False off. |
outlines() |
Your outlines: the collections that make them, and how many documents have theirs. |
documents.outline(document), documents.make_outline(document) |
A document's outline: str() of it gives every heading one page a line, .status (ready, preparing, off, unpaid, failed) and .pages, each a page with its headings; make one document's, whatever its collection. |
documents.update(document, metadata=) |
Set metadata keys; None removes one. |
collections.schema(collection), documents.schema(collection=None, filter=None) |
The metadata keys the documents have: each key's types, how many documents have it, its least and greatest numbers and commonest strings. Counted as they are now; nothing is enforced. |
collections.create(name), .list(), .get(id), .rename(collection, name), .delete(collection) |
Named groups of your documents, as folders: a document is in at most one. Deleting one deletes its documents. |
collections.add(collection, documents), .remove(collection, document) |
Move documents into a collection, from any other, or one out of it, into none. documents.upload(..., collection=) makes a new one in it. |
usage(start=None, end=None) |
Uploads, searches and cost by day, your credit and stored pages. |
In 0.4, search(document, questions) became search(questions, document=document), and each answer lists
documents, each with its pages (answer.pages is the first document's). Before 0.2 these were upload(), document(), documents(), iter_documents() and delete() on the client;
they still work, with a warning, for now.
Errors raise PageSearchError, with the API's status, code, message and request_id.
See the API reference for every field and the pricing.
VectifyAI/pageindex-search-python is a public repo on GitHub by VectifyAI. Its maker has not written a description.
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-06. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
OpenKB: Open LLM Knowledge Base
ChatIndex: Tree indexing and retrieval for long conversational memory