VectifyAI/OpenKB: Build a Compiled Wiki Without Vector Databases

VectifyAI/OpenKB: Build a Compiled Wiki Without Vector Databases

Traditional RAG forces your LLM to rediscover knowledge from scratch every single query. Documents sit in isolation, context gets lost, and nothing accumulates. VectifyAI/OpenKB takes a fundamentally different approach: it compiles raw documents into a persistent, interlinked wiki-style knowledge base that grows smarter over time. Built on vectorless, reasoning-based retrieval via PageIndex, this open-source Python^{↗ Bright Coding Blog} CLI tool (3,003 GitHub stars, Apache 2.0 licensed) targets developers who need to work with long documents, multi-modal content, and complex knowledge synthesis—without the overhead of traditional vector databases.

What is VectifyAI/OpenKB?

VectifyAI/OpenKB is an open-source CLI system that transforms raw documents into structured, interlinked wiki pages using LLMs. Maintained by VectifyAI and last updated July 13, 2026, it sits at the intersection of document processing, knowledge management, and LLM application infrastructure.

The project's core thesis comes from a concept described by Andrej Karpathy: LLMs should generate summaries, concept pages, and cross-references that persist and compound over time, rather than being re-derived on every query. OpenKB implements this vision through two architectural layers: a wiki foundation that compiles and maintains knowledge, and generators that transform that wiki into usable outputs like answers, conversations, and portable agent skills.

What distinguishes OpenKB from conventional RAG pipelines is its compilation model. Traditional RAG retrieves chunks and synthesizes responses ad hoc; OpenKB performs the synthesis once during ingestion, creating persistent pages that capture cross-document relationships, flag contradictions, and enable incremental enrichment. The result is a knowledge base that genuinely accumulates understanding rather than repeating discovery.

The system handles both short and long documents through differentiated pipelines: shorter materials pass through markitdown for direct LLM reading, while longer PDFs (≥20 pages by default) route through PageIndex's hierarchical tree indexing for scalable, context-aware retrieval without vector embeddings.

Key Features

Vectorless, reasoning-based retrieval. OpenKB leverages PageIndex's tree-structured indexing rather than dense vector embeddings. For long documents, the LLM reasons over a hierarchical index rather than scanning full text or approximating similarity through vector distance. This avoids the context-limit and relevance-precision tradeoffs that plague traditional RAG.

Native multi-modality. The system retrieves and understands figures, tables, and images alongside text—not as afterthoughts, but as integrated knowledge elements. PageIndex extracts visual content during indexing, and the compilation process incorporates these into the structured wiki.

Compiled wiki with automatic cross-referencing. When you add a document, the LLM generates a summary page, reads existing concept and entity pages, creates or updates cross-document syntheses, and maintains the index and log. A single source typically touches 10–15 wiki pages. Entity pages for people, organizations, places, and products auto-extract and stay synchronized.

Broad format support. PDF, Word, Markdown^{↗ Smart Converter}, PowerPoint, HTML, Excel, CSV, plain text, and URLs all ingest through unified pipelines. Content type auto-detection removes format friction.

Generator ecosystem. Beyond the wiki itself, OpenKB ships query/chat interfaces, an interactive 3D knowledge graph visualizer, HTML slide deck generation, and Skill Factory for distilling portable agent skills compatible with Claude Code, OpenAI Codex CLI, and Gemini CLI.

Obsidian compatibility. The wiki outputs as plain Markdown files with [[wikilinks]], opening directly in Obsidian for graph visualization and manual browsing. No lock-in, no proprietary formats.

Google OKF compliance. Wiki pages follow the Google Open Knowledge Format specification, enabling standardized knowledge sharing.

Use Cases

Research literature synthesis. Drop a directory of PDF papers into OpenKB; receive interconnected summary pages, extracted entities (authors, institutions, datasets), and cross-referenced concepts. Query across the compiled wiki to find methodological connections a keyword search would miss, or generate a portable skill that lets Claude Code reason like a domain specialist about your paper collection.

Technical documentation intelligence. Feed product manuals, API docs, and internal wikis through OpenKB's compilation pipeline. The resulting knowledge base maintains living connections between related procedures, flags when updates contradict existing guidance, and supports conversational exploration for support engineers who need precise, grounded answers with citations.

Multi-modal report analysis. Process earnings presentations, research reports with heavy chart content, or regulatory filings. PageIndex extracts figures and tables; OpenKB's compilation incorporates these visual elements into the structured wiki, enabling queries that reference specific data visualizations rather than just surrounding text.

Agent skill distillation. Use Skill Factory to convert domain expertise accumulated in your wiki into redistributable agent skills. A consultant who builds a wiki from industry whitepapers can package that knowledge into openkb skill new market-analyst "Reason like a senior analyst about semiconductor supply chains"—installable by collaborators using their preferred AI coding assistant.

Living personal knowledge bases. Combine openkb watch for automatic compilation of dropped files, Obsidian for browsing, and persistent chat sessions for incremental exploration. The knowledge compounds as you add sources, rather than fragmenting across disconnected queries.

Installation & Setup

OpenKB requires Python and pip. Install from PyPI:

pip install openkb

For the latest development version or to contribute:

# Latest from GitHub
pip install git+https://github.com/VectifyAI/OpenKB.git

# Editable install for development
git clone https://github.com/VectifyAI/OpenKB.git
cd OpenKB
pip install -e .

After installation, create and initialize a knowledge base:

# Create directory for your knowledge base
mkdir my-kb && cd my-kb

# Initialize (interactive; sets model, language, other config)
openkb init

This writes .openkb/config.yaml with your settings. Configure your LLM provider by creating a .env file:

LLM_API_KEY=your_llm_api_key

OpenKB supports multiple providers (OpenAI, Anthropic, Google Gemini, and others) via LiteLLM using the provider/model format—e.g., anthropic/claude-sonnet-4-6 or gpt-5.4 for OpenAI models where the prefix may be omitted.

Optional: For enhanced long-document processing with OCR and faster structure generation, set a PageIndex Cloud API key:

PAGEINDEX_API_KEY=your_pageindex_api_key

Cloud features remain optional; local PageIndex runs without external dependencies.

Real Code Examples

Basic Document Ingestion and Query

The everyday workflow demonstrates OpenKB's core compilation model:

# Add documents individually, by directory, or from URL
openkb add paper.pdf
openkb add ~/papers/                            # Recursive directory add
openkb add https://arxiv.org/pdf/2509.11420     # Auto-detected content type

# Query the compiled wiki
openkb query "What are the main findings?"

# Interactive multi-turn conversation
openkb chat

The add command triggers full compilation: markitdown or PageIndex conversion, LLM summary generation, concept/entity extraction, cross-linking, and index updates. Subsequent queries read from this persistent structure rather than reprocessing source documents.

Skill Factory: Distilling Agent Expertise

Skill Factory converts accumulated wiki knowledge into portable agent capabilities:

# Create a specialist skill from your compiled knowledge
openkb skill new my-expert "Reason like an expert on distributed systems consensus"

This generates a validated skill package installable across AI assistants. Additional skill management commands:

# Validate compiled skills (auto-runs after skill new)
openkb skill validate my-expert

# Check trigger prompt alignment
openkb skill eval my-expert

# Version history and rollback
openkb skill history my-expert
openkb skill rollback my-expert

Visualization and Presentation Generation

# Interactive 3D knowledge graph with mind-map and radial views
openkb visualize
# Output: output/visualize/graph.html

# Single-file HTML slide deck
openkb deck new my-deck "An intro deck on vectorless retrieval"
# Options: --skill for theme selection, --critique for quality pass

File Watching for Continuous Compilation

# Auto-compile documents dropped into raw/
openkb watch

This pairs with Obsidian Web Clipper: clip articles to raw/, and OpenKB automatically incorporates them into the growing wiki.

Advanced Usage & Best Practices

Tune the PageIndex threshold. The default pageindex_threshold: 20 in config.yaml routes PDFs of 20+ pages through tree indexing. Adjust based on your typical document complexity and LLM context window. Shorter thresholds trade processing overhead for retrieval precision on moderately complex documents.

Curate wiki/AGENTS.md. This file defines wiki structure conventions and serves as the LLM's runtime instruction manual. Customize organization schemes, naming conventions, or cross-linking rules—changes take effect immediately without recompilation since the LLM reads it from disk each run.

Use --dry-run for destructive operations. Both openkb remove and openkb recompile support --dry-run to preview changes. Recompilation overwrites manual edits to generated pages; plan your editing workflow accordingly.

Structure raw inputs intentionally. Nested folders within raw/ compile into logical document groupings. The roadmap indicates nested folder support is expanding; organize sources by project, time period, or domain to prepare for richer hierarchical concept indexing.

Version skills before distribution. Skill Factory's built-in history and rollback commands enable iterative refinement. Evaluate trigger behavior with skill eval before sharing to ensure prompts activate the intended expertise.

Comparison with Alternatives

Traditional RAG excels at ad hoc queries over massive corpora where recency matters more than synthesis. OpenKB suits scenarios requiring accumulated understanding, cross-document reasoning, and portable expertise. NotebookLM offers polished consumer experience but lacks developer control, extensibility, and local operation.

FAQ

What LLM providers does OpenKB support? Any provider supported by LiteLLM: OpenAI, Anthropic, Google, Azure, local models via Ollama/LM Studio, and others. Configure with provider/model syntax in config.yaml.

Is there a web interface? Not currently. OpenKB is CLI-first. The roadmap includes a web UI for browsing and management.

Can I use local models without API costs? Yes. LiteLLM supports local runtimes; configure timeouts appropriately for slower local inference in config.yaml.

How does licensing work? Apache License 2.0. Free for commercial and personal use with standard Apache attribution requirements.

What happens to my data? Local operation by default. Documents, wiki files, and PageIndex indices remain on your machine. Optional PageIndex Cloud requires API key and sends documents to hosted infrastructure.

Can I edit wiki pages manually? Yes, but openkb recompile overwrites generated content. Reserve manual edits for pages you create outside the compilation pipeline, or use --dry-run to preview recompilation impact.

Does it scale to thousands of documents? The roadmap explicitly targets large collections with nested folders and database-backed storage. Current performance depends on LLM API rate limits and local filesystem I/O.

Conclusion

VectifyAI/OpenKB addresses a genuine architectural limitation in how most teams deploy LLMs for knowledge work: the endless rediscovery problem. By compiling documents into a structured, interlinked, and growing wiki—using vectorless, reasoning-based retrieval for scalability—it offers a credible alternative for developers who value persistent knowledge accumulation over ephemeral retrieval.

The tool fits practitioners managing research literature, technical documentation, or multi-modal report collections who want Obsidian-compatible outputs, portable agent skills, and freedom from vector database infrastructure. It's less suited for real-time analytics over rapidly changing data streams or teams needing mature web-based collaboration today.

With 3,003 GitHub stars, active development through mid-2026, and a growing ecosystem including PageIndex, ChatIndex, and ConDB, VectifyAI is building coherent infrastructure around this compiled-knowledge approach. If you're evaluating alternatives to chunk-and-retrieve RAG, explore VectifyAI/OpenKB on GitHub and test the compilation model against your document challenges.

For related approaches to structured LLM knowledge management, see [INTERNAL_LINK: PageIndex vectorless retrieval architecture].