#24
XERJ is a community-trusted, local AI search engine built in Rust that automatically indexes any folder and serves as a high-efficiency retrieval backend for coding agents and developers. Its primary use case is "reference coding," where an agent is pointed at a task, downloads the open-source repositories most similar to the problem at hand, indexes them, and retrieves exactly how those projects solved analogous problems before writing any new code. This approach has been measured in a controlled study across 8 tasks, 4 programming languages, and 16 runs per arm using real Claude token counts, demonstrating 2.7× fewer output tokens than a grep-driven agent and 26× fewer than an agent working from memory alone, all at the same 16/16 solve rate and at roughly 2.1× lower cost. On a single Java task, the reduction reached 278× fewer tokens. In everyday field use, contributors report approximately 5× fewer tokens end to end. The core insight is that grep-driven agents pull entire files into context — up to 1.06 million input tokens on one measured corpus — while XERJ returns only the relevant passage with file and line number. XERJ ships as a single static binary with no JVM and no external dependencies, prebuilt for Linux, macOS, and Windows on both x86-64 and arm64. It speaks the Elasticsearch API natively, meaning existing clients, dashboards, and tooling work against it without modification, and it achieves 1366/1369 ES-YAML conformance. Its search stack combines BM25, k-nearest-neighbor (kNN) vector search, and hybrid retrieval. The default embedder is lexical and fully offline; a neural embedder is available as an opt-in download of approximately 90 MB. Indexing is zero-config via `xerj autoindex <folder>`: XERJ sniffs every file, infers its type, and creates typed, queryable indices automatically — handling code (with symbols and line numbers via tree-sitter), docs, logs, PDFs, SQLite, and CSVs. It also provides a `/_memory/{namespace}` API for agent long-term memory, storing and recalling information by semantic meaning across sessions. Native MCP (Model Context Protocol) integration is supported, and a single `xerj init` command wires XERJ into Claude Code or Cursor. The project is agent-ready with an `llms.txt` file that gives agents ordered setup and usage instructions. Security is explicit: the `--insecure` flag disables TLS and API-key auth, making every caller a superuser, intentionally scoped to single-user developer machines binding only to 127.0.0.1. Community membership is earned by submitting one field report as a pull request after running the tool; these PRs are CLA-exempt. The project is licensed under Apache-2.0, has active CI, versioned releases, multilingual documentation (English, Simplified Chinese, Japanese, Arabic, Spanish), and community channels on Discord and X. It is trending on Trendshift (repository #116361), signaling growing momentum in the AI-assisted development tooling space. Its combination of measurable token savings, zero-config indexing, Elasticsearch compatibility, offline-first design, and native agent integration makes it a notable and practically differentiated entry in the local AI search
RetrievalToolsMCPvector-databaselocal-firstsecurity
★ 8,605 total+4,992 this week
#43
Graphify is an open-source AI-agent memory and code intelligence tool developed by Graphify Labs, a Y Combinator S26 company, that maps entire software projects — including code, documentation, PDFs, images, and video — into a traversable knowledge graph rather than a vector index. The core value proposition is dramatically reducing AI agent token consumption, with Graphify Cloud claiming up to an 80% reduction in agent token spend by keeping a live, always-on graph across the full software development lifecycle. The project is invoked directly inside AI coding assistants via a simple `/graphify` slash command, making it immediately accessible without requiring users to leave their existing workflow. Under the hood, code is parsed using tree-sitter AST parsing, which is deterministic, requires no LLM calls, and runs entirely locally — nothing leaves the user's machine during the code-mapping phase. Only the semantic pass over non-code assets like documents, PDFs, images, and video optionally calls an external model or configured API key. This local-first, zero-LLM-credit approach for code is a notable differentiator from most competing memory and retrieval systems that rely on per-token embedding costs. The resulting knowledge graph is output as three files: an interactive browser-viewable `graph.html`, a human-readable `GRAPH_REPORT.md` summarizing key concepts and surprising connections, and a machine-queryable `graph.json` that persists across sessions with schema versioning for integration stability. Every edge in the graph is tagged as either `EXTRACTED` (explicitly present in source) or `INFERRED` (resolved by Graphify), giving users clear provenance and confidence signals for every relationship. The graph supports rich querying capabilities including `graphify explain`, `graphify path`, and `graphify query` commands that let users trace shortest paths between concepts, explain individual nodes, and retrieve scoped subgraphs from plain-language questions — all without re-reading source files. Community detection uses the Leiden algorithm with LLM-free labeling, and the system identifies "god nodes" — the most-connected concepts that everything flows through — giving developers a bird's-eye architectural view. Cross-file relationship types include calls, imports, inherits, and mixes_in, resolved across approximately 40 programming languages. Benchmark results are notably strong: on the LOCOMO benchmark (n=300), Graphify achieves a recall@10 of 0.497, compared to mem0's 0.048 and supermemory's 0.149, while spending zero LLM credits on graph construction. On LongMemEval-S (n=50), it achieves 76% QA accuracy, tied with dense RAG approaches. On an ERPNext cross-tool benchmark, it achieves 82% key-fact coverage versus a grep/read baseline of 70.8%. The tool supports all major AI coding assistants including Claude Code, Cursor, Codex, Gemini CLI, and GitHub Copilot, and runs on macOS, Linux, and Windows. The PyPI package is published under the name `graphifyy` (double-y) to distinguish it from unaffiliated packages. Graphify Cloud extends the local tool with monorepo and cross-repo support, formal verification, SDLC-wide code review, and connectors for Sentry and Jira, offered with a free 14-day trial. The README is available in over 30 languages, signaling strong international community investment. The project is tracked on Trendshift and carries an Apache 2.0 license, with active CI, a Discord community, YouTube channel, and LinkedIn presence, suggesting a well-resourced and growing open-source project with clear commercial backing and a compelling technical approach to AI agent memory.
RetrievalToolsMCPlocal-firstvector-databasecoding
★ 128,529 total+2,926 this week
#66
TencentDB Agent Memory is an open-source, production-oriented memory infrastructure system built by TencentCloud that enables AI agents to share, accumulate, and reuse knowledge across sessions, frameworks, and team members. The core motivation is eliminating repetitive work: if an agent has already learned project context, read documents, or solved a problem, that experience should be preserved and passed forward rather than rediscovered from scratch. The system is architected around three services — `memory-core`, `memory-hub`, and a transparent `proxy` — all launchable with a single shell script, making setup accessible within minutes. Its most distinctive design choice is a zero-code integration model: agents simply point their base URL to the Proxy, and they immediately gain memory capabilities without plugins, hooks, or MCP servers. This means diverse agents — Claude Code, Codex, DeepSeek Harness, CodeBuddy, WorkBuddy, Hermes, and OpenClaw — all share the same memory server out of the box. Memory assets are organized into four richly structured types: Chat Memory (distilled across four layers from raw conversation to persona), Skills (versioned, executable expertise with trigger boundaries and validation rules), Wiki (structured document knowledge with link graphs, inspired by Karpathy's LLM knowledge base approach), and CodeGraph (symbol-level code indexing with call relationships and impact analysis). A key feature is cold-start support: existing codebases, documents, and past agent conversation sessions can be imported and automatically processed, so new agents inherit accumulated team experience rather than starting from zero. The system supports multi-agent team workflows, enabling a "one-person company" model where specialized agents (Scout, Builder, Reviewer) each receive tailored memory loadouts. Access control is granular, with private, team, and restricted visibility tiers, plus two-layer role management (global System Admin and team-level Admin/Member). The project is currently in active beta (v2/v3 migration tooling exists, MongoDB backend is experimental), published on npm, MIT-licensed, and requires Node.js ≥ 22.16. It is trending on Trendshift, has a Discord community, and supports both English and Simplified Chinese documentation. Compared to standard RAG or chat history, TencentDB Agent Memory adds ownership tracking, versioning, structured relationships, and agent-specific routing — positioning it as a team-grade memory layer rather than a simple retrieval store. Its notable ambition is making agent experience compound over time the way institutional knowledge does in human organizations.
RetrievalAgentsToolslocal-firstvector-databasesynthetic-data
★ 29,591 total+1,658 this week