[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-75763":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":9,"totalLinesOfCode":9,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":9,"subscribersCount":16,"size":16,"stars1d":17,"stars7d":18,"stars30d":19,"stars90d":16,"forks30d":16,"starsTrendScore":20,"compositeScore":21,"rankGlobal":9,"rankLanguage":9,"license":9,"archived":22,"fork":22,"defaultBranch":23,"hasWiki":22,"hasPages":22,"topics":24,"createdAt":9,"pushedAt":9,"updatedAt":41,"readmeContent":42,"aiSummary":43,"trendingCount":16,"starSnapshotCount":16,"syncStatus":44,"lastSyncTime":45,"discoverSource":46},75763,"codegraph-rust","Jakedismo\u002Fcodegraph-rust","Jakedismo","100% Rust implementation of code graphRAG with blazing fast AST+FastML parsing, surrealDB backend and advanced agentic code analysis tools through MCP for efficient code agent context management",null,"https:\u002F\u002Fgithub.com\u002FJakedismo\u002Fcodegraph-rust","Rust",798,75,9,14,0,12,19,183,36,9.64,false,"main",[25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40],"graphrag","claude-code","codex","cursor","code-search","agents","ai-agents","ai-coding","coding-agent","context-engine","gemini-cli","rag","rust","search-engines","semantic-search","vibe-coding","2026-06-12 02:03:35","![CodeGraph](docs\u002Fassets\u002Fbanner.png)\n\n# CodeGraph\n\n**Your codebase, understood.**\n\nCodeGraph transforms your entire codebase into a semantically searchable knowledge graph that AI agents can actually *reason* about—not just grep through.\n\n> **Ready to get started?** Jump to the [Installation Guide](docs\u002FINSTALLATION_GUIDE.md) for step-by-step setup instructions.\n>\n> **Already set up?** See the [Usage Guide](docs\u002FUSAGE_GUIDE.md) for tips on getting the most out of CodeGraph with your AI assistant.\n\n---\n\n## The Problem\n\nAI coding assistants are powerful, but they're flying blind. They see files one at a time, grep for patterns, and burn tokens trying to understand your architecture. Every conversation starts from zero.\n\n**What if your AI assistant already knew your codebase?**\n\n---\n\n## What CodeGraph Does Differently\n\n### 1. Graph + Embeddings = True Understanding\n\nMost semantic search tools create embeddings and call it a day. CodeGraph builds a **real knowledge graph**:\n\n```\nYour Code → Build Context → AST + FastML → LSP Resolution → Enrichment → Graph + Embeddings\n              ↓               ↓              ↓              ↓              ↓         ↓\n          Packages        Nodes\u002Fedges    Type-aware     API surface      Graph    Semantic\n          Features        Fast patterns  linking        Module graph   traversal   search\n          Targets         Spans          Definitions    Dataflow\u002FDocs             (hybrid)\n```\n\nWhen you search, you don't just get \"similar code\"—you get code with its **relationships intact**. The function that matches your query, plus what calls it, what it depends on, and where it fits in the architecture.\n\nIndexing enrichment adds:\n- Module nodes and module-level import\u002Fcontainment edges for cross-file navigation\n- Rust-local dataflow edges (`defines`, `uses`, `flows_to`, `returns`, `mutates`) for impact analysis\n- Document\u002Fspec nodes linked to backticked symbols in `README.md`, `docs\u002F**\u002F*.md`, and `schema\u002F**\u002F*.surql`\n- Architecture signals (package cycles + optional boundary violations)\n\n#### Indexing tiers (speed vs richness)\n\nIndexing is tiered so you can choose between speed\u002Fstorage and graph richness. The default is **fast**.\n\n| Tier | What it enables | Typical use |\n|------|-----------------|-------------|\n| `fast` | AST nodes + core edges only (no LSP or enrichment) | Quick indexing, low storage |\n| `balanced` | LSP symbols + docs\u002Fenrichment + module linking | Good agentic results without full cost |\n| `full` | All analyzers + LSP definitions + dataflow + architecture | Maximum accuracy\u002Frichness |\n\nTier behavior details:\n- `fast`: disables build context, LSP, enrichment, module linking, dataflow, docs\u002Fcontracts, and architecture; filters out `Uses`\u002F`References` edges.\n- `balanced`: enables build context, LSP symbols, enrichment, module linking, and docs\u002Fcontracts; filters out `References` edges.\n- `full`: enables all analyzers and LSP definitions; no edge filtering.\n\nConfigure the tier:\n- CLI: `codegraph index --index-tier balanced`\n- Env: `CODEGRAPH_INDEX_TIER=balanced`\n- Config: `[indexing] tier = \"balanced\"`\n\n#### Indexing prerequisites (LSP-enabled tiers)\n\nWhen the tier enables LSP (`balanced`\u002F`full`), indexing **fails fast** if required external tools are missing.\n\nRequired tools by language:\n- Rust: `rust-analyzer`\n- TypeScript\u002FJavaScript: `node` and `typescript-language-server`\n- Python: `node` and `pyright-langserver`\n- Go: `gopls`\n- Java: `jdtls`\n- C\u002FC++: `clangd`\n\nIf indexing appears to stall during LSP resolution, you can adjust the per-request timeout:\n\n- `CODEGRAPH_LSP_REQUEST_TIMEOUT_SECS` (default `600`, minimum `5`)\n\nIf LSP resolution fails immediately and the error includes something like `Unknown binary 'rust-analyzer' in official toolchain ...`, your `rust-analyzer` is a rustup shim without an installed binary. Install a runnable `rust-analyzer` (e.g. via `brew install rust-analyzer` or by switching to a toolchain that provides it).\n\n#### Optional architecture boundary rules\n\nIf you want CodeGraph to flag forbidden package dependencies, add `codegraph.boundaries.toml` at the project root:\n\n```toml\n[[deny]]\nfrom = \"your_crate\"\nto = \"forbidden_crate\"\nreason = \"explain the boundary\"\n```\n\nIndexing will emit `violates_boundary` edges when a `depends_on` relationship matches a deny rule.\n\n### 2. Agentic Tools, Not Just Search\n\nCodeGraph doesn't return a list of files and wish you luck. It ships **4 consolidated agentic tools** that do the thinking:\n\n| Tool | What It Actually Does |\n|------|----------------------|\n| `agentic_context` | Gathers the context you need—searches code, builds comprehensive context, answers semantic questions |\n| `agentic_impact` | Maps change impact—dependency chains, call flows, what breaks if you touch something |\n| `agentic_architecture` | The big picture—system structure, API surfaces, architectural patterns |\n| `agentic_quality` | Risk assessment—complexity hotspots, coupling metrics, refactoring priorities |\n\nEach tool accepts an optional `focus` parameter for precision when needed:\n\n| Tool | Focus Values | Default Behavior |\n|------|-------------|-----------------|\n| `agentic_context` | `\"search\"`, `\"builder\"`, `\"question\"` | Auto-selects based on query |\n| `agentic_impact` | `\"dependencies\"`, `\"call_chain\"` | Analyzes both |\n| `agentic_architecture` | `\"structure\"`, `\"api_surface\"` | Provides both |\n| `agentic_quality` | `\"complexity\"`, `\"coupling\"`, `\"hotspots\"` | Comprehensive assessment |\n\nEach tool runs a **reasoning agent** that plans, searches, analyzes graph relationships, and synthesizes an answer. Not a search result—an *answer*.\n\n> **[View Agent Context Gathering Flow](docs\u002Farchitecture\u002Fagent-context-gathering-flow.html)** - Interactive diagram showing how agents use graph tools to gather context.\n\n![AgenticArchitectures](docs\u002Fassets\u002Fagentic_architectures.jpeg)\n#### Agent Architectures\n\nCodeGraph implements agents using **Rig** the default and recommended choice (legacy `react` and `lats` implemented with autoagents still work). Selectable at runtime via `CODEGRAPH_AGENT_ARCHITECTURE=rig`:\n\n**Why Rig is Default:**\nThe Rig-based backend delivers the best performance with modern thinking and reasoning models. It is a native Rust implementation that supports internal sub-architectures and provides features like **True Token Streaming** and **Automatic Recovery**.\n\n**Internal Rig Sub-Architectures:**\nWhen using the `rig` backend, the system automatically maps the **consolidated agentic tools** to the most effective reasoning strategy:\n- **LATS (Tree Search)**: Deep multi-path exploration for complex, non-linear tasks.\n  - Automatically used for: `agentic_architecture` (structure), `agentic_quality`, and `agentic_context` (question).\n- **ReAct (Linear)**: High-speed, focused reasoning for direct data lookups.\n  - Automatically used for: `agentic_context` (search\u002Fbuilder), `agentic_impact`, and `agentic_architecture` (api_surface).\n- **Reflexion (Auto-Recovery)**: A self-correcting fallback that kicks in automatically if the primary strategy fails to find an answer. It analyzes the failure and retries with a refined plan.\n\n### Agent Bootstrap Context\n\nAgents can start with lightweight project context so their first tool calls are not blind. Enable via env:\n\n- `CODEGRAPH_ARCH_BOOTSTRAP=true` — includes a brief directory\u002Fstructure bootstrap + contents of README.md and CLAUDE.md+AGENTS.md or GEMINI.md (if present) in the agent’s initial context.\n- `CODEGRAPH_ARCH_PRIMER=\"\u003Cprimer text>\"` — optional custom primer injected into startup instructions (e.g., areas to focus on).\n\nWhy? Faster, more relevant early steps, fewer wasted graph\u002Fsemantic queries, and better architecture answers on large repos.\n\nNotes:\n- Bootstrap is small (top directories summary), not a replacement for graph queries.\n- Uses the same project selection as indexing (`CODEGRAPH_PROJECT_ID` or current working directory).\n\n```bash\n# Use Rig for best performance with thinking and reasoning models (recommended)\nCODEGRAPH_AGENT_ARCHITECTURE=rig .\u002Fcodegraph start stdio\n\n# Use default ReAct for traditional instruction models\n.\u002Fcodegraph start stdio\n\n# Use LATS for complex analysis\nCODEGRAPH_AGENT_ARCHITECTURE=lats .\u002Fcodegraph start stdio\n```\n\nAll architectures use the same 4 consolidated agentic tools (backed by 6 internal graph analysis tools) and tier-aware prompting—only the reasoning strategy differs.\n\n### 3. Tier-Aware Intelligence\n\nHere's something clever: CodeGraph automatically adjusts its behavior based on the LLM's context window that you configured for the codegraph agent.\n\nRunning a small local model? Get focused, efficient queries.\n\nUsing GPT-5.1 or Claude with 200K context? Get comprehensive, exploratory analysis.\n\nUsing grok-4-1-fast-reasoning with 2M context? Get detailed analysis with intelligent result management.\n\nThe Agent only uses the amount of steps that it requires to produce the answer so tool execution times vary based on the query and amount of data indexed in the database.\n\nDuring development the agent used 3-6 steps on average to produce answers for test scenarios.\n\nThe Agent is stateless it only has conversational memory for the span of tool execution it does not accumulate context\u002Fmemory over multiple chained tool calls this is already handled by your client of choice, it accumulates that context so codegraph needs to just provide answers.\n\n| Your Model | CodeGraph's Behavior |\n|------------|---------------------|\n| \u003C 50K tokens | Terse prompts, max 3 steps |\n| 50K-150K | Balanced analysis, max 5 steps |\n| 150K-500K | Detailed exploration, max 6 steps |\n| > 500K (Grok, etc.) | Comprehensive analysis, max 8 steps |\n\n**Hard cap:** Maximum 8 steps regardless of tier (10 with env override). This prevents runaway costs and context overflow while still allowing thorough analysis.\n\n**Same tool, automatically optimized for your setup.**\n\n### 4. Context Overflow Protection\n\nCodeGraph includes multi-layer protection against context overflow—preventing expensive failures when tool results exceed your model's limits.\n\n**Per-Tool Result Truncation:**\n- Each tool result is limited based on your configured context window\n- Large results (e.g., dependency trees with 1000+ nodes) are intelligently truncated\n- Truncated results include `_truncated: true` metadata so the agent knows data was cut\n- Array results keep the most relevant items that fit within limits\n\n**Context Accumulation Guard:**\n- Monitors total accumulated context across multi-step reasoning\n- Fails fast with clear error message if accumulated tool results exceed safe threshold\n- Threshold: 80% of context window × 4 (conservative estimate for token overhead)\n\n**Configure via environment:**\n```bash\n# CRITICAL: Set this to match your agent's LLM context window\nCODEGRAPH_CONTEXT_WINDOW=128000  # Default: 128K\n\n# Per-tool result limit derived automatically: context_window × 2 bytes\n# Accumulation limit derived automatically: context_window × 4 × 0.8 bytes\n```\n\n**Why this matters:** Without these guards, a single `agentic_impact` query on a large codebase could return 6M+ tokens—far exceeding most models' limits and causing expensive failures.\n\n### 5. Hybrid Search That Actually Works\n\nWe don't pick sides in the \"embeddings vs keywords\" debate. CodeGraph combines:\n\n- **70% vector similarity** (semantic understanding)\n- **30% lexical search** (exact matches matter)\n- **Graph traversal** (relationships and context)\n- **Optional reranking** (cross-encoder precision)\n\nThe result? You find `handleUserAuth` when you search for \"login logic\"—but also when you search for \"handleUserAuth\".\n\n---\n![Intelligence](docs\u002Fassets\u002Fmid.png)\n\n## Why This Matters for AI Coding\n\nWhen you connect CodeGraph to Claude Code, Cursor, or any MCP-compatible agent:\n\n**Before:** Your AI reads files one by one, grepping around, burning tokens on context-gathering.\n\n**After:** Your AI calls `agentic_impact({\"query\": \"UserService\"})` and instantly knows what breaks if you refactor it.\n\nThis isn't incremental improvement. It's the difference between an AI that *searches* your code and one that *understands* it.\n\n### Why this is powerful for code agents\n\nCodeGraph shifts the *cognitive load* (search + relevance + dependency reasoning) into CodeGraph’s agentic tools, so your code agent can spend its context budget on *making the change*, not *discovering what to change*.\n\n#### What an agentic tool returns (example)\n\n`agentic_impact` returns structured output (file paths, line numbers, and bounded snippets\u002Fhighlights) plus analysis:\n\n```json\n{\n  \"analysis_type\": \"dependency_analysis\",\n  \"query\": \"PromptSelector\",\n  \"structured_output\": {\n    \"analysis\": \"…what depends on PromptSelector and why…\",\n    \"highlights\": [\n      { \"file_path\": \"crates\u002Fcodegraph-mcp-server\u002Fsrc\u002Fprompt_selector.rs\", \"line_number\": 42, \"snippet\": \"pub struct PromptSelector { … }\" }\n    ],\n    \"next_steps\": [\"…\"]\n  },\n  \"steps_taken\": \"5\",\n  \"tool_use_count\": 5\n}\n```\n\n#### What a code agent would otherwise have to do\n\nWithout CodeGraph’s agentic tools, a code agent typically needs multiple “single-purpose” calls to reach the same confidence:\n- search for the symbol (often multiple strategies: text + semantic + ripgrep-style search)\n- open and read multiple files (definition + usages + callers + related modules)\n- reconstruct dependency\u002Fcall graphs mentally from partial evidence\n- repeat when a guess is wrong (more reads, more tokens)\n\nThis burns context quickly: reading “just” a handful of medium-sized files + surrounding context can easily consume tens of thousands of tokens, and larger repos can push into hundreds of thousands depending on how much code gets pulled into context.\n\nWith CodeGraph, the agent gets *pinpointed locations and relationships* (plus bounded context) and can keep far more of the context window available for planning and implementing changes.\n\n---\n\n## Quick Start\n\n### 1. Install\n\n```bash\n# Clone and build with all features\ngit clone https:\u002F\u002Fgithub.com\u002Fyourorg\u002Fcodegraph-rust\ncd codegraph-rust\n.\u002Finstall-codegraph-full-features.sh\n```\n\n#### macOS faster builds (LLVM lld)\n\nIf you develop on macOS, you can opt into LLVM's `lld` linker for faster linking:\n\n```bash\n# Install LLVM so ld64.lld is on PATH (Homebrew)\nbrew install llvm\n\n# Use the repo-provided Makefile targets\nmake build-llvm\nmake test-llvm\n```\n\n### 2. Start SurrealDB\n\n```bash\n# Local persistent storage\nsurreal start --bind 0.0.0.0:3004 --user root --pass root file:\u002F\u002F$HOME\u002F.codegraph\u002Fsurreal.db\n```\n\n### 3. Apply Schema\n\n```bash\ncd schema && .\u002Fapply-schema.sh\n```\n\n### 4. Index Your Code\n\n```bash\ncodegraph index \u002Fpath\u002Fto\u002Fproject -r -l rust,typescript,python\n```\n\n> **🔒 Security Note:** Indexing automatically respects `.gitignore` and filters out common secrets patterns (`.env`, `credentials.json`, `*.pem`, API keys, etc.). Your secrets won't be embedded or exposed to the agent.\n\n### 5. Connect to Claude Code\n\nAdd to your MCP config:\n```json\n{\n  \"mcpServers\": {\n    \"codegraph\": {\n      \"command\": \"\u002Ffull\u002Fpath\u002Fto\u002Fcodegraph\",\n      \"args\": [\"start\", \"stdio\", \"--watch\"]\n    }\n  }\n}\n```\n\n**That's it.** Your AI now understands your codebase.\n\n---\n\n## The Architecture\n\n> **[View Interactive Architecture Diagram](docs\u002Farchitecture\u002Fcodegraph-architecture.html)** - Explore the full workspace structure with clickable components and layer filtering.\n\n```\n┌─────────────────────────────────────────────────────────────────┐\n│                         Claude Code \u002F MCP Client                │\n└─────────────────────────────────┬───────────────────────────────┘\n                                  │ MCP Protocol\n                                  ▼\n┌─────────────────────────────────────────────────────────────────┐\n│                        CodeGraph MCP Server                     │\n│  ┌───────────────────────────────────────────────────────────┐  │\n│  │                    Agentic Tools Layer                    │  │\n│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────────────┐  │  │\n│  │  │  Rig    │ │ ReAct   │ │  LATS   │ │ Tool Execution  │  │  │\n│  │  │ Agent   │ │ Agent   │ │  Agent  │ │    Pipeline     │  │  │\n│  │  └────┬────┘ └────┬────┘ └────┬────┘ └────────┬────────┘  │  │\n│  └───────┼───────────┼───────────┼───────────────┼───────────┘  │\n│          └───────────┴───────────┴───────────────┘              │\n│                              │                                  │\n│  ┌───────────────────────────┼───────────────────────────────┐  │\n│  │                  Inner Graph Tools                        │  │\n│  │  ┌──────────────┐ ┌──────────────┐ ┌──────────────────┐   │  │\n│  │  │ Transitive   │ │    Call      │ │     Coupling     │   │  │\n│  │  │ Dependencies │ │   Chains     │ │     Metrics      │   │  │\n│  │  └──────────────┘ └──────────────┘ └──────────────────┘   │  │\n│  │  ┌──────────────┐ ┌──────────────┐ ┌──────────────────┐   │  │\n│  │  │   Reverse    │ │    Cycle     │ │       Hub        │   │  │\n│  │  │    Deps      │ │  Detection   │ │      Nodes       │   │  │\n│  │  └──────────────┘ └──────────────┘ └──────────────────┘   │  │\n│  └───────────────────────────┬───────────────────────────────┘  │\n└──────────────────────────────┼──────────────────────────────────┘\n                               │\n┌──────────────────────────────┼──────────────────────────────────┐\n│                         SurrealDB                               │\n│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │\n│  │   Nodes     │  │    Edges    │  │   Chunks + Embeddings   │  │\n│  │  (AST +     │  │  (calls,    │  │   (HNSW vector index)   │  │\n│  │   FastML)   │  │   imports)  │  │                         │  │\n│  └─────────────┘  └─────────────┘  └─────────────────────────┘  │\n│                                                                 │\n│  ┌────────────────────────────────────────────────────────────┐ │\n│  │              SurrealQL Graph Functions                     │ │\n│  │   fn::semantic_search_nodes_via_chunks                     │ │\n│  │   fn::semantic_search_chunks_with_context                  │ │\n│  │   fn::get_transitive_dependencies                          │ │\n│  │   fn::trace_call_chain                                     │ │\n│  │   fn::calculate_coupling_metrics                           │ │\n│  └────────────────────────────────────────────────────────────┘ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n**Key insight:** The agentic tools don't just call one function. They *reason* about which graph operations to perform, chain them together, and synthesize results. A single `agentic_impact` call might:\n\n1. Search for the target component semantically\n2. Get its direct dependencies\n3. Trace transitive dependencies\n4. Check for circular dependencies\n5. Calculate coupling metrics\n6. Identify hub nodes that might be affected\n7. Synthesize all findings into an actionable answer\n\n---\n\n## Supported Languages\n\nCodeGraph uses tree-sitter for initial parsing and enhances results with FastML algorithms and supports:\n\nRust • Python • TypeScript • JavaScript • Go • Java • C++ • C • Swift • Kotlin • C# • Ruby • PHP • Dart\n\n---\n\n## Provider Flexibility\n\n### Embeddings\nUse any model with dimensions 384-4096:\n- **Local:** Ollama, LM Studio, ONNX Runtime\n- **Cloud:** OpenAI, Jina AI\n\n### LLM (for agentic reasoning)\n- **Local:** Ollama, LM Studio\n- **Cloud:** Anthropic Claude, OpenAI, xAI Grok, OpenAI Compliant\n\n### Database\n- **SurrealDB** with HNSW vector index (2-5ms queries)\n- Free cloud tier available at [surrealdb.com\u002Fcloud](https:\u002F\u002Fsurrealdb.com\u002Fcloud)\n\n---\n\n## Configuration\n\nGlobal config in `~\u002F.codegraph\u002Fconfig.toml`:\n\n```toml\n[embedding]\nprovider = \"ollama\"\nmodel = \"qwen3-embedding:0.6b\"\ndimension = 1024\n\n[llm]\nprovider = \"anthropic\"\nmodel = \"claude-sonnet-4\"\n\n[database.surrealdb]\nconnection = \"ws:\u002F\u002Flocalhost:3004\"\nnamespace = \"ouroboros\"\ndatabase = \"codegraph\"\n```\n\nSee [INSTALLATION_GUIDE.md](docs\u002FINSTALLATION_GUIDE.md) for complete configuration options.\n\n### Experimental graph schema (optional)\n\nCodeGraph can run against an experimental SurrealDB **graphdb-style schema** (`schema\u002Fcodegraph_graph_experimental.surql`) that is interoperable with the existing CodeGraph tools and indexing pipeline.\n\nCompared to the relational\u002Fvanilla schema (`schema\u002Fcodegraph.surql`), the experimental schema is designed for faster and more efficient graph-query operations (traversals, neighborhood expansion, and tool-driven graph analytics) on large codebases.\n\nTo use it:\n\n1) Load the schema into a dedicated database (once):\n\n```bash\n# Example (SurrealDB CLI)\nsurreal sql --conn ws:\u002F\u002Flocalhost:3004 --ns ouroboros --db codegraph_experimental \u003C schema\u002Fcodegraph_graph_experimental.surql\n```\n\n2) Point CodeGraph at that database:\n\n```bash\nCODEGRAPH_USE_GRAPH_SCHEMA=true\nCODEGRAPH_GRAPH_DB_DATABASE=codegraph_experimental\n```\n\nNotes:\n- The schema file defines HNSW indexes for multiple embedding dimensions (384–4096) so you can switch embedding models without reworking the DB.\n- Schema loading is not currently performed automatically at runtime; you must apply the `.surql` file to the target database before indexing.\n- `CODEGRAPH_GRAPH_DB_DATABASE` controls which Surreal database indexing\u002Ftools use when `CODEGRAPH_USE_GRAPH_SCHEMA=true`.\n\n---\n\n## Daemon Mode\n\nKeep your index fresh automatically:\n\n```bash\n# With MCP server (recommended)\ncodegraph start stdio --watch\n\n# Standalone daemon\ncodegraph daemon start \u002Fpath\u002Fto\u002Fproject --languages rust,typescript\n```\n\nChanges are detected, debounced, and re-indexed in the background.\n\n---\n\n## What's Next\n\n- [ ] More language support\n- [ ] Cross-repository analysis\n- [ ] Custom graph schemas\n- [ ] Plugin system for custom analyzers\n\n---\n\n## Philosophy\n\nCodeGraph exists because we believe AI coding assistants should be *augmented*, not replaced. The best AI-human collaboration happens when the AI has deep context about what you're working with.\n\nWe're not trying to replace your IDE, your type checker, or your tests. We're giving your AI the context it needs to actually help.\n\n**Your codebase is a graph. Let your AI see it that way.**\n\n---\n\n## License\n\nMIT\n\n---\n\n## Links\n\n- [Installation Guide](docs\u002FINSTALLATION_GUIDE.md)\n- [SurrealDB Cloud](https:\u002F\u002Fsurrealdb.com\u002Fcloud) (free tier)\n- [Jina AI](https:\u002F\u002Fjina.ai) (free API tokens)\n- [Ollama](https:\u002F\u002Follama.com) (local models)\n\n---\n\n![CodeGraph](docs\u002Fassets\u002Ffooter.jpg)\n","CodeGraph 是一个使用 Rust 语言实现的代码图谱项目，它能够将整个代码库转换为可由 AI 代理理解和搜索的知识图谱。该项目的核心功能包括快速的 AST 和 FastML 解析、surrealDB 后端支持以及通过 MCP 提供的高级代码分析工具，从而有效管理代码代理上下文。它适用于需要对大型或复杂代码库进行高效理解与导航的场景，如软件维护、代码审查及重构等。通过构建真实的知识图谱而非简单的嵌入式表示，CodeGraph 能够保持代码间的关系完整，帮助开发者更深入地理解代码结构和依赖关系。",2,"2026-06-11 03:53:15","trending"]