# ahmedxuhri/bigindexer [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/ahmedxuhri/bigindexer  
**GitHub Stars:** 3  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/ahmedxuhri-bigindexer

## Description
Hierarchical code intelligence for AI coding agents. Scans local source code, clusters files by behavioral roles, maps coupling seams, and provides in-repo twins/context for complex implementation tasks.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "bigindexer": {
    "command": "uvx",
    "args": ["bigindexer"]
  }
}
```

## Documentation

## What ahmedxuhri/bigindexer MCP server does

The ahmedxuhri/bigindexer MCP server is a static analysis tool for organizing large repositories around behavioral relationships rather than only syntax or imports. It examines local source files, assigns behavior-oriented tokens to code units, connects units with scoped key-lock relationships, and groups them into bounded clusters.

The resulting structure is intended to make likely component boundaries and risky coupling seams easier to inspect. It can also produce machine-readable graph files such as `bgi-graph.json` and `fuse-graph.json`, along with optional human-readable context in `bigindexer.md`. Additional output formats mentioned by the project include routes, GraphML, and HTML.

For AI-assisted implementation tasks, the project exposes `task_fingerprint`, `behavioral_twins`, and `twin_context`. These capabilities help identify comparable code already present in the repository and provide context based on those in-repo patterns.

## How it works

Analysis is organized into three gates. The first classifies unit behavior using repository token frequencies and language-specific extraction. The second creates behavioral edges while applying scope rules that can limit matching globally, by directory, or within a file. The third forms clusters with a hard size cap and records refused merges as fuse events, which serve as possible architectural boundary signals.

The project uses Tree-sitter query-backed extraction for Python, TypeScript, TSX, JavaScript, Go, Rust, Java, C#, PHP, Ruby, Kotlin, and Scala. C, Lua, and Elixir use scanner and rule paths. Several other languages, including Swift, R, Dart, Bash, Nim, Zig, Haskell, and others, use generic extension-based regex fallback. This tiering is relevant when evaluating result reliability and cross-file edge density.

## Setup and configuration

The README documents installation with Python package version `0.1.3`:

```bash
pip install bigindexer==0.1.3
```

The MCP process can then be started with the `bgi mcp` command and paths to the generated graph artifacts:

```bash
bgi mcp --graph bgi-graph.json --fuse-graph fuse-graph.json
```

A local scan can be run with a language selection and output path, for example:

```bash
bgi scan tests/fixtures --lang python --out /tmp/bgi-example.json
```

The repository also publishes an MCP Registry identifier, `io.github.ahmedxuhri/bigindexer`. The provided material does not specify client-specific configuration for Claude Desktop, Cursor, Windsurf, or Cline.

## Tools and capabilities

The ahmedxuhri/bigindexer MCP server supports these documented agent-facing capabilities:

- Generate a task fingerprint from an implementation request.
- Retrieve behavioral twins: code units with related behavior in the same repository.
- Build twin context for use in AI coding prompts.
- Surface coupling seams and fuse-boundary signals between clusters.
- Emit graph artifacts for automation and architecture inspection.
- Scan multiple programming languages using tiered extraction paths.

## Limitations and notes

BGI performs static analysis and does not consume runtime traces. Cross-file semantic resolution is heuristic and depends on the language tier. Query-backed languages generally provide stronger extraction than generic regex fallback, while tier-2 scanners may produce fewer cross-file behavioral edges because some structural tokens are intentionally constrained to same-file matching.

The project reports cluster-size and validation measurements, but the README states that a complete external precision-and-recall benchmark has not yet been published. The provided benchmark evidence also includes mixed results by language, so architecture findings should be reviewed rather than treated as definitive dependency truth.

_Full upstream README: https://allmcps.com/mcp/ahmedxuhri-bigindexer/readme_