Flyto Indexer

Flyto Indexer is a local MCP server that provides code impact analysis, cross - project dependency tracking, and code health scoring for AI assistants, helping developers understand potential impacts before modifying code and avoid destructive changes.

Developer tools Artificial intelligence chatbots #Code Analysis #Dependency Tracking #Impact Assessment #Code Health .Python

rating : 2.5 points

downloads : 0

update time : 2026-03-12

Open Site

What is Flyto Indexer?

Flyto Indexer is an intelligent code analysis tool specifically designed for AI assistants. It builds a code dependency graph through static analysis, enabling AI to understand the potential impacts of code changes and make safer modification decisions. Different from traditional text search, it can track function call relationships, cross - project dependencies, and API usage.

How to use Flyto Indexer?

Just two simple steps: install the package and run the setup command. Flyto Indexer will automatically scan your project, build a code index, and configure MCP clients such as Claude Code. After that, the AI assistant can use all analysis tools.

Applicable scenarios

Flyto Indexer is particularly suitable for the following scenarios: evaluating the impact scope when refactoring code, finding all call points when renaming functions or variables, understanding front - end callers when modifying APIs, evaluating the health of the codebase, and planning complex change tasks.

Main Features

Impact Analysis

The core function, which analyzes the potential impacts of code changes. It shows all call points of functions, classes, or variables, including cross - project references, and evaluates the risk level of changes.

Cross - Language API Tracking

Automatically associates back - end API endpoints with front - end callers. It supports multiple frameworks such as Python (FastAPI/Flask) and TypeScript/Vue (fetch/axios).

Code Health Scoring

Evaluates the overall health of the codebase, including complexity, dead code, documentation integrity, and modularity, and provides a grade from A - F.

Security Scan

Detects security risks in the code, such as hard - coded API keys and SQL injection risks, and reports them classified by severity.

Task Analysis

Conducts a risk assessment before code changes, analyzes tasks from 6 dimensions (explosion radius, destruction risk, etc.), and generates an execution plan.

Dependency Graph

Visualizes the import/export relationships between files, builds a complete dependency graph, and helps understand the code structure.

Advantages

Zero - dependency, implemented in pure Python, runs 100% locally to protect code privacy

Supports multiple programming languages: Python, TypeScript/JavaScript, Vue, Go, Rust, Java

Intelligent incremental indexing, only re - scans changed files, fast

Seamlessly integrates with mainstream MCP clients: Claude Code, Cursor, Windsurf, etc.

Provides 32 dedicated tools covering all aspects of code analysis

Limitations

Only supports static analysis, cannot track dynamic imports and metaprogramming

Limited type inference for complex TypeScript generics

Cross - project tracking requires indexing all projects together

Requires regular re - scanning to keep the index up - to - date

How to Use

Install the Package

Install the Flyto Indexer package using pip

Set Up the Project

Run the setup command in the project root directory to automatically scan and configure

Restart the Client

Restart your MCP client (such as Claude Code)

Start Using

The AI assistant can now use all analysis tools

Usage Examples

Safely Rename a Function

Before renaming a function, analyze all call points to avoid missing cross - project references

Evaluate the Impact of API Changes

Before modifying a back - end API, understand which front - end components will be affected

Code Health Check

Regularly check the health of the codebase and identify parts that need refactoring

Plan a Complex Refactoring

Before conducting a large - scale refactoring, develop a detailed execution plan

Frequently Asked Questions

Will Flyto Indexer send my code to the cloud?

Which programming languages are supported?

How to update the index?

Can it be used in CI/CD?

How to uninstall?

How much storage space is required?

Related Resources

GitHub Repository

Source code, issue tracking, and contribution guidelines

PyPI Page

Package release page and version history

MCP Protocol Documentation

Official specification of the Model Context Protocol

Claude Code

Claude code editor supporting MCP

🚀 Flyto Indexer

Know what breaks before you change it. A MCP server that provides AI assistants with impact analysis, cross - project reference tracking, and code health scoring. Zero dependencies, pure Python, and 100% local.

🚀 Quick Start

Without Flyto Indexer

You:    "Rename validateOrder to validate_order"

AI:     *renames the function*
        *greps for "validateOrder"*
        *finds 3 matches in the same project*
        *misses 4 callers in the frontend repo*
        *misses the API endpoint that routes to it*
        *pushes broken code*

With Flyto Indexer

You:    "Rename validateOrder to validate_order"

AI:     → impact_analysis("validateOrder")

        ⚠️ 7 call sites across 3 projects:
          backend/checkout.py:42     — calls validateOrder()
          backend/api/orders.py:18   — imports validateOrder
          frontend/Cart.vue:55       — calls via useCheckout()
          frontend/QuickBuy.vue:23   — calls via useCheckout()
          mobile/OrderScreen.tsx:67  — API call to /api/validate
          tests/test_orders.py:12    — unit test
          tests/test_api.py:88       — integration test
          Risk: HIGH — 3 projects affected

        → edit_impact_preview("validateOrder", change_type="rename")
        *renames all 7 call sites, updates tests, pushes clean code*

That's the difference. grep finds text. This finds dependencies.

📦 Installation

Standard Installation

pip install flyto-indexer
flyto-index setup .

That's it. One command does everything:

Scans your project and builds the code index
Writes CLAUDE.md with tool usage instructions
Configures Claude Code MCP settings (~/.claude/settings.json)

Restart Claude Code and start using it. Works with any MCP client — Claude Code, Cursor, Windsurf, etc.

Manual setup (other MCP clients)

If your MCP client doesn't use ~/.claude/settings.json, add this to your MCP config:

{
  "mcpServers": {
    "flyto-indexer": {
      "command": "python3",
      "args": ["-m", "flyto_indexer.mcp_server"]
    }
  }
}

Then scan and set up CLAUDE.md separately:

flyto-index scan .
flyto-index setup-claude .

Run from source

git clone https://github.com/flytohub/flyto-indexer.git
cd flyto-indexer && pip install -e .
flyto-index setup .

Uninstall

flyto-index setup . --remove
pip uninstall flyto-indexer

✨ Features

Impact Analysis — the core feature

Every tool an AI already has (grep, file read, glob) finds text. None of them answer "what depends on this?"

impact_analysis builds a reverse dependency graph and tells you exactly what breaks:

→ impact_analysis("useAuth")

  12 references across 4 projects:
    flyto-cloud:  LoginPage.vue, RegisterPage.vue, AuthGuard.ts, api.ts
    flyto-pro:    vscode_agent/tools.py, middleware/auth.py
    flyto-vscode: ChatHandler.ts, AuthProvider.ts
    flyto-core:   modules/auth/login.py
  Risk: HIGH — shared across 4 projects

→ edit_impact_preview("useAuth", change_type="signature_change")
  Shows exact code lines at each call site that need updating.

Cross-Language API Tracking

Python backend endpoints are automatically linked to TypeScript/Vue frontend callers:

→ list_apis()

  POST /api/checkout
    Defined in: backend/routes/order.py (create_order)
    Called by:   frontend/Cart.vue, frontend/api/orders.ts
    Call count: 4

It detects FastAPI, Flask, Starlette decorators + fetch(), axios, $http calls.

Code Health & Security

→ code_health_score()            → security_scan()

  Score: 74/100 (C)               2 critical: hardcoded API keys
  Complexity:    22/25             1 high: SQL string concatenation
  Dead code:     18/25             0 medium
  Documentation: 16/25
  Modularity:    18/25

→ suggest_refactoring()

  [high]   process_data() — 87 lines, depth=6 → extract sub - functions
  [medium] dead_fn() — unreferenced, 45 lines → safe to remove
  [low]    utils.py — 800 lines → split into focused modules

Task Analysis — plan before you code

analyze_task scores risk across 6 dimensions and generates an execution plan with concrete tool call sequences:

→ analyze_task("Rename validateOrder to validate_order", intent="refactor")

  Dimensions:
    blast_radius:      HIGH (8.0)  — 7 callers across 3 projects
    breaking_risk:     HIGH (7.0)  — public API, used by external consumers
    test_risk:         MEDIUM (5.0) — 2/7 callers have test coverage
    cross_coupling:    HIGH (8.0)  — referenced in 3 projects
    complexity:        LOW (2.0)   — straightforward rename
    rollback_difficulty: MEDIUM (5.0) — multi - project change

  Strategy: safe_refactor (upgraded from minimal_diff due to blast radius)

  Execution Plan:
    1. scope_callers       → find_references("validateOrder")
    2. verify_test_coverage → find_test_file("checkout.py")
    3. check_cross_project → cross_project_impact("validateOrder")
    4. gate_before_plan    → task_gate_check(phase="plan")
    5. preview_changes     → edit_impact_preview("validateOrder", "rename")
    6. gate_before_apply   → task_gate_check(phase="apply")

Each step has pre - filled arguments and dependencies — AI follows the data structure, not prompts.

💻 Usage Examples

Tools

32 MCP tools. Organized by what they do:

Impact & Dependencies

Tool	What it answers
`impact_analysis`	"What breaks if I change this?"
`impact_from_diff`	"What's the blast radius of my uncommitted changes?"
`find_references`	"Who calls this function?" (with file + line)
`cross_project_impact`	"Which other repos use this?"
`edit_impact_preview`	"Show me the exact lines affected by this rename"
`dependency_graph`	"What does this file import / what imports it?"

Task Analysis

Tool	What it answers
`analyze_task`	"What's the risk profile and execution plan for this change?"
`task_gate_check`	"Is it safe to proceed to the next phase?"

Code Quality

Tool	What it answers
`code_health_score`	"How healthy is this project?" (0 - 100, A - F)
`security_scan`	"Any hardcoded secrets or injection risks?"
`find_dead_code`	"What's safe to delete?"
`find_complex_functions`	"Which functions need refactoring?"
`suggest_refactoring`	"What should I fix first?"
`find_duplicates`	"Where's the copy - pasted code?"
`find_stale_files`	"What hasn't been touched in months?"
`find_todos`	"What's the tech debt backlog?"

All 32 tools (including search, metadata, session, task analysis)

Search & Discovery

Tool	Description
`search_code`	BM25 - ranked symbol search
`get_symbol_content`	Full source of a function/class
`get_file_symbols`	All symbols in a file
`get_file_info`	File purpose, category, keywords
`get_file_context`	One - call: symbols + deps + test file
`fulltext_search`	Search comments, strings, TODOs

Project Overview

Tool	Description
`list_projects`	Indexed projects with stats
`list_categories`	Code categories (auth, payment...)
`list_apis`	API endpoints + cross - language callers
`check_index_status`	Is the index fresh or stale?

File Metadata

Tool	Description
`find_test_file`	Source → test file mapping
`get_description`	Semantic one - liner for a file
`update_description`	Write/update file description

Session & Indexing

Tool	Description
`session_track`	Track events for search boosting
`session_get`	Inspect session state
`check_and_reindex`	Detect changes + live reindex
`impact_from_diff`	Git diff → symbol impact analysis

Task Analysis

Tool	Description
`analyze_task`	Multi - dimensional risk assessment with execution plan
`task_gate_check`	Phase gate validation before proceeding

Languages

Language	Parser	Extracts
Python	AST	Functions, classes, methods, decorators, API routes
TypeScript/JS	Custom	Functions, classes, interfaces, types, API calls
Vue	SFC	Components, composables, emits, props
Go	Custom	Functions, structs, methods, interfaces
Rust	Custom	Functions, structs, impl blocks, traits
Java	Custom	Classes, methods, interfaces, annotations

🔧 Technical Details

How It Works

flyto-index scan .

Parse — AST (Python) or regex (others) extracts every function, class, and import
Graph — Builds dependency graph + reverse index (caller → callee)
Serve — MCP server answers queries from the graph in memory
Incremental — Re - scans only changed files (content hash tracking)

.flyto-index/
├── index.json       # Symbols + dependency graph + reverse index
├── content.jsonl    # Source code (lazy - loaded)
├── bm25.json        # Search index
└── manifest.json    # Change tracking

CI: Block Risky Changes

# Fail the PR if changes affect too many call sites
- run: pip install flyto-indexer
- run: flyto-index scan .
- run: flyto-index check . --threshold medium --base main

CLI

flyto-index setup .                       # One command: scan + CLAUDE.md + MCP config
flyto-index scan .                        # Index (or re - index)
flyto-index impact useAuth --path .       # Impact analysis
flyto-index check . --threshold medium    # CI gate
flyto-index demo .                        # 30 - second demo
flyto-index install-hook .                # Auto - reindex on commit
flyto-index setup . --remove              # Uninstall