Personal Rag Builder

    1

    Build a private, local RAG system to index and search your files and repos without using third-party APIs.

    $9

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    personal-rag-builder

    Example session with this skill installed

    Build a local RAG index for my 'projects/docs' folder using BM25 for keyword search.

    • Read your context and instructions
    • Compiled the personal-rag-builder

    I have initialized a local RAG index for your documents. The system has processed 42 files into 156 chunks and created a BM25 keyword index stored in your local directory.

    Local RAG Index Summary

    ComponentStatusDetails
    Source PathActive/projects/docs
    Total ChunksCompleted156 chunks (approx 300 words each)
    Index TypeActiveBM25 Keyword Search
    Privacy ModeVerified100% Local (No external API calls)
    Search ScriptGeneratedsearch_index.py
    import json
    from rank_bm25 import BM25Okapi
    
    def search(query, top_n=3):
        # Load local index and chunks
        with open('index_store.json', 'r') as f:
            data = json.load(f)
        
        tokenized_query = query.lower().split()
        bm25 = BM25Okapi([c['tokens'] for c in data['chunks']])
        results = bm25.get_top_n(tokenized_query, data['chunks'], n=top_n)
        
        return [{"text": r['text'], "source": r['source']} for r in results]
    
    # Example usage: print(search("authentication logic"))
    

    Next steps

    1. Run python search_index.py to test retrieval accuracy.
    2. Add your .env or .git folders to the exclusion list if they contain sensitive secrets.
    3. Schedule a refresh task to update the index when you modify your documentation files.

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

    About this skill

    Building a RAG system often involves complex cloud infrastructure and third-party APIs that compromise data privacy. This skill provides a blueprint for creating a private retrieval index over local files, notes, and repositories without sending sensitive data to external servers.

    What it does

    • Local indexing creates a searchable database of user-owned files, notes, and public repositories.
    • Privacy-first architecture ensures all chunks and indices stay on the local device.
    • Hybrid search builds a BM25 keyword index for zero-cost retrieval with optional vector embeddings.
    • Source tracking attaches specific file origins to every chunk for verifiable citations.
    • Index maintenance handles refreshing data when files change or removing specific chunks.

    How it works

    1. Source collection gathers the specific workspace files or repositories the user wants to index.
    2. Chunking splits documents into small, manageable segments with metadata labels.
    3. Index building generates the keyword and vector stores locally.
    4. Search implementation adds a script to query the index and return the most relevant chunks.

    Frameworks & tools

    This skill works with local file systems and Python-based indexing libraries. It uses the BM25 algorithm for keyword matching and supports small local embedding models for vector search.

    Why this beats prompting it yourself

    Prompting an agent to "remember" files often leads to hallucinations or context window exhaustion. This skill provides a systematic engineering approach to data retrieval that maintains a verifiable link between questions and local source material.

    Use cases

    • Search across personal engineering notes and technical documentation.
    • Query local code repositories to find specific logic or patterns.
    • Build a private knowledge base from business emails and archives.
    • Create a retrieval tool that works entirely offline for sensitive projects.

    Known limitations

    Large file sets may require significant local disk space. Highly complex document layouts like nested tables or images may need pre-processing.

    Requires local storage for index files. Performance depends on local hardware specs. Best suited for text-heavy documents and code files.

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

    Permissions

    No special permissions declared or detected

    Listed1 day ago

    What's inside

    Frequently Asked Questions

    This skill creates a fully local Retrieval-Augmented Generation (RAG) system, allowing you to index and search your private files and code repositories without sending sensitive data to third-party cloud APIs.

    The skill includes the architectural blueprint, local indexing scripts, and configuration files needed to build and query your private database. You will receive all the logic required to handle chunking, keyword matching, and source-tracking for your local files.

    The system is designed to work with Python-based environments and is compatible with any AI agent or LLM that can execute local scripts or access local file directories. It is ideal for developers using VS Code, Obsidian, or custom terminal-based agents.

    The skill is optimized for standard text-based files, Markdown notes, and source code repositories (.py, .js, .cpp, etc.). While it handles dense technical documentation well, files with complex visual elements like nested tables or images may require basic text pre-processing before indexing.

    No, the system is designed to run entirely on your local hardware using the BM25 algorithm and lightweight local embedding models. You can index and search your knowledge base without an active internet connection or recurring API costs.

    New in LLM Ops