Concho AI reached 3,200 GitHub stars in July 2026 by solving a problem that blocks every team trying to put AI agents to work on real codebases: agents do not understand the codebase the way humans do. They see files as disconnected text. Concho indexes the entire repository - code, documentation, architecture decisions, dependencies - into a knowledge graph that agents can traverse like a senior engineer would.
The project installs with `pip install concho-ai` and runs a local indexer that builds a Neo4j-backed graph in minutes. Agents query it through a lightweight MCP (Model Context Protocol) server. No cloud dependency, no code leaving your machine. For teams building internal coding agents, onboarding assistants, or architecture review tools, Concho turns "agent doesn't understand our codebase" into "agent navigates the codebase like a staff engineer."
What Concho Actually Does
Concho runs a multi-pass indexer over your repository. The first pass parses every file with Tree-sitter, extracting symbols, imports, function signatures, class hierarchies, and control flow. The second pass ingests markdown docs, OpenAPI specs, README files, and architecture decision records. The third pass builds cross-references: which functions call which, which services depend on which, which tests cover which modules.
The result is a property graph in Neo4j where nodes are code entities (functions, classes, modules, services, tables, API endpoints) and edges are relationships (calls, imports, depends_on, tests, documents, deploys_to). A typical 100k-line TypeScript monorepo indexes in under three minutes on a laptop and produces a graph of roughly 150,000 nodes and 400,000 relationships.
Agents query the graph through a Model Context Protocol server that exposes tools like `find_symbol`, `trace_call_path`, `get_dependencies`, `find_tests_for`, and `explain_architecture`. An agent asked "How does the payment flow work?" can trace from the API route through the service layer to the database schema and the Stripe webhook handler - following actual call edges, not semantic similarity.
Why Graph Beats RAG for Code
Standard RAG over code embeddings treats every file as a bag of tokens. It retrieves by semantic similarity, which works for "find me a function that validates email" but fails for "trace the request from the API gateway to the database." Similarity search cannot follow call chains across service boundaries. It cannot answer "which services will break if I change this schema?" or "show me all paths that write to the users table."
Concho's graph approach preserves structure. The indexer captures the actual call graph, import graph, and deployment topology. Agents traverse edges, not vector distances. This makes the difference between an agent that hallucinates a function name and an agent that finds the exact function, sees its callers, and understands the impact radius of a change.
Benchmarks on the SWE-bench Verified dataset show Concho-augmented agents resolve 34 percent more issues than equivalent RAG-only agents on repository-level tasks. The gap widens on cross-file refactoring and architecture questions where structural knowledge matters more than semantic matching.
Installation and Quick Start
Install the package and index a repository:
pip install concho-ai
cd /path/to/your/repo
concho index --watch
concho serve --port 8080 # starts MCP server
The `--watch` flag keeps the index updated on file changes. The MCP server exposes a JSON-RPC endpoint that any MCP-compatible client (Cursor, Claude Code, custom agents) can connect to. Configuration lives in a `.concho.yaml` at the repo root - you can exclude paths, add custom parsers, and define domain-specific node types.
For teams that want a managed option, Concho Cloud offers hosted indexing with SSO, audit logs, and team workspaces. The open-source version is MIT licensed and fully functional locally.
Who This Is For
Platform teams building internal coding agents. If you are wiring Cursor, Cline, or a custom agent to your monorepo, Concho gives the agent the structural knowledge that makes it useful beyond single-file edits.
Engineering leads onboarding seniors into complex codebases. The graph explorer (included in the MCP server) lets new hires ask "show me the authentication flow" and get a traversable diagram instead of a README that stopped being accurate in 2022.
Teams doing large-scale refactors or migrations. Impact analysis queries - "what breaks if I change this interface?" - return precise answers because the graph captures actual dependencies, not import statements that might be dead code.
Security teams doing supply chain analysis. The dependency graph includes transitive dependencies, license data, and known vulnerability mappings from OSV.
Concho is not for single-file scripting, throwaway prototypes, or teams that only need autocomplete. It shines when the problem is system-level understanding.
How It Compares
Sourcegraph Cody and GitHub Copilot Enterprise offer code search and chat, but they index centrally and send code to their clouds. Concho runs entirely local. CodeGraph (by CodeGraph Inc.) builds a similar graph but is closed-source and cloud-only. Glean and Cursor's codebase indexing use embedding-based retrieval - fast for lookup, weak for traversal.
Concho's tradeoff: you run Neo4j locally (Docker or binary), which adds operational overhead. The team provides a lightweight embedded mode using KuzuDB for teams that want zero-infrastructure indexing, though it sacrifices some query expressiveness.
What's Next
The 0.12 release (July 2026) adds incremental indexing with file-system watchers, a VS Code extension for graph visualization, and experimental support for indexing Jira tickets and PR discussions as graph nodes - linking code to the decisions that shaped it. The roadmap includes multi-repo federation for microservice architectures and a plugin SDK for custom extractors (Protobuf, GraphQL, Terraform, Kubernetes manifests).
For teams that have hit the wall with embedding-based code search, Concho offers a structural alternative. The graph is not a replacement for semantic search - it is the layer that makes semantic search results actionable by connecting them to the system they live in.