Creating Kb Skill for Claude

creating-kb

Turn a pile of files into a portable, deployable knowledgebase. The output

is a .skill bundle — an ordinary zip — containing a BM25 inverted index, the

chunk text, a pure-Node searcher, and a query protocol. It has no embedding

model and no semantic search: retrieval is lexical, and the consuming agent

supplies the semantic layer by expanding the query at search time. That is what

makes the bundle portable — any agent that can run node can query it with no

npm install, no model download, and no network.

The whole toolchain is JavaScript so one implementation serves both this builder

and the in-browser packer. Build with the bundled script; do not hand-roll the

index.

SCRIPTS=/mnt/skills/user/creating-kb/scripts
node $SCRIPTS/build_lexkb.js CORPUS_DIR --out /tmp/kb --name my-kb --zip

Workflow

1. Gather the sources

Collect the files into one directory. In a Claude.ai chat, uploads land in

/mnt/user-data/uploads/ — point the builder there. Otherwise use any path the

user names. Supported extensions default to txt,md,html,htm; pass --ext to

change them.

This MVP interface is bounded by how many files a chat can accept. For a large

corpus, stage the files in a directory first, or use the browser packer (built

from the same scripts) that runs entirely client-side.

2. Build the bundle

SCRIPTS=/mnt/skills/user/creating-kb/scripts
node $SCRIPTS/build_lexkb.js /mnt/user-data/uploads \
  --out /tmp/kb --name my-kb --zip \
  --source "human description of the corpus"

The script chunks each file, builds the BM25 index, writes the bundle dir

(SKILL.md + search.js + index.json + chunks.jsonl), and — with --zip —

emits my-kb.skill next to --out.

3. Deliver

Move the .skill to the outputs directory and give the user a download link:

cp /tmp/my-kb.skill /mnt/user-data/outputs/

[Download my-kb.skill](computer:///mnt/user-data/outputs/my-kb.skill)

Tell the user how to deploy it: unzip into an agent's skill directory (or upload

it as a skill). The bundle's own SKILL.md then drives querying — the consuming

agent reads it, expands each question into search terms, and runs the bundled

search.js. No further setup.

Choosing chunk size

The retrieval unit and the reasoning unit are decoupled, which makes chunk size a

low-stakes choice. search.py/search.js rank on the whole chunk (best

recall) but return only the query-densest passage of it by default

(--snippet, ~1200 chars), so a big chunk does not flood the consuming agent's

context with surrounding noise. Index for recall; the searcher handles signal.

--target-chars controls chunk size (whole paragraphs are packed up to the

target; --target-chars 0 makes each file one chunk). Lexical BM25 tolerates —

and on a real-corpus sweep slightly *preferred* — larger chunks than

embedding-based retrieval, because there is no vector to dilute: BM25 scores

individual term presence with length normalization, so a big chunk still ranks on

the exact terms it contains.

• Default: --target-chars 0 (whole document). Best recall, fewest chunks;

the snippet return keeps reasoning context focused.

• Long, multi-topic files where you want tighter citation units: 1500–4000.
• 500 only if you need very fine-grained chunk ids and accept more chunks.

Verifying the bundle

Test before delivering. Run a query against the freshly built bundle and confirm

it returns sensible hits:

node /tmp/kb/search.js --query "a representative question" \
  --core "key term" --expand "synonym" --k 3

Each hit's text is the query-focused passage by default; add --snippet 0 to

inspect a full chunk.

search.js prints JSON {"hits": [...]}. Confirm the right chunks surface.

What ships in the bundle

| File | Role |

|---|---|

| SKILL.md | the query protocol the consuming agent follows (expand → search → cite) |

| search.js / search.py | equivalent BM25 + RM3 + metadata-filter searchers; return query-focused passages (matched sentences kept in neighbour context, merged); the agent runs whichever runtime it has |

| index.json | precomputed inverted index (postings, df, doc lengths, BM25 params) |

| chunks.jsonl | chunk text + structured metadata |

Both searchers are thin readers of the same neutral JSON index, so the bundle

runs in a Node-only or a Python-only consumer. Metadata stays structured (not

folded into the indexed text), which lets the consuming agent filter on it

(--filter section=blog, --filter date>=2025).

Scripts

• scripts/build_lexkb.js — chunker + BM25 index builder + .skill writer.
• scripts/search.js — the JS runtime searcher, copied verbatim into every

bundle. It owns the tokenizer; the builder imports it so index and queries

tokenize identically.

• scripts/search.py — the Python runtime searcher, copied verbatim into every

bundle; a thin reader of the same neutral JSON index, parity-pinned to

search.js (identical results on a shared index).

• scripts/zipstore.js — pure-JS ZIP-STORED writer (used by the builder; shared

with the in-browser packer).

• scripts/bundle_SKILL.md — the query-side SKILL.md template written into each

bundle.