More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    pydoc

    1

    Look up real Python signatures, docstrings, and symbols directly from your local system environment.

    $5

    /mo

    Subscription · cancel anytime

    Secure checkout via Stripe

    • Always the latest version
    • Delivered live to your agent via MCP
    • Cancel anytime, access ends at period end
    Security scanned
    pydoc

    pydoc

    Example session with this skill installed

    /pydoc json.dumps

    • Read your context and instructions
    • Compiled the pydoc

    I have retrieved the documentation and signature for json.dumps from the system Python environment.

    Python Documentation: json.dumps

    AttributeValue
    Fully Qualified Namejson.dumps
    Signaturedumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
    Modulejson
    Return Typestr

    Docstring

    Serialize obj to a JSON formatted str.

    If skipkeys is true then dict keys that are not basic types
    (str, int, float, bool, None) will be skipped
    instead of raising a TypeError.

    If ensure_ascii is false, then the return value can contain non-ASCII
    characters if they appear in strings contained in obj. Otherwise, all
    such characters are escaped in JSON strings.

    If check_circular is false, then the circular reference check
    for container types will be skipped and a circular reference will
    result in an RecursionError (or worse).

    If allow_nan is false, then it will be a ValueError to
    serialize out of range float values (nan, inf, -inf) in
    strict compliance of the JSON specification, instead of using the
    JavaScript equivalents (NaN, Infinity, -Infinity).

    If indent is a non-negative integer, then JSON array elements and
    object members will be pretty-printed with that indent level. An indent
    level of 0 will only insert newlines. None (the default) selects the
    most compact representation.

    Next steps

    • Run /pydoc json.loads to view the deserialization signature.
    • Use /pydoc --list json to see all available functions in the json module.
    • Try /pydoc --find json indent to find where the indent logic is handled.
    $5/mo

    Subscription · always the latest version

    • Secure checkout via Stripe
    • Cancel anytime
    • Delivered live via MCP

    About this skill

    Stop guessing Python API signatures and relying on outdated training data. This skill provides direct access to the documentation, type annotations, and docstrings of any package or module installed in your local Python environment. It introspects the live system to ensure you are writing code against the actual versions currently running on your machine.

    What it does

    • Live Introspection retrieves real docstrings and signatures from the system Python interpreter.
    • Deep Exploration documents nested subtrees of packages, classes, and modules with configurable depth.
    • Symbol Discovery searches for functions, classes, or members using substring, glob, or regex patterns.
    • Structural Listing enumerates the contents of specific packages or the entire top-level environment.
    • Member Filtering isolates specific object types like methods, classes, or functions during searches.

    How it works

    1. Run /pydoc <name> to pull the full signature and docstring for a specific module, class, or function.
    2. Use /pydoc --list to browse available packages or see the internal structure of a specific root.
    3. Use /pydoc --find with a query string to locate a symbol when you only know part of its name.
    4. Apply flags like --private to include internal members or -r to recursively document a whole package.

    Frameworks & tools

    This skill runs on python3 (3.10+ recommended) using the Python standard library. It executes introspection scripts via Bash to query the local environment without external dependencies.

    Why this beats prompting it yourself

    General LLMs often hallucinate parameters or use outdated API versions. This skill queries your specific local installation, giving you the exact signatures and type hints present in your current environment.

    Use cases

    • Verify exact keyword arguments for an installed library function.
    • Explore the internal structure and available methods of a new package.
    • Locate a specific utility function across a large installed codebase.
    • Check type annotations for complex objects to ensure IDE-like accuracy.

    Known limitations

    Requires system python3 (3.10+ recommended). It only sees packages installed in the system environment; virtualenv support is not explicitly provided.

    Requires system python3 (3.10+ recommended). Only queries the system Python environment; no explicit virtualenv or third-party dependency isolation.

    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

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 12 days ago

    Requires

    python3

    Permissions

    Terminal / Shell
    Listed12 days ago

    What's inside

    Frequently Asked Questions

    This skill performs live introspection of your local Python environment to retrieve actual docstrings and type signatures, ensuring you get accurate data for the exact versions of libraries you have installed, rather than relying on potentially outdated or hallucinated AI training data. It ensures that the information comes from python itself every time, instead of trusting the agent not to recall and potentially hallucinate.

    The skill works with any AI agent that has access to your local filesystem and a bash terminal, provided your system is running Python 3.10 or higher.

    Yes, by using the --find flag and applying the --private flag, you can search for and document internal members and private methods that are typically hidden from standard documentation views.

    The skill automatically discovers and introspects any package, module, or class currently installed in your system's Python environment, including third-party libraries installed via pip.

    New in APIs & Backend