Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    ASTra MCP: Permanent AST Code Memory

    0

    Set up ASTra, a 100% local AST knowledge graph MCP server, so your agent gets the 5-25 most relevant functions instead of whole files.

    Free

    1 useSecurity scanned
    ASTra MCP: Permanent AST Code Memory

    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

    StepToolPurpose
    1astra_index_statusConfirm the index exists and has nodes
    2astra_get_context("refactor login handler")Returns only the relevant symbols, not whole files
    3astra_get_callersWho calls the login handler
    4astra_impact_analysisBlast 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

    1. Initialize the project by running astra init to parse code into a local SQLite knowledge graph.
    2. Configure the agent using provided JSON templates for Claude Code, Cursor, Windsurf, or VS Code.
    3. Query the graph using astra_get_context to receive a ranked list of relevant symbols for a new task.
    4. 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.

    Supports Python, JS/TS, Go, Rust, and Java only. Requires Python 3.10+. First run requires an 80MB download. MCP configs require absolute file paths.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 28 days ago

    • Free with an Agensi account

    Requires

    Python 3.10+
    pip
    Astra (Pip Install Astra Mcp) MCP
    Python
    Git

    Permissions

    Read Files
    Network Access
    Terminal / Shell
    Write Files

    Shell: the skill tells the agent to run pip install astra-mcp and the astra CLI (astra init, astra query), always after asking the user. Read Files: ASTra parses the project folder set in ASTRA_PROJECT. Write Files: it writes its index to the .astra folder in that project (delete the folder to remove everything). Network: pip install, plus a one-time ~80MB download of the local embedding model; after that it works offline. No telemetry, no API keys, no secrets.

    Listed28 days ago

    What's inside

    Frequently Asked Questions

    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.

    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.

    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.

    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.

    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.

    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.

    New in LLM Ops