How does this skill help reduce my agent's token consumption?

ASTra MCP uses tree-sitter to build a local knowledge graph of your code, providing agents with targeted function signatures and PageRank-weighted relevance rather than raw, token-heavy source files.

Which AI agents and IDEs are compatible with ASTra MCP?

It is designed for the Model Context Protocol (MCP) and includes ready-to-use JSON configuration templates for popular IDEs and agents like Claude Code, Cursor, Windsurf, and VS Code.

How does the impact analysis feature help with refactoring safely?

The impact analysis tool calculates the 'blast radius' of a change by identifying all upstream callers and downstream callees that would be affected by refactoring a specific function.

Does my source code need to be uploaded to a cloud service for indexing?

Yes, ASTra MCP processes everything locally, using a local SQLite database for the knowledge graph and a local all-MiniLM-L6-v2 model for embeddings, ensuring your code never leaves your machine.

What are the technical requirements and supported programming languages?

Currently, the skill supports Python, JavaScript, TypeScript, Go, Rust, and Java; you will need Python 3.10+ installed on your system to run the local indexing service.

What exactly is included in the ASTra MCP package?

Your purchase includes the MCP server package, the Astra CLI tool for project initialization, and a suite of configuration templates to get you started immediately.

ASTra MCP: Permanent AST Code Memory

Example session with this skill installed

I need to refactor the login handler in this repo. Help me set up ASTra MCP to find the relevant context and check what might break if I change the signature.

Read your context and instructions
Compiled the astra mcp

Summary

The agent walks you through installing ASTra, indexing your repo, wiring it into your agent config, then uses it to pull targeted context and check the blast radius before the refactor.

Setup commands (run by you)

pip install astra-mcp
cd /path/to/your-project
astra init        # one-time index, about 60s on large repos
astra daemon start  # optional: keeps the graph hot in memory

Config added to `~/.claude/mcp.json` (or project `.mcp.json`)

{
  "mcpServers": {
    "astra": {
      "command": "python3",
      "args": ["-m", "astra.mcp.server"],
      "env": {
        "ASTRA_PROJECT": "/absolute/path/to/your-project",
        "ASTRA_DATA_DIR": "/absolute/path/to/your-project/.astra"
      }
    }
  }
}

Then the agent calls

Step	Tool	Purpose
1	`astra_index_status`	Confirm the index exists and has nodes
2	`astra_get_context("refactor login handler")`	Returns only the relevant symbols, not whole files
3	`astra_get_callers`	Who calls the login handler
4	`astra_impact_analysis`	Blast radius and risk score before you change the signature

Next steps

Restart your agent and check that astra shows as connected
Replace /absolute/path/to/your-project with your real absolute path (relative paths fail in MCP configs)
Run astra bench "refactor login handler" to measure token savings on your own repo

Connects securely to your tools. The creator never sees your data.

About this skill

Navigating large codebases often forces agents to ingest entire files, leading to massive token waste and lost context. This skill integrates ASTra MCP into your workflow, providing a local AST-based knowledge graph that serves the 25 most relevant functions instead of raw source code.

What it does

Persistent memory allows your agent to recall relevant symbols across multiple coding sessions.
Context retrieval fetches targeted code signatures for a specific task using vector search and PageRank.
Impact analysis calculates the blast radius and risk score before you refactor shared functions.
Cross-repo tracing follows function calls across different repositories to maintain visibility.
Semantic search finds functions based on their behavior rather than just their names.

How it works

Initialize the project by running astra init to parse code into a local SQLite knowledge graph.
Configure the agent using provided JSON templates for Claude Code, Cursor, Windsurf, or VS Code.
Query the graph using astra_get_context to receive a ranked list of relevant symbols for a new task.
Verify edits by running astra_impact_analysis to identify all callers and callees affected by a change.

Frameworks & tools

Built for Python, JavaScript, TypeScript, Go, Rust, and Java. It uses tree-sitter for parsing and all-MiniLM-L6-v2 for local embeddings.

Why this beats prompting it yourself

Manual prompting cannot index an entire repository or calculate PageRank for symbol relevance. This skill automates the retrieval of high-signal context, reducing token usage by up to 98% compared to reading full files.

Use cases

Adding features to large, unfamiliar repositories without reading every file.
Performing safe refactors by checking the blast radius of a function change.
Finding logic bugs in functions where the name does not match the behavior.
Tracing complex call chains across multiple internal dependencies.

Known limitations

Supports only Python, JS, TS, Go, Rust, and Java. Requires Python 3.10+ and an initial 80MB download for the embedding model. Absolute paths are required in MCP configurations.

How to use

Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.

Reviews

No reviews yet

Be one of the first to try it. Every listed skill passes our trust checks below.

Security scanned

Passed our 8-point scan before listing

Fresh listing

Recently published to Agensi

Free forever

No account required to browse

ASTra MCP: Permanent AST Code Memory