skelprSkelpr finds the right code for AI agents, PR reviews, and fixes — grounded in syntax-aware context and precise file:line citations.
Skelpr retrieves and cites — your agent still does the reasoning.
It speaks MCP (Model Context Protocol), so agents such as Claude Code, Cursor and Antigravity can call it as they are.
Agents can search. The hard part is knowing which files matter, how symbols connect, and whether an answer is grounded in what the repository actually contains.
Skelpr addresses context selection, not the agent’s reasoning. It provides ranked, token-efficient evidence through the same retrieval path across CLI and MCP integrations.
The `negative_missing_service` task asked whether the Sock Shop repository defined a recommendations or inventory service. Skelpr searched for the names, returned compact evidence, and helped the agent avoid inventing a manifest.
0 code definitions · 0 deployment manifestsSkelpr indexes a repository, understands its symbols and relationships, and returns only the code context an agent needs to answer, review, patch, or validate.
path:line evidence.Engine.retrieve_context() is the shared context retrieval method used by MCP, CLI, and integrations. It performs retrieval without invoking an LLM.
Repository files, symbols, imports, chunks, and embeddings become a working knowledge base.
Lexical, symbol, graph, and vector signals are fused deterministically.
Patch generation and validation preserve a path from evidence to verification.
Use the standalone workflow when skelpr should run end to end. Use Agent Integration when an existing coding agent should bring its own reasoning.
Skelpr runs as a code intelligence backend for agents such as Claude Code, Cursor and Antigravity, or any MCP-compatible agent. The agent’s LLM handles reasoning; skelpr provides retrieval and validation.
The MCP Agent integration uses an external agent through MCP/CLI/HTTP. Headless / Enterprise deployments route application or CI traffic through the skelpr API, retrieval, and LLM gateway.
The MCP Agent integration is not a search box. It is a boundary between an agent’s reasoning and a repository’s evidence.
A developer asks the agent a question about a repository.
The external coding agent receives a repository question, review, or fix request.
skelpr_searchskelpr_get_contextskelpr_find_symbolskelpr_dependenciesskelpr_validateskelpr_healthskelpr_apply_ast_patchIn the repository’s self-reported MCP Agent A/B, an Antigravity agent answered seven Sock Shop tasks with native tools only, then with skelpr MCP available (WITHOUT arms 2026-09-09/10; WITH arms re-run 2026-09-24 on the current engine). Below it, the same seven questions answer the like-for-like CLI comparison. Pick any agent-A/B task to read the exact prompt and both verbatim answers.
Explain the architecture of this microservices demo (Sock Shop): identify the main services (carts, catalogue, front-end, orders, payment, queue-master, shipping, user), the data stores and message broker backing them, and the key deployment files (docker-compose, Kubernetes manifests, Helm chart) that define the system.
A score-neutral swap: WITH’s table omits the Redis session-db row (−5) but adds the Makefile workflow (+5)
WITH is the better answer to show someone — image versions for every service and a table you can scan in seconds, at 22% fewer tokens. The one thing WITHOUT has that WITH doesn’t is the Redis session-db row; WITH alone has the Makefile workflow. On facts, it’s a wash.
Parity is the headline: all seven tasks score within the ±5 tolerance, and the run-1 gaps (Helm/ingress, the healthcheck step, 3-of-5 image sites) are closed. Two single checklist facts traded the other way (session-db ↔ Makefile; kube-state-metrics), and both arms miss the negative task’s absence phrase (60/60). Token and file-read savings are unaffected.
Same model (openai/gpt-oss-120b on Groq), same checkout, same deterministic checklist as the agent A/B. The agentic reference picks files from a repo listing, then reads them — two model calls per task; the hybrid engine answers from pre-ranked, cited chunks in one.
⚠️ Latency includes Groq free-tier rate-limit backoff (the Skelpr arm ran second and absorbed the waits); on the task with no throttling it answered in 1.56s vs 3.55s. Accuracy is near-parity, not better: 4 of 7 tasks tie, and the agentic reference leads the other three by 5–10 points.
Your repository, your agent, your next task — the setup is two prerequisites and four commands.
Skelpr cannot start either one for you, and neither one fails loudly. Start Docker Desktop and settle the embedding endpoint first, then run the setup block below.
skelpr setup starts the three services above. Docker Desktop must be running first — if it is not, setup stops at step 1 and says so instead of half-configuring the machine.
Without Docker the core still runs end to end on in-memory fallbacks — you lose sandboxed validation and the production-grade stores, not the assistant.
Both modes embed your query, so you need an endpoint — not a language model. Easiest: a hosted-embeddings token sets SKELPR_EMBEDDINGS_ENDPOINT, and every command authenticates itself. Nothing to run. Or run nomic-embed-text-v1.5 in LM Studio on port 1234.
Point embeddings.endpoint at a GPU host if you prefer — it need not be local. Leave it down and the index still builds over a hashing embedder: worse recall, no error. A credentialed endpoint and the watcher refuse that fallback.
ask, chat, review and fix need a generation model. Run qwen2.5-14b-instruct locally, or configure an API key and skip the hardware. MCP mode needs neither: your agent reasons, Skelpr only retrieves.
A local model and the embedding server can share one endpoint or run on two — separate model and embeddings blocks in .skelpr.yaml. With an API key, only the embedding endpoint stays local.
Check the embedding endpoint before you index. A 200 here, and the Embedding server online line in the skelpr index output, are the whole difference between a vector index and a keyword one. On the hosted endpoint there is nothing to check by hand — skelpr index probes and authenticates for you — so this is the local path.
curl -s http://127.0.0.1:1234/v1/embeddings \
-H 'Content-Type: application/json' \
-d '{"input":["hi"],
"model":"text-embedding-nomic-embed-text-v1.5@q8_0"}'Index a project, add the MCP integration, and let your existing agent call skelpr when it needs repository understanding.
# from PyPI — the [mcp] extra brings the MCP server
pip install "skelpr[mcp]"
# once per machine — the token from your access email
skelpr activate <token>
cd <your-repo>
skelpr setup
skelpr init
skelpr index
skelpr install-mcpRequirements: Python 3.10+, Docker Desktop running, and an embeddings endpoint — hosted or local, the section above has both. The agent side needs any MCP-capable client: skelpr install-mcp auto-detects Claude Code, Cursor, Windsurf, Cline, Claude Desktop and Antigravity, and skelpr register-agent covers the rest.
No account, no telemetry, one honest exception. Activation binds this machine once; a managed lease then re-checks in on its interval, sending your token and a machine-id hash — no hostname, no paths, no code, no usage. Indexing, retrieval and review run against your local checkout, so your code is never uploaded — except at the optional hosted-embeddings endpoint, which receives the chunk text it is asked to embed. Credential-shaped values are masked before retrieved text reaches your agent, the model or the logs, and credential files like .env, *.pem and id_rsa never enter the index. skelpr license reports the state; skelpr doctor reports what was masked.
What it is, what it needs, and where your code goes — the answers that otherwise live in an email thread. The full guide has the commands.
Skelpr is surgical code retrieval for AI agents, PR reviews, and fixes. It finds the parts of a repository that matter, ranks them, and hands your agent a small context package with precise file:line citations. Skelpr retrieves and cites — your agent still does the reasoning.
Search finds matches; Skelpr assembles evidence. It combines symbolic, lexical and graph signals over an indexed repository and returns a ranked, token-efficient package — the benchmarked runs opened 76% fewer files and spent 59% fewer agent tokens.
Anything that speaks MCP. skelpr install-mcp auto-detects common agents such as Claude Code, Cursor and Antigravity, and skelpr register-agent covers the rest. The CLI takes the same retrieval path for review, diff and fix without an agent in the loop.
Python 3.10 or newer, Docker Desktop running, and an embeddings endpoint — the hosted one if your token carries it, otherwise a local model such as LM Studio servingnomic-embed-text-v1.5 on port 1234. Without Docker the core still runs on in-memory fallbacks; you lose sandboxed validation and the production stores, not the assistant.
No. Indexing, retrieval and review run locally, and there is no telemetry. Activation sends your token and a hash of this machine’s id — no hostname, no file paths, no code, no usage — and a managed lease re-checks in on its interval, so it needs the network. Credential-shaped values are masked before retrieved text reaches your agent, the model or a trace, and credential files such as .env, .pem and id_rsa are left out of the index.
pip install skelpr is open to anyone; running is licensed per machine. Join the waitlist and we send a token that activates one seat — a seat is a machine, not a person or a repository.
Install is open today; running is licensed per machine. Access is invite-only for now — 0.3.0, the engine behind these benchmarks, is out and seats go out by hand. Join the list and we send a token for one machine, plus release notes, new runs and early enterprise access.