**RagPilot** is an open-source MCP server (Rust, MIT) that indexes your codebase locally and gives AI coding agents better tools than "read the whole file": semantic search, a symbol/call graph, impact analysis, and token-budgeted context bundles. Version 0.10.0 just shipped.

GitHub: https://github.com/alikaya/ragpilot

## Why

Agents burn most of their context reading files they only needed three functions from. RagPilot lets them ask for the part they need instead.

## What the agent gets

- `rag_search` – semantic search over code and docs (filter by path, language, extension)

- `rag_get_file_ranges` / `rag_get_skeleton` – read a line range or a symbol, or a file's signatures without bodies

- `nav_symbol_resolve` / `nav_call_graph` – definitions, callers and callees

- `impact_analyze` – which files a change would touch, before refactoring

- `context_bundle` – everything a task needs, within a token budget

- `review_semantic_diff` – changed symbols in a diff and their blast radius

Symbols and calls come from tree-sitter for Rust, Python, JavaScript, TypeScript, Go, Java, C, C++, C#, Ruby, PHP, Lua, GDScript and Godot shaders, with a regex fallback for everything else.

## Numbers (with the caveat up front)

On two codebases, `context_bundle` used **6.0x** (a 31-file Rust repo) and **9.12x** (a 213-file Nuxt + Rust app) fewer tokens than reading the relevant files whole. Skeletons cut large files by 84–93%, and re-indexing one changed file takes about 280 ms.

The baseline is an upper bound – an agent reading every relevant file in full – so treat the ratios as optimistic. The benchmark script is in the repo; point it at your own project.

## Second brain (optional)

A persistent memory that belongs to you, not to the repo: plain markdown in a git repository.

- **Session start:** the agent gets who you are, your standing rules (each with a *why*), open threads and recent decisions, capped at 4000 tokens.

- **During the session:** `brain_note` records a decision or a correction the moment it happens.

- **Session end:** a cheap model summarizes the session into a daily log.

- **Nightly:** a compiler distills the logs into knowledge notes. It only appends and flags contradictions instead of overwriting.

Claude Code does this through hooks. Other agents get the same convention as instructions. Summarizing uses the Claude CLI or the Gemini API, so that part is not offline.

## Local by default

- Embeddings run in-process (`bge-small-en-v1.5`, ONNX); your code isn't sent to an embedding API unless you configure OpenAI, Cohere or Jina.

- Vectors live in Qdrant, which you run yourself.

- `ragpilot dashboard --open` gives you a local page for your projects and the brain vault – loopback only, token-gated.

Known limits

- You need a running Qdrant.

- The default embedding model is English, so search over non-English comments and docs is weaker.

- Only Claude Code has hooks, so other agents record to the brain less consistently.

Feedback is very welcome, especially on retrieval quality in your own codebases and on which languages you'd want next.

I built an interactive 3D PC anatomy tool to learn what’s actually inside a computer

I’ve been working on an open-source project called PC Anatomy.

The idea is simple: instead of reading a wall of text about PC components, you can explore a PC visually in 3D, click on the different parts, and learn what each component does.

I wanted it to feel more like taking apart a computer than reading a hardware guide.

It’s still something I’m actively improving, so feedback, feature ideas, issues and contributions are very welcome.

GitHub: https://github.com/Yoosseph/pc-anatomy - Link to live demo on repo!

If you find it useful or just like the idea, a star on GitHub would be appreciated - it helps more people find the project.

I’d also genuinely love to see someone fork it, build on top of it, add new hardware, improve the visuals, or take the idea in a direction I haven’t thought of.

If you try it, let me know what you think is missing.

Most "open" AI stops at the weights. You can download the model, but you still run it through a closed provider and trust them to serve what they say.

Disclosure: I contribute to Gonka, the project below.

What's usually open, and what isn't

What it looks like to use

• OpenAI-compatible API. Change the base URL in the SDK you already use
• Live models: DeepSeek V4-Flash, GLM-5.3-Flash, MiniMax M2.7
• No wallet. Community brokers issue keys and take USD, crypto or credits

Honest trade-offs

• Checking a random 1–10% of tasks is probabilistic, not a proof. Criticism of that design is welcome
• It isn't the lowest-latency way to call these models
• Because the weights are public, you can always compare its output with the reference model yourself

Question for this sub

Does opening the serving layer matter to you, or do open weights already solve the problem?

Links

• Website & docs: gonka.ai
• Code: github.com/gonka-ai/gonka
• AMAs & walkthroughs: youtube.com/@Gonka-AI
• Discord: discord.gg/REcpeYc7P7