Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    duker brain

    1

    Dynamic context routing and hierarchical Obsidian vault memory for coding agents via the duker-brain MCP server.

    $1

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    duker brain

    duker brain

    Example session with this skill installed

    Check the brain for our project conventions on asyncpg pooling and then update the database connection module.

    • Read your context and instructions
    • Compiled the duker brain

    I have queried the project memory to retrieve our specific conventions for asyncpg.

    Project Context Retrieval

    Note IDTitleRouting Criteria
    asyncpg_poolingasyncpg Connection PoolingPostgreSQL connections, asyncpg pool sizing, PgBouncer transaction mode, statement cache errors

    Based on the retrieved guide, I will now update the database connection module to use min_size=5 and max_size=20 as per our internal production standards, ensuring we avoid the statement cache errors mentioned in the project memory.

    import asyncio
    import asyncpg
    
    async def run():
        # Applying project-specific pooling conventions from asyncpg_pooling guide
        pool = await asyncpg.create_pool(
            dsn='postgres://user:pass@host:port/db',
            min_size=5,
            max_size=20,
            max_queries=50000,
            max_inactive_connection_lifetime=300.0,
            setup=None # Statement caching disabled per ADR-04
        )
        return pool
    

    Next steps

    1. Run brain_doctor to ensure no criteria conflicts were introduced if you decide to add more notes.
    2. Verify the pool lifespan settings match the latest PgBouncer deployment by checking the infrastructure folder in the vault.
    3. Call brain_check_routing with "how do we handle pg errors" to confirm this note remains the primary target.

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

    About this skill

    Context window limitations often lead to agents forgetting project-specific architectural decisions, library quirks, and internal coding standards. This skill integrates an Obsidian-based hierarchical memory vault via the duker-brain MCP server, enabling agents to retrieve and maintain long-term project knowledge.

    What it does

    • Dynamic Context Routing walks an Obsidian folder tree to fetch the specific note matching the user's intent.
    • Hierarchical Memory Management organizes engineering notes into a routable structure with discriminative criteria.
    • Vault Health Auditing uses brain_doctor to detect thin criteria, over-full folders, or missing catch-all notes.
    • Automated Indexing ensures the router's decision model stays in sync with filesystem changes.
    • Conflict Resolution manages sibling notes by rewriting criteria to ensure distinct routing paths.

    How it works

    1. Query: Call brain_route with a natural language request to fetch the relevant technical guide before answering.
    2. Explore: Use brain_tree and brain_search to locate existing documentation and prevent duplicate content.
    3. Write: Author new notes or branches using brain_add_note to automatically generate metadata and update the index.
    4. Optimize: Use brain_split_branch to keep folders under 15 items, maintaining high routing accuracy.
    5. Verify: Run brain_check_routing to test if specific prompts successfully land on the intended note.

    Frameworks & tools

    Built for the Model Context Protocol (MCP) using Node.js (>= 22). It manages markdown-based Obsidian vaults and requires the duker-brain server package.

    Why this beats prompting it yourself

    Standard RAG often retrieves noisy or irrelevant chunks from large files. This skill uses a tree-traversal decision model that picks the single most relevant guide based on specific, human-defined criteria, ensuring the agent follows project-specific rules over generic LLM training data.

    Use cases

    • Documenting team-specific PostgreSQL connection pooling and error handling patterns.
    • Storing architectural decision records (ADRs) that the agent must reference before refactoring.
    • Onboarding new developers by routing their setup questions to the correct environment guides.
    • Managing a growing knowledge base of library-specific gotchas that generic models miss.

    Known limitations

    Requires Node.js 22 or higher. The router's accuracy degrades if folders contain more than 15 children. Routing requires a warm npx cache or local MCP server installation.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    Requires Node.js 22+. Folders are limited to 15 children for routing reliability. Manual file edits require a brain_rebuild call to sync the index.

    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 buying a skill.

    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 1 day ago

    Accounts
    GitHub
    Software
    Node.js
    Optional
    Obsidian

    You can use Obsidian to view the vaults.

    Permissions

    Terminal / Shell
    Write Files
    Read Files
    Network Access
    Environment Variables
    Listed1 day ago

    What's inside

    Frequently Asked Questions

    This skill allows AI agents to navigate a structured Obsidian vault to retrieve project-specific rules, ADRs, and coding standards, solving the problem of agents 'forgeting' architectural decisions or hallucinating generic solutions.

    It is built on the Model Context Protocol (MCP) and is primary compatible with any AI agent or IDE that supports MCP servers, such as Claude Desktop or specialized coding environments.

    Effective routing relies on a clean directory structure; if a folder contains more than 15 items, the decision logic can become cluttered, so it's recommended to use the included 'brain_split_branch' tool to maintain hierarchy.

    No, this skill uses a hierarchical decision-tree model that navigates your vault based on discriminative criteria, which is often more precise than standard RAG for following specific engineering guidelines.

    You will receive the 'duker-brain' MCP server package, documentation on vault structuring, and the suite of routing and auditing tools like 'brain_doctor' and 'brain_route'.

    The skill requires Node.js version 22 or higher and an existing or new Obsidian vault where your markdown-based project knowledge is stored.

    New in LLM Ops