#7
`code-review-graph` (CRG) is an open-source Python tool designed to reduce token waste when AI coding assistants perform code review tasks. The core problem it addresses is that AI tools tend to re-read large portions of a codebase during reviews, burning excessive tokens; CRG solves this by building a structural map of the code and feeding AI assistants only the precise context they need. It parses a repository into an Abstract Syntax Tree (AST) using Tree-sitter, stores the code as a graph of nodes (functions, classes, imports) and edges (calls, inheritance, test coverage) in a SQLite backend, and queries this graph at review time to compute the minimal set of files an AI assistant must read. Integration with AI assistants happens through the Model Context Protocol (MCP), allowing the assistant to query graph tools directly. A central feature is "blast-radius analysis": when a file changes, the graph traces every caller, dependent, and test affected by that change, so the AI reads only impacted files rather than scanning the whole project. The tool supports incremental updates in under two seconds—file saves and commit hooks trigger diffs that use SHA-256 hash checks to re-parse only changed files, allowing a 2,900-file project to re-index in under two seconds. CRG is particularly aimed at solving the monorepo token-waste problem, funneling hundreds of thousands of source tokens down to roughly 2,495-token graph responses (a claimed 93x reduction). Installation is streamlined via a single `code-review-graph install` command that auto-detects and configures supported AI coding platforms, writing correct MCP configurations, installing platform-native hooks/skills, and injecting graph-aware instructions into platform rules. Supported platforms include Codex, Claude Code, CodeBuddy Code, Cursor, Windsurf, Zed, Continue, OpenCode, Antigravity, Gemini CLI, Qwen, Qoder, Kiro, and GitHub Copilot (both VS Code and CLI variants). The tool offers a symmetric, safe uninstall command with dry-run, keep-data, and per-repo options that only removes CRG-owned files while preserving unrelated MCP servers and configurations via atomic writes. Language coverage is broad, spanning web, backend, systems, mobile, scripting, and config categories—including Python, JavaScript/TypeScript/TSX, Go, Rust, Java, C/C++, C#, VB.NET, Ruby, Kotlin, Swift, PHP, Scala, Solidity, Dart, R, Perl, Lua/Luau, Objective-C, shell scripts, Elixir, Zig, PowerShell, Julia, ReScript, GDScript, Nix, Verilog/SystemVerilog, SQL, Terraform/OpenTofu, Ansible, Vue/Svelte, Astro, and Jupyter/Databricks notebooks. Users can add support for uncovered languages without forking by dropping a `languages.toml` file mapping extensions
RetrievalMCPToolslocal-firstcodingvector-database
★ 26,697 total+5,078 this week
#8
Graphify is an open-source developer tool built by Graphify Labs that transforms entire software projects — including code, documentation, PDFs, images, and video — into a traversable knowledge graph that AI coding assistants can query directly. Rather than relying on traditional file search or vector embeddings, Graphify constructs a real graph of concepts and relationships that developers and AI agents can navigate using natural language queries, path tracing, and node explanation commands. The core philosophy is that understanding a codebase should feel like exploring a map, not grepping through files, and Graphify delivers on that by making the graph the primary interface for project comprehension.
The tool is invoked by typing `/graphify .` inside any supported AI coding assistant, after which it parses the entire project and produces three output artifacts: an interactive `graph.html` file viewable in any browser with clickable nodes and community filtering, a `GRAPH_REPORT.md` summarizing key concepts and surprising connections, and a `graph.json` file that persists the full graph for repeated querying without re-reading source files. This on-demand workflow is positioned as the open-source entry point, while the team is building an always-on, continuously updating version at graphify.com, for which users can join a waitlist.
A defining technical feature is that code parsing is entirely local and deterministic, powered by tree-sitter AST analysis across approximately 40 programming languages. No LLM is invoked and no data leaves the machine during the code-mapping phase. Only the semantic pass over non-code assets like documents, PDFs, images, and audio/video calls an external model, and only when the user configures an API key. This local-first design is a deliberate differentiator from most AI-powered code intelligence tools that rely on per-token LLM calls for every analysis step.
Every edge in the graph carries a confidence tag: `EXTRACTED` for relationships explicitly present in the source, and `INFERRED` for those resolved by Graphify's own analysis. This transparency lets developers and AI agents distinguish ground-truth structural facts from derived inferences, which is important for trust in agentic workflows. The graph also surfaces "god nodes" — the most-connected concepts that everything flows through — and uses the Leiden community detection algorithm to split the graph into labeled subsystems without requiring any LLM calls, making community labeling both fast and cost-free.
Query capabilities include `graphify explain "<concept>"` for detailed node inspection, `graphify path A B` for shortest-path tracing between any two concepts, and `graphify query "<question>"` for returning a scoped subgraph in response to a plain-language question. These commands operate against the persisted `graph.json`, meaning the graph is a durable artifact that can be queried repeatedly and shared across team members or CI pipelines. Inline code annotations such as `# NOTE:` and `# WHY:` comments, as well as ADR and RFC citations, are promoted to first-class graph nodes linked directly to the relevant code, preserving architectural rationale as a queryable layer.
Benchmarks reported in the README show competitive performance on established memory and retrieval tasks. On the LOCOMO benchmark with 300 samples, Graphify achieves a recall@10 of 0.497, compared to 0.048 for mem0 and 0.149 for supermemory. On LongMemEval-S with 50 samples, it reaches 76% QA accuracy, tied with dense RAG approaches. Crucially, Graphify achieves these results with zero LLM credits consumed during graph construction, whereas most competing systems incur per-token costs. The benchmarks were run on a shared harness with blind judge validation achieving 90.6% agreement and a Cohen's kappa of 0.81, lending methodological credibility to the reported numbers.
The tool integrates with a wide range of AI coding assistants including Claude Code, Cursor, Codex, Gemini CLI, and GitHub Copilot, among 15 or more platforms. Installation is straightforward via `uv tool install graphifyy` or `pipx install graphifyy`, followed by `graphify install` to register the skill with the assistant. Project-scoped installs are supported via a `--project` flag, writing skill files into the repository itself for team sharing and CI use. A strict mode for Claude Code (`--strict`) is also available to ensure the assistant actively uses the graph rather than merely having access to it.
The README is available in over 30 languages, signaling a strong internationalization effort and a broad intended audience. The project is listed on Trendshift and is backed by Y Combinator (S26 batch), which adds institutional credibility and suggests it is in active early-stage commercial development. The PyPI package name is `graphifyy` (double-y) to distinguish it from unaffiliated packages, while the CLI command remains `graphify`. The combination of zero-cost local graph construction, transparent edge provenance, multi-modal input support, broad AI assistant compatibility, and strong benchmark results makes Graphify a notably well-positioned project in the rapidly growing space of AI agent tooling and codebase intelligence.
RetrievalToolsMCPlocal-firstmultimodalcoding
★ 96,592 total+4,880 this week
#109
GBrain is an open-source personal and team knowledge brain system built by Garry Tan, President and CEO of Y Combinator, designed to serve as a persistent, intelligent memory layer for AI agents. Rather than returning raw search results like traditional retrieval systems, GBrain synthesizes information into coherent, cited answers with explicit gap analysis — telling you not just what it knows, but what it doesn't. The project is positioned as the "brain layer" missing from most AI agent stacks, combining synthesis, knowledge graph traversal, and gap analysis in a single deployable system.
At its core, GBrain addresses a fundamental limitation of existing personal knowledge management tools: they find relevant pages but leave the user to read and synthesize them manually. GBrain instead reads those pages and writes the answer, complete with citations and a candid note about what information may be missing or stale. This is illustrated vividly in the README's meeting-prep example, where a query about an upcoming meeting with "Alice" returns a structured briefing covering her role, open action items, and a heads-up that no new data has been ingested in six weeks — rather than a list of five documents to open manually.
The system is built around two primary query modes: raw retrieval via `gbrain search`, which uses hybrid scoring combining vector similarity, keyword matching, reciprocal rank fusion, source-tier boosting, and a reranker; and the synthesis layer via `gbrain think`, which produces LLM-generated prose answers with citations and gap analysis. The knowledge graph component automatically extracts entity references and creates typed edges — such as `attended`, `works_at`, `invested_in`, `founded`, and `advises` — on every page write, with zero additional LLM calls. This graph layer enables relational queries that pure vector search cannot answer, such as "who works at Acme AI?" or "what did Bob invest in this quarter?"
Performance benchmarks are cited directly in the README: on a 240-page Opus-generated rich-prose corpus called BrainBench, GBrain achieves P@5 of 49.1% and R@5 of 97.9%, representing a +31.4 point improvement in P@5 over its graph-disabled variant and over ripgrep-BM25 plus vector-only RAG by a similar margin. Full evaluation scorecards are available in the sibling `gbrain-evals` repository.
GBrain is described as production-grade and battle-tested: Garry Tan runs it personally across 146,646 pages, 24,585 people, 5,339 companies, and 66 autonomous cron jobs. It ingests meetings, emails, tweets, voice calls, and original ideas continuously, enriches every person and company it encounters, fixes its own citations, and consolidates memory overnight in what the README calls a "dream cycle." This autonomous overnight enrichment loop is a key differentiating feature — it is framed as a daemon that runs 24/7 rather than a chat-based agent requiring constant prompting.
The system supports multi-user team deployments with per-user data scoping, ensuring that queries only surface data the authenticated user is permitted to see. The README claims zero data leaks across all read paths — search, list, lookup, and multi-source reads — after fuzz testing. This positions GBrain directly as a candidate for the "company brain" shape described in Y Combinator's Request for Startups.
Installation is designed to be agent-driven and takes approximately 30 minutes. The recommended path is to paste a single URL into an AI agent such as OpenClaw or Hermes, which then installs GBrain, creates the brain, configures API keys, loads 43 skills, sets up the dream cycle, and verifies the installation end-to-end. For developers already using Claude Code or Codex, GBrain can be wired in as a local memory layer in two commands using PGLite — requiring no Docker, no server, and no tunnel. Remote brain connections are supported via a bearer token. The system exposes 30+ tools over MCP in both stdio and HTTP modes, with OAuth 2.1 support for cloud clients including Claude Desktop, Claude Cowork, Perplexity Computer, and ChatGPT. Deployment guides cover ngrok, Railway, and Fly.io.
The project is notable for several reasons: it is authored by a highly prominent figure
RetrievalAgentsMCPvector-databaseworkflow-automationlocal-first
★ 27,175 total+552 this week