research-20260127-104600-cd8452

What Is Lattice?

Lattice is an AI-powered knowledge graph tool created by Zabaca that transforms markdown documentation into a searchable, interconnected knowledge base. It’s designed specifically for developers who use Claude Code and want to build intelligent documentation systems without complex infrastructure setup.

Think of it as GraphRAG for developers, but simpler—it extracts entities (people, technologies, concepts) from your documentation and builds a knowledge graph that you can search semantically.

Why Is It Special?

Key Differentiators

1. Zero-Friction Setup

   • Embedded DuckDB database (no PostgreSQL, MongoDB, or other external databases)
   • Single API key requirement (Voyage AI for embeddings only)
   • Works directly with your existing Claude Code subscription
   • Two-minute setup time from installation to first search

2. Solves a Real Problem

   • Traditional knowledge management tools (Notion, Obsidian plugins, custom GraphRAG) require:
     • Multiple external services (LLMs, vector databases, embeddings APIs)
     • Complex configuration and DevOps work
     • Separate API keys and authentication
     • Docker or other infrastructure concerns
   • Lattice eliminates this friction with sensible defaults and integrated workflow

3. Built on Proven Technology

   • Uses DuckDB’s HNSW (Hierarchical Navigable Small World) vector similarity search with cosine distance
   • Leverages Claude Code for intelligent entity extraction
   • Vector embeddings via Voyage AI (efficient and cost-effective)
   • Data stored in portable SQLite-like format (~/.lattice/lattice.duckdb)

4. Developer-Centric Features

   • /research command: AI-assisted workflow to find existing docs or create new ones
   • lattice sync: Automatic synchronization of new documents to knowledge graph
   • Semantic search: Find information by meaning, not just keywords
   • P2P knowledge sharing with encrypted transfers
   • Question tracking with answer linking
   • Static site generation for browsable, shareable documentation

Technical Architecture

How It Works

Markdown Documentation
         ↓
    Claude Code
    (via /research command)
         ↓
  Entity Extraction
  (people, technologies, concepts, relationships)
         ↓
  Vector Embeddings
  (Voyage AI)
         ↓
  DuckDB with HNSW Index
  (~/.lattice/lattice.duckdb)
         ↓
  Semantic Search & Retrieval

Data Flow

1. Input: Markdown files in your documentation directory
2. Processing: Claude Code’s /research command extracts:
   • Entities (what things are)
   • Relationships (how things connect)
   • Metadata (context, importance, timestamps)
3. Storage: Everything goes into embedded DuckDB with vector indices
4. Query: Semantic search finds related information using cosine similarity
5. Output: Results formatted as knowledge graph nodes, browsable docs, or raw data

Storage & Portability

• Database file: ~/.lattice/lattice.duckdb
• Format: Portable SQLite-compatible DuckDB format
• Can be version controlled with git (typically small, <10MB for most docs)
• Backup: Simple file copy
• Sharing: Encrypted P2P transfers built-in

Installation & Quick Start

Requirements

• Bun (modern JavaScript runtime)
• Voyage AI API key (free tier available)
• Claude Code subscription (or access to Claude)

Setup

# Install globally with bun
bun add -g @zabaca/lattice

# Set API key
export VOYAGE_API_KEY="your-key-here"

# Initialize in your documentation directory
lattice init

# Index your markdown files
lattice sync

# Search your knowledge base
lattice search "how do I authenticate users?"

Usage Examples

Research a topic:

lattice research "React authentication patterns"
# Opens Claude Code interface to find docs or create new research

Add documentation:

lattice add docs/authentication.md

Search semantically:

lattice search "best practice for password reset"
# Returns semantically relevant docs, not just keyword matches

Why Should You Use It?

When Lattice Is a Good Fit

✅ You should use Lattice if:

• You maintain technical documentation (internal wiki, API docs, engineering guides)
• You want to search documentation by meaning, not just keywords
• You value simplicity over maximum features
• You’re already using Claude Code (leverages existing subscription)
• You want your knowledge base to be portable and version-controllable
• Your documentation is primarily in markdown

❌ Lattice might not be ideal if:

• You need complex access control or team collaboration features
• Your knowledge base is enormous (though DuckDB scales well)
• You need UI-first tools (Lattice is CLI-first)
• You require integration with non-markdown sources (databases, APIs)

Competitive Positioning

Current State (January 2026)

• Actively maintained: GitHub repo shows recent commits
• Package available: Published on npm as @zabaca/lattice
• Ecosystem developing: Complementary project (temporal-bridge) shows broader vision
• Early adopter phase: Not yet widely known, but solid technical foundation
• Production-ready: Used by Zabaca team internally

Conclusion

Lattice is special because it solves the “knowledge graph without infrastructure” problem.

Most teams want GraphRAG-like capabilities but don’t want the operational overhead of managing external databases, multiple LLM APIs, and complex deployments. Lattice delivers that simplicity while keeping the powerful semantic search that makes knowledge graphs valuable.

It’s particularly well-suited for:

• Individual developers building personal wikis
• Engineering teams maintaining internal documentation
• Open source projects with extensive docs
• Anyone already using Claude Code who wants better docs

The project shows the hallmarks of a well-designed developer tool: minimal dependencies, clear problem statement, sensible defaults, and a delightful experience.

Sources

• Lattice GitHub Repository
• Lattice npm Package
• Zabaca Website
• Temporal Bridge (Complementary Project)