Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    CallGraph QA — Agensi Skill Pack

    1

    Analyze, index, and query Python codebases using AST-aware chunking and call-graph enriched RAG.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    CallGraph QA — Agensi Skill Pack

    CallGraph QA — Agensi Skill Pack

    Example session with this skill installed

    Analyze the implementation of the checkout logic in this repo. Explain how it interacts with the payment gateway based on the call graph.

    • Read your context and instructions
    • Compiled the callgraph qa

    I have analyzed the checkout.py and payments/gateway.py modules using AST parsing and graph-expanded retrieval. The semantic search identified the process_checkout function, and graph expansion successfully pulled in the dependent gateway calls.

    Codebase Analysis: Checkout to Payment Flow

    ComponentSymbolLocationRole
    Primary Matchprocess_checkoutservices/checkout.py:45Main entry point for cart finalization.
    Direct Calleevalidate_sessionauth/session.py:12Verifies user token before processing.
    Direct Calleecharge_cardpayments/gateway.py:88External API wrapper for Stripe/Braintree.
    CallerCheckoutAPIView.postapi/views.py:210REST endpoint triggering the service.

    Control Flow Summary

    1. The CheckoutAPIView receives a POST request and calls process_checkout.
    2. process_checkout invokes validate_session to ensure the user is authenticated.
    3. Upon successful validation, the service initializes the PaymentGateway and calls charge_card.
    4. Static analysis shows charge_card is an async function requiring the amount and currency attributes from the Order object.

    Call Graph Context

    The retrieval included charge_card because it is explicitly called within the body of process_checkout. While charge_card did not match the initial semantic query for "checkout logic" as strongly as the service layer, its structural relationship as a callee provides the necessary context to explain the payment integration.

    Next steps

    • Inspect payments/gateway.py for specific error handling logic during API timeouts.
    • Review the Order class definition to verify attribute types passed to the gateway.
    • Verify if the charge_card call is wrapped in a retry decorator.

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

    About this skill

    Traditional RAG often fails on complex codebases because simple text chunks lose the structural context of how functions interact. This skill pack provides a specialized set of tools for structural Python analysis, graph-enriched retrieval, and evidence-based codebase Q&A.

    What it does

    • AST-Aware Analysis parses Python source code to identify functions and classes, ensuring code is never split mid-block.
    • Structural Chunking maintains module paths, qualified symbol names, and line-range metadata for every code segment.
    • Graph Expansion enriches standard vector search results by including immediate callers and callees in the retrieval context.
    • Static Call Extraction walks function bodies to map relationships between symbols without requiring runtime execution.
    • Evidence-Based Q&A answers technical questions about repository behavior using confirmed source citations and data flow tracing.

    How it works

    1. Parse the Python codebase using the ast module to map top-level functions, async definitions, and class methods.
    2. Index code chunks by preserving complete syntactical units and attaching symbol-level metadata.
    3. Query the index using vector similarity, then expand the context window by fetching one-hop graph neighbors (callers/callees).
    4. Synthesize an answer that distinguishes between direct semantic matches and structural graph matches.

    Frameworks & tools

    This tool uses Python's ast module for static analysis. It is designed for RAG systems using vector databases and LLMs, specifically targeting Python repositories with complex call hierarchies.

    Why this beats prompting it yourself

    Generic prompts treat code as raw text, leading to broken context and "lost" logic when functions span multiple chunks. This skill enforces structural integrity and graph-based relationships, ensuring the agent sees the code's execution path rather than just disconnected snippets.

    Use cases

    • Codebase Onboarding to map out where specific features are implemented in an unfamiliar repository.
    • Root Cause Analysis to trace data flow from entry points to bug-prone utility functions.
    • RAG System Design to architect code-aware retrieval pipelines that use structural graph context.
    • Dependency Mapping to identify which functions will be impacted by a refactor or change.

    Known limitations

    Does not support full type inference or dynamic dispatch resolution. Limited to Python source code. Graph expansion is restricted to one-hop caller/callee relationships based on static function names.

    Supports Python only. Static analysis cannot resolve dynamic dispatch, monkey-patching, or decorators. Graph expansion is restricted to one-hop caller/callee relationships.

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed today

    Requires

    Python
    Node.js

    Permissions

    Read Files
    Terminal / Shell
    Listedtoday

    What's inside

    Frequently Asked Questions

    Unlike standard RAG that chunks code by line count, this skill uses Abstract Syntax Tree (AST) parsing to ensure functions and classes stay together, preserving the structural integrity of your logic.

    This skill is purpose-built for Python repositories and uses the native `ast` module to map out relationships between functions, methods, and classes.

    The package includes a suite of specialized tools for AST parsing, structural indexing, and graph-enriched retrieval logic designed to be integrated into your agent's workflow.

    Yes, it is designed for static analysis and does not require you to execute the code, making it ideal for analyzing repositories without setting up a full runtime environment.

    This skill works with any RAG-enabled agent that supports tool-calling and can connect to a vector database for storing the structural chunks and metadata.

    The current version supports 'one-hop' expansion, meaning it retrieves the direct callers and callees of a function to provide context on how that specific piece of code is used.

    New in LLM Ops