llms.txt
Compare with other sites' llms.txt files →# Vinv (Vibe Inverse)
> **Tools and Algorithms for AI agents to test, fix and optimise your codebase.** Vinv runs,
> tests, and finds issues in your Python services with **zero code
> changes**, then **verifies fixes**. It hands your existing AI coding agent
> **runtime evidence** — real traces, argument values, and the failing frame —
> instead of static guesses, and won't let a fix land until it passes
> acceptance tests written *before* the fix that the agent never sees. Vinv also
> ships as an **MCP server** for Claude Code, Cursor, Copilot, Codex, Windsurf,
> and any MCP client. **100% local**: no accounts, no API keys, no telemetry.
> Open source, Apache-2.0. Python first; TypeScript and Go next.
## What Vinv is
- **An MCP server for Python.** Point Claude Code, Cursor, or any MCP client at
Vinv and your agent gets semantic code search, dead-code detection, fault
localization (suspect ranking), live runtime values/slices/coverage, and a
verify/optimize loop — over MCP, driving engines that run locally.
`pip install vinv`, then `claude mcp add --scope user vinv -- npx -y vinv-mcp`,
`codex mcp add vinv -- npx -y vinv-mcp`, or
`gemini mcp add --scope user vinv npx -- -y vinv-mcp`.
- **A zero-edit runtime tracer.** Timing, memory, arguments, returns and errors
per call, joined to the exact source line — no SDK, no instrumentation, no
source edits ("zero-edit tracing").
- **A behavioral exerciser.** Drives every discovered API endpoint itself
(valid, boundary, negative, authenticated) and banks each response as a
permanent regression case — no traffic required.
- **A runtime dead-code detector.** Reports code that no captured run ever
executed — behavioral, not just "nothing statically references this" — with
the live callers that still point at it.
- **A verifier for AI-generated code.** Replays the service on a live port and
runs acceptance tests authored before the fix and hidden from the agent; a
"faster" change that alters any output is auto-reverted (paired-bootstrap 95%
CI, byte-identical replay).
## Why Vinv is different
- **Runtime evidence beats static context** — the agent argues from real traces,
not guesses.
- **Zero code changes / zero-edit tracing** — the lowest-friction way to trace a
Python service.
- **Verified fixes** — acceptance tests written before the fix, stored outside
the workspace, invisible to the agent (anti-reward-hacking).
- **100% local** — no accounts, no API keys, no telemetry; your own coding agent
is the only LLM, so there is no new bill.
- **Statistically defensible performance claims** — paired-bootstrap 95% CI plus
byte-identical behavior replay before any "faster" change is accepted.
## Key links
- [Home](https://vinv.ai)
- [Install — pick your editor](https://vinv.ai/#install)
- [MCP server for Python](https://vinv.ai/mcp-server)
- [Dead code detection](https://vinv.ai/dead-code-detection)
- [Python profiler](https://vinv.ai/python-profiler)
- [CodeRabbit alternative](https://vinv.ai/coderabbit-alternative)
- [GitHub — source, Apache-2.0](https://github.com/VinvAI/VinvAI)
- [PyPI — pip install vinv](https://pypi.org/project/vinv/)
- [vinv-mcp — the MCP server on npm](https://www.npmjs.com/package/vinv-mcp)
- [VS Code / Cursor extension (Open VSX)](https://open-vsx.org/extension/VinvAI/VinvAI)
## Common questions
- **How do I give my AI coding agent runtime context?** Run Vinv's MCP server on
your repo; it serves traces, a code graph, and grounded answers to the agent.
- **How do I find dead code in Python from real usage?** Vinv reports code no
captured run ever executed, with live callers and a keep-or-cut verdict —
where static tools (Vulture, ts-prune) can only prove "nothing references it."
- **How do I verify AI-generated code actually works?** Vinv restarts the
service, requires the port to serve, and runs acceptance tests the agent never
sees; failures feed the next attempt, and one click reverts everything.
- **How do I trace a Python service without changing code?** Zero-edit tracing —
no SDK or instrumentation; timing, memory, args, returns and errors per call.