Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Enterprise-RAG-Architect

    1

    Critical principal architect for Tri-Hybrid RAG, enterprise caching, vector DB internals, zero-regex security, and TDD workflows.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Enterprise-RAG-Architect

    Enterprise-RAG-Architect

    Example session with this skill installed

    I need to build a RAG system for 100k technical manuals. I'm using Python and ChromaDB, but I'm worried about filtering by department ID. Can you review this stack?

    • Read your context and instructions
    • Compiled the enterprise-rag-architect

    I have audited your proposed stack. ChromaDB's post-filtering will likely cause recall collapse (k-starvation) as your department-specific document subsets grow. I recommend switching to a database that supports filterable HNSW with Roaring Bitmaps for sub-millisecond ACL pruning.

    Architectural Audit & Recommendations

    LayerProposed StackIdentified RiskRecommended Alternative
    Vector StorageChromaDBRecall collapse on strict filtersQdrant (Filterable HNSW)
    ACL FilteringMetadata Post-filterO(n) latency scalingRoaring Bitmaps (uint32 bitsets)
    IngestionNaive Regex CleaningSilent formula truncationDocling (Structural Parsing)
    RetrievalSingle VectorLow recall on part numbersTri-Hybrid (BM25 + Dense + Graph)
    from pydantic_settings import BaseSettings, SettingsConfigDict
    from pydantic import Field
    
    class EnterpriseRAGConfig(BaseSettings):
        model_config = SettingsConfigDict(env_prefix="RAG_ARCH_", frozen=True)
    
        # Vector DB Internals
        vector_db_url: str = Field(..., description="Qdrant/Milvus endpoint")
        enable_roaring_bitmaps: bool = Field(default=True)
        
        # Retrieval Hyperparameters
        dense_top_k: int = Field(default=10, ge=1, le=50)
        sparse_boost: float = Field(default=1.5, ge=0.0)
        
        # Security Delimiters
        sandbox_tag_prefix: str = Field(default="context_layer_")
    

    Next steps

    1. Review Blueprint: I have generated a detailed performance matrix in docs/plans/architecture_comparison.md.

    Select Mode: Reply auto to scaffold the Qdrant-based retrieval engine with Roaring Bitmap integration, or interactive to tune the embedding model selection.
    3. Verify Compliance: Run pytest tests/security to validate the zero-regex sanitization layer.

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

    About this skill

    Production RAG systems fail when naive vector lookups meet complex enterprise requirements like strict ACLs and technical nomenclature. This skill acts as a principal AI architect to design, benchmark, and harden RAG systems. It replaces fragile regex-based cleaning and sequential retrieval with concurrent pipelines, Roaring Bitmap filtering, and multi-tier caching.

    What it does

    • Tri-Hybrid Architecture designs concurrent retrieval pipelines combining Lexical (BM25), Semantic (Dense), and Relational (GraphRAG) brains.
    • Advanced Filtering implements Roaring Bitmap indexes and pre-filtering to prevent recall collapse during metadata or ACL lookups.
    • Enterprise Caching builds four-tier systems including exact L2 hits, L3 semantic vector caching, and content-addressable ingestion caches.
    • Security Hardening enforces zero-regex text processing and structural prompt-injection shielding using randomized XML sandboxing.
    • Infrastructure Benchmarking generates comparison matrices for vector databases (Qdrant, Milvus, pgvector) and model providers based on latency and cost.

    How it works

    1. Discovery & Audit analyzes your current stack to identify bottlenecks like sequential retrieval or post-filtering pitfalls.
    2. Architecture Blueprinting generates a formal plan in docs/plans/ documenting tech stack selections and performance targets.
    3. Implementation & Auto-Mode scaffolds modular codebases or autonomously selects optimal defaults when you invoke auto.
    4. Verification Gate runs unit and integration tests using condition-based polling instead of fragile delays.

    Frameworks & tools

    Python, Node.js, TypeScript, Qdrant, Milvus, Redis, Valkey, Docling, GLiNER, Pydantic, Zod, and various LLM providers.

    Why this beats prompting it yourself

    Generic prompts often produce naive LangChain wrappers that suffer from "k-starvation" and security debt. This skill enforces strict engineering mandates like zero-regex processing and deterministic invalidation protocols that standard LLMs overlook.

    Use cases

    • Building a technical document assistant for 500k+ PDFs requiring per-department access control.
    • Migrating a prototype RAG app to a production-grade system with sub-millisecond candidate pruning.
    • Auditing a codebase to replace fragile regex cleaners with structural parsers for academic or symbolic text.

    Known limitations

    Requires a local or containerized runtime to execute live vector database latency benchmarks and integration test suites.

    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 a local or containerized runtime to execute live vector database latency benchmarks and integration test suites.

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

    Software
    uv (Python tool runner)pytestDocker

    Permissions

    Network Access
    Terminal / Shell
    Write Files
    Read Files
    Environment Variables

    File Scopes

    src/**
    tests/**
    frontend/**
    docs/plans/**
    docs/**
    *.md
    backend/**
    Listed22 days ago

    What's inside

    Frequently Asked Questions

    It turns your coding agent into an expert principal AI systems architect. It guides you step-by-step through designing, benchmarking, securing, and testing production-grade Tri-Hybrid GraphRAG systems without hallucinating or taking shortcuts.

    Not at all! The skill covers both free, self-hosted open-weights models (like local GLiNER, BAAI/bge-m3, and Ollama/Groq setups) and commercial APIs, allowing you to build entirely on local hardware if you have strict privacy or zero-budget constraints.

    It follows the open universal SKILL.md standard and works seamlessly with Claude Code, Cursor, GitHub Copilot, Gemini CLI, Codex CLI, and 20+ other compatible agent platforms.

    The skill automatically adapts to your tech stack. If you prefer Python end-to-end, it structures Streamlit dashboards; if you want a custom web app, it scaffolds decoupled React/Next.js frontends with FastAPI or Node.js backends.

    This skill addresses 'k-starvation' and recall collapse by replacing naive vector lookups with a Tri-Hybrid architecture that integrates GraphRAG, Roaring Bitmap filtering, and zero-regex structural parsing for enterprise-grade precision.

    The skill is optimized for Python and Node.js/TypeScript environments and supports major vector databases including Qdrant, Milvus, and pgvector, as well as Redis or Valkey for caching layers.

    While the skill provides a comprehensive blueprint and modular code scaffolding, you will need a local or containerized environment to execute the live latency benchmarks and integration test suites it generates.

    You receive a principal-level AI architect capable of auditing existing stacks, generating formal performance blueprints, and scaffolding production-ready retrieval pipelines with built-in security shielding.

    Unlike generic prompts, this skill enforces deterministic invalidation protocols and randomized XML sandboxing to protect against prompt injection and metadata leakage, ensuring strict ACL compliance at scale.

    If you aren't sure which vector database, bitmap index, or caching tier to pick, you can simply type "auto". The skill will explain the trade-off in two plain sentences and autonomously lock in the highest-performing enterprise default for your hardware.

    Yes! The skill includes production blueprints for ingesting dense academic PDFs, extracting local knowledge graphs from research papers, and running tri-hybrid search for study materials and lecture notes.

    Not at all. It is built to run entirely on local student hardware (like a standard laptop or college VM) using free open-weights models and local vector stores, requiring zero budget for paid cloud APIs.

    Yes! While it implements advanced enterprise patterns under the hood, you can type "auto" at any time and the skill will make the technical decisions for you while explaining how everything works along the way.

    It utilizes distributed vector databases (such as Qdrant or Milvus) with sharded HNSW/DiskANN indexes, paired with async concurrency throttling (asyncio.Semaphore) and SIMD-accelerated Roaring Bitmaps for sub-millisecond multi-tenant access control (ACL) filtering.

    The orchestration layer executes all retrieval brains concurrently using asyncio.gather with isolated error catching. If a single retrieval brain (such as the knowledge graph or sparse index) times out or fails, the system logs the exception without dropping successful results, gracefully degrading to the operational brains.

    Ingestion pipelines enforce strict async semaphore concurrency bounds, memory-efficient streaming, and windowed token splitting (e.g., 350-token GLiNER windows with 50-token overlap) to prevent silent truncation and keep CPU/RAM usage strictly bounded during batch uploads.

    By deploying a robust 4-tier enterprise caching strategy covering L1 in-process memory, L2 Redis exact normalized query caches, L3 tenant-isolated semantic vector caches ($\ge 0.96$ similarity pre-filtered by ACL bitmaps), and L4 content-addressable SHA-256 chunk embedding caches.

    New in LLM Ops