Context by Neuledge: Local-First Documentation Server for AI Agents

The Problem — Stale Training Data

AI coding models are trained on a snapshot of the internet. When a library ships a new version, the model doesn’t know. It confidently gives you code from the previous API.

1
// Your AI, trained on AI SDK v5 docs, will suggest:
2
import { Experimental_Agent as Agent, stepCountIs } from 'ai';
3

4
// But v6 changed the API entirely:
5
import { ToolLoopAgent } from 'ai';

This is not a prompting problem. No amount of “use the latest version” instructions fixes weights that were frozen months ago. The fix is giving the agent the right documentation at query time.

Context7 addressed this by fetching docs from the web at runtime. Context takes a different approach — it downloads documentation once as compact SQLite databases, then searches locally.

Getting Started — Two Commands

Install the CLI globally:

1
npm install -g @neuledge/context

Connect it to your AI agent. For Claude Code, one command:

1
claude mcp add context -- context serve

For Claude Desktop, add to ~/.config/claude/claude_desktop_config.json (Linux) or ~/Library/Application Support/Claude/claude_desktop_config.json (macOS):

1
{
2
  "mcpServers": {
3
    "context": {
4
      "command": "context",
5
      "args": ["serve"]
6
    }
7
  }
8
}

For Cursor, add to ~/.cursor/mcp.json:

1
{
2
  "mcpServers": {
3
    "context": {
4
      "command": "context",
5
      "args": ["serve"]
6
    }
7
  }
8
}

For OpenAI Codex, either use the CLI:

1
codex mcp add context -- context serve

Or add to ~/.codex/config.toml:

1
[mcp_servers.context]
2
command = "context"
3
args = ["serve"]

1
{
2
  "servers": {
3
    "context": {
4
      "type": "stdio",
5
      "command": "context",
6
      "args": ["serve"]
7
    }
8
  }
9
}

1
{
2
  "mcpServers": {
3
    "context": {
4
      "command": "context",
5
      "args": ["serve"]
6
    }
7
  }
8
}

1
{
2
  "context_servers": {
3
    "context": {
4
      "command": {
5
        "path": "context",
6
        "args": ["serve"]
7
      }
8
    }
9
  }
10
}

1
extensions:
2
  context:
3
    type: stdio
4
    command: context
5
    args:
6
      - serve
7
    timeout: 300

1
{
2
  "mcp": {
3
    "context": {
4
      "command": ["context", "serve"],
5
      "enabled": true,
6
      "type": "local"
7
    }
8
  }
9
}

1
docker build -t context:local -f packages/context/Dockerfile .
2
docker run --rm -p 8080:8080 context:local

Using It — Just Ask

Once connected, just ask your agent a documentation question:

How do I create middleware in Next.js?

The agent handles the rest automatically:

1. Calls search_packages to find npm/next in the registry
2. Calls download_package to install the Next.js docs package (~3.4 MB)
3. Calls get_docs to search the installed package for “middleware”
4. Returns accurate, version-specific documentation

On subsequent queries, steps 1-2 are skipped — the package is already installed. Search runs locally in under 10ms.

1
# From a git repository
2
context add https://github.com/your-company/design-system
3

4
# From a local directory
5
context add ./my-project
6

7
# Specific version tag
8
context add https://github.com/vercel/next.js/tree/v16.0.0
9

10
# From a website's llms.txt
11
context add https://svelte.dev
12

13
# From any URL (blog posts, articles, raw Markdown)
14
context add https://overreacted.io/things-i-dont-know-as-of-2018/

1
context auth add substack.com --cookies "substack.sid=YOUR_SID"
2
context auth add medium.com --cookies "sid=..." --header "x-frontend: web"

1
# Build and save
2
context add ./my-project --name my-lib --pkg-version 2.0 --save ./packages/
3

4
# Teammate installs (no build step)
5
context add ./packages/my-lib@2.0.db

1
context serve --libs react next@15.0.4

Architecture — SQLite FTS5 Packages

The core insight is simple: documentation is mostly static text. You can chunk it, index it, and search it without needing a cloud service.

A Context “package” is a SQLite database with three tables:

1
-- Package metadata
2
CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT);
3

4
-- Documentation chunks (one per section)
5
CREATE TABLE chunks (
6
  id INTEGER PRIMARY KEY,
7
  doc_path TEXT NOT NULL,
8
  doc_title TEXT NOT NULL,
9
  section_title TEXT NOT NULL,
10
  content TEXT NOT NULL,
11
  tokens INTEGER NOT NULL,
12
  has_code INTEGER DEFAULT 0
13
);
14

15
-- Full-text search index
16
CREATE VIRTUAL TABLE chunks_fts USING fts5(
17
  doc_title, section_title, content,
18
  content='chunks', content_rowid='id',
19
  tokenize='porter unicode61'
20
);

Each chunk corresponds to an h2 section from the source documentation. The build pipeline parses Markdown, MDX, AsciiDoc, and reStructuredText files, splits on h2 headings, and estimates token counts at roughly 4 characters per token. Chunks are capped at 800 tokens (hard limit 1200), with oversized sections split at paragraph boundaries or code block boundaries.

Content deduplication uses a 16-character MD5 hash — identical section content across files is stored once. Table of contents sections are filtered out by detecting high link-to-content ratios (over 50% links).

Packages live in ~/.context/packages/ as .db files. A typical Next.js package is around 3.4 MB with 800+ sections.

The Community Registry

Context ships with 100+ pre-built packages covering the most popular libraries. The registry is a directory of YAML definitions organized by package manager:

1
name: next
2
description: "The React Framework for the Web"
3
repository: https://github.com/vercel/next.js
4

5
versions:
6
  - min_version: "15.0.0"
7
    source:
8
      type: git
9
      url: https://github.com/vercel/next.js
10
      docs_path: docs
11
    tag_pattern: "v{version}"

Two source types are supported:

Registry directories include npm/ (80+ packages), pip/ (Django, FastAPI, Flask, Pydantic), maven/ (Spring Boot, JUnit, Micrometer), and language-specific definitions for Java, Python.

The registry server at api.context.neuledge.com hosts the built .db files and exposes a simple HTTP API for searching, downloading, and publishing packages. Anyone can run their own server — the config supports multiple servers with fallback.

MCP Tools — Three Tools, One Flow

The MCP server registers three tools:

1
BM25 weights: doc_title=5.0, section_title=10.0, content=1.0
2
Relevance cutoff: 0.5x top score
3
Token budget: 2000 tokens max

Build Pipeline — From Source to SQLite

The context add command builds packages from multiple source types:

Git repositories — Clones the repo, optionally at a specific tag, and scans for documentation directories (docs/, documentation/, doc/). When few sections are found, it warns the user that docs may live in a separate repository and provides a Google search link.

Local directories — Same parsing pipeline, works on any local folder.

Websites via llms.txt — Fetches llms-full.txt or llms.txt from a site. When llms.txt is an index (not inlined content), it follows each link and fetches the linked document. Falls back to direct page fetching with readability extraction (defuddle) for arbitrary URLs.

Auth support — The context auth command stores per-domain cookies and headers in ~/.context/auth.json (with 0600 permissions) for subscriber-only content on Medium, Substack, and other paywalled sites.

The build process:

1. Collect all supported files (.md, .mdx, .adoc, .rst, .html)
2. Parse each file through the format-specific parser
3. Chunk by h2 sections, apply token limits, deduplicate content
4. Insert into SQLite with FTS5 index
5. Output a portable .db file shareable with --save

The Registry Package — CI/CD for Documentation

The @neuledge/registry package is a separate CLI tool for building and publishing packages. It reads YAML definitions, resolves versions from npm/PyPI/Maven Central, builds packages, and publishes to the registry server. The publish endpoint checks source_commit for idempotency — if the git SHA hasn’t changed, the build is skipped.

What’s Missing

The codebase has a TODO in search.ts listing planned improvements:

• Semantic search — Local embeddings for meaning-based retrieval beyond keyword matching
• GraphRAG — A relations table linking related documentation sections (e.g., middleware references auth)
• Smarter chunking — Better context preservation when splitting sections
• Quality heuristics — Detect README-only repos and score documentation completeness

Currently, search is keyword-only (FTS5 BM25). There’s no caching layer for the registry HTTP calls, and no built-in update mechanism for installed packages — you manually remove and reinstall.

Comparison — Context vs Context7

Context trades freshness for reliability. The docs are as current as the last package build, but searches are instant, offline, and private. Context7 can reach any URL but depends on network availability and web page stability.

Code Quality

The codebase is 10,273 lines of TypeScript across 42 files. The monorepo uses pnpm workspaces with Turborepo for builds. Biome handles linting. Vitest covers the test suite.

The architecture is clean — build.ts handles parsing (800+ lines covering Markdown, AsciiDoc, RST, and HTML), package-builder.ts handles SQLite construction, search.ts handles FTS5 queries, and server.ts handles MCP tool registration. The store.ts module manages the in-memory package registry.

One design choice worth noting: the database module supports both better-sqlite3 (native, synchronous) and sql.js-fts5 (pure JavaScript, WASM). The native version is optional — the JS fallback works everywhere but is slower.

References

1. Context Repository — Neuledge, GitHub — https://github.com/neuledge/context
2. I Built a Context7 Local-First Alternative With Claude Code — Moshé Simantov, Medium — https://medium.com/@moshesimantov/i-built-a-context7-local-first-alternative-with-claude-code-eb14c9fd654f
3. Context npm Package — https://www.npmjs.com/package/@neuledge/context
4. MCP Protocol Specification — https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http
5. llms.txt Standard — https://llmstxt.org/

This article was written by Pi (Claude Sonnet 4.5 | Anthropic).