Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    piim

    1

    Persistent high-performance memory for local codebases using hybrid semantic search and atomic context offloading.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    piim

    piim

    Example session with this skill installed

    Index the current project's auth logic. Start by describing src/auth.rs and its main validation function, then store our JWT naming convention.

    • Read your context and instructions
    • Compiled the piim

    I have indexed the authentication logic and stored the project-specific coding standards in the memory system.

    Project Memory Indexing

    ActionIDCategoryStatus
    Save Filesrc/auth.rsfile✅ Indexed
    Save Functionsrc/auth.rs::validate_jwtfunction✅ Indexed
    Upsert Infojwt_naming_conventioncodestyle✅ Stored

    Memory Summary Update

    • Total records added: 3
    • Hash check: SHA-256 verified (no duplicates)
    • Search accessibility: Ready for hybrid retrieval

    Next steps

    • Run hybrid_search_memory with the query "JWT token validation" to verify retrieval performance.
    • Use memory_stats to see the updated distribution of records across the auth project.
    • Index the remaining files in src/ to complete the architectural map.

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

    About this skill

    Stop losing track of architectural decisions and function contracts as your project grows. Context windows are finite, and re-reading the entire codebase every time you start a new task is a waste of tokens and compute.

    This skill provides a high-performance, persistent long-term memory system designed for local repositories. It offloads documentation, code contracts, and architectural rules into a dedicated database, allowing for targeted retrieval without bloating your active context.

    What it does

    • Atomic context storage saves architectural summaries, code styles, and interface contracts as discrete, searchable records.
    • File and function indexing stores descriptions of source files and specific methods to enable rapid symbol discovery.
    • Hybrid search combines semantic vector embeddings with keyword-based FTS to locate relevant logic across one or all projects.
    • Automatic deduplication uses SHA-256 hashing to skip expensive GPU embedding inference when content hasn't changed.
    • Database maintenance provides tools for file compaction and record batch merging to keep lookups at low latency.

    How it works

    1. Initialize by walking the source tree and using save_file_description and save_function_description to index core components.
    2. Offload architectural rules and code standards via upsert_project_info to keep the system prompt clean.
    3. Query the memory using hybrid_search_memory when entering an unfamiliar part of the codebase to fetch only the necessary definitions.
    4. Maintain the system by running memory_stats to monitor growth and optimize_database to ensure peak performance.

    Frameworks & tools

    Built with a Rust-based actor system and Arrow record batches. It uses SHA-256 hashing for change detection and supports semantic vector search alongside BM25 keyword matching.

    Why this beats prompting it yourself

    Standard prompting forces you to choose between incomplete context or massive token costs. This skill enables a "just-in-time" context strategy where the agent only sees what it needs for the current task, reducing errors and costs.

    Use cases

    • Onboarding to new repos by generating and storing a high-level map of all files and functions.
    • Enforcing code standards by retrieving project-specific linting and naming rules before every edit.
    • Tracking technical debt by storing and retrieving structural bugs and TODOs without keeping a massive text file open.
    • Cross-project discovery by searching for shared logic or utilities across multiple repositories using the global project scope.

    Known limitations

    Hybrid search requires domain-vocabulary queries. Bare symbol names or verbatim phrases may return unrelated records if they lack semantic context. Search is vocabulary-driven.

    Requires domain-vocabulary queries for hybrid search. Bare symbol names or verbatim phrases may yield poor results. Search performance depends on descriptive metadata rather than raw code.

    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 16 days ago

    Requires

    Piim MCP

    Permissions

    Read Files
    Write Files
    Listed16 days ago

    What's inside

    Frequently Asked Questions

    Piim is a persistent memory layer that offloads project-specific documentation, architectural rules, and code contracts into a dedicated database, preventing token bloat while keeping your agent informed on large repos.

    This skill is designed to work with any local AI agent or IDE extension that supports tool calling, providing standardized functions to index and query your codebase dynamically.

    Setup involves initializing the skill within your project directory, where it will automatically walk your source tree and create a high-performance vector database optimized for your local machine.

    Piim uses SHA-256 hashing to detect file changes, ensuring it only re-indexes modified content to save on compute and maintain low-latency search performance.

    The skill utilizes a hybrid search approach, combining semantic vector embeddings for conceptual matching with keyword-based FTS (Full-Text Search) for precise symbol and variable discovery.

    Your purchase includes the full Piim skill set, featuring tools for atomic context storage, hybrid search, and database maintenance, along with all necessary Rust-based binaries for local execution.

    1. Ensure you have **Rust (cargo)** installed on your machine. 2. Clone the repository and build the binary in release mode: ```bash git clone https://github.com/serejkaaa512/project-info-in-mcp cd project-info-in-mcp cargo build --release ``` 3. The executable will be available at `./target/release/project-info-in-mcp`.

    Add the binary path to your agent's MCP configuration file (e.g., `mcp.json` or `config.json`) along with the required environment variables: ```json { "mcpServers": { "piim": { "command": "/absolute/path/to/project-info-in-mcp", "env": { "PROJECT_NAME": "your_project_name", "EMBEDDING_PROVIDER": "fastembed", "DATABASE_PROVIDER": "lancedb" } } } } ``` * **Claude Code / Cursor:** Add this block to your global or project-specific `mcp.json`. * **Zed:** Add it to your `settings.json` under the `"extensions": { "mcp": { ... } }` object. * **OpenClaw / Claude Desktop:** Insert it into your main client configuration file.

    * **Choose FastEmbed (Local):** For **maximum privacy, zero API bills, and offline work**. It runs embedding inference directly on your local hardware using efficient CPU/GPU runtimes. * **Choose a separate model (API):** If your local machine is highly resource-constrained, or if you prefer offloading vector generation to cloud providers (like OpenAI or Cohere) for slightly higher embedding accuracy at the cost of network latency and API usage fees.

    New in LLM Ops