More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    ContextVault

    1

    Local-first semantic code search for AI coding agents. Index your codebase with Ollama and SQLite, then retrieve relevant source code through natural-language queries and MCP.

    Free

    Security scanned

    ContextVault

    Example session with this skill installed

    ContextVault Project Indexing — Technical Investigation

    The project-indexing workflow follows this pipeline:

    Project directory → File scanning → Chunking → Local embeddings → SQLite persistence → Search and monitoring

    Here is how each stage works, based on the current implementation.

    1. File scanning

    The indexing process begins in "src/indexer/pipeline.ts", which calls "scanProject()" from "src/indexer/fileWatcher.ts".

    The scanner

    • Recursively walks the selected project directory.
    • Skips symbolic links.
    • Reads eligible files as UTF-8.
    • Records each file's relative path, contents, modification time, size, and detected language.
    • Sorts discovered files by path for consistent processing.

    It excludes directories such as "node_modules", ".git", "dist", "build", ".next", "target", and "pycache".

    It also applies file exclusions and a maximum file size of 500 KiB.

    The project root and relative file path are retained separately, allowing different projects to contain files with identical relative paths.

    Relevant files

    • "src/indexer/fileWatcher.ts"
    • "src/config/ignorePatterns.ts"
    • "src/indexer/pipeline.ts"
    1. Chunking

    After scanning, ContextVault divides file contents into smaller searchable chunks.

    The current implementation defines

    const CHUNK_SIZE_CHARS = 3200;
    const CHUNK_OVERLAP_CHARS = 400;
    

    This means chunks contain up to 3,200 characters, with a 400-character overlap between consecutive chunks.

    The chunking logic also attempts to respect useful content boundaries:

    • Markdown headings.
    • Function and class declarations in TypeScript and JavaScript.
    • Function and class declarations in Python.

    Each chunk retains its file path, chunk index, and start/end line numbers.

    For TypeScript, JavaScript, and Python, additional file and language context is included in the embedding text.

    Relevant file: "src/indexer/fileWatcher.ts"

    1. Local embedding generation

    The pipeline sends chunk text to the embedding layer in batches.

    The current pipeline configuration is

    const EMBEDDING_BATCH_SIZE = 8;

    ContextVault uses the local Ollama API with the "nomic-embed-text" model.

    The default endpoint is

    http://127.0.0.1:11434/api/embed

    The embedding layer adds task context to the submitted text, validates the returned vectors, and checks that the number of embeddings matches the input batch.

    It also includes request timeouts, queue management, error handling, and embedding diagnostics.

    No hosted embedding API is required for this indexing process.

    Relevant file: "src/indexer/embedder.ts"

    1. SQLite persistence

    Once a file's chunks have been processed, ContextVault stores the indexed data in its local SQLite database.

    The database separates file records from chunk records.

    Table| Stored information
    "files"| File path, project root, original content, modification time, size, and language
    "chunks"| File reference, chunk content, line boundaries, chunk index, and embedding data

    Embeddings are converted into "Float32Array" data and stored as binary values in SQLite.

    The database uses a project-scoped uniqueness constraint:

    UNIQUE (root_path, path)

    This prevents two different projects from overwriting each other's records merely because they contain the same relative filename.

    File and chunk persistence uses SQLite transactions, helping prevent partially written file records.

    Relevant files

    • "src/storage/db.ts"
    • "src/storage/vectors.ts"
    • "src/indexer/pipeline.ts"
    1. Stale-file cleanup

    ContextVault also handles files that have been removed or renamed.

    After a full indexing operation processes the current project files, "pruneProjectIndex()" compares the newly scanned paths against the existing records belonging to that project root.

    Records for paths that no longer exist are removed, along with their associated chunks.

    Importantly, cleanup is performed after the current indexing work, rather than immediately when scanning begins.

    The implementation also preserves an existing complete file index when every chunk for that file fails to embed.

    Relevant file: "src/storage/vectors.ts"

    The testing documentation describes this behavior:

    «Reindexing compares the successfully scanned file paths with the records owned by that root and removes paths that disappeared or were renamed.»

    Source: "TESTING.md" — Stale file cleanup after reindex.

    1. Live monitoring

    ContextVault provides Live Monitoring in the local application.

    The implementation uses Chokidar through "watchProject()".

    When monitoring is active

    1. The watcher observes the selected project directory.
    2. New and modified files generate filesystem events.
    3. Events are debounced for 500 milliseconds.
    4. The changed file is read and passed to "indexSingleFile()".
    5. Updates are processed through a queue to avoid overlapping persistence operations.

    Live Monitoring requires a verified Pro license and the local ContextVault application must remain running.

    Important distinction: The current watcher handles file additions and changes. Deleted or renamed file cleanup is handled by a subsequent full reindex, not by a dedicated live deletion handler.

    Live Monitoring is an application feature; it is not exposed as a separate MCP tool.

    Relevant files

    • "src/indexer/fileWatcher.ts"
    • "src/indexer/liveWatcher.ts"
    • "src/indexer/pipeline.ts"
    1. Documentation evidence

    The official MCP guide summarizes the architecture:

    «The application indexes selected project files, generates embeddings with local Ollama, and stores the index in local SQLite.»

    It also explains the local data-handling model:

    «File scanning, embedding generation, semantic search, and SQLite persistence run locally in ContextVault using the local Ollama service.»

    Source: "README_MCP.md"

    The guide further clarifies that MCP clients must connect to the local server separately. Installing the Agensi skill alone does not install ContextVault or configure its local MCP connection.

    1. End-to-end architecture

    Authorized project directory

          |
    
    
          v
    File scanner
    
          |
    
    
          v
    

    Filtering and exclusions

          |
    
    
          v
     Text chunking
    
          |
    
    
          v
    

    Local Ollama API
    nomic-embed-text

          |
    
    
          v
    Embedding vectors
    
          |
    
    
          v
     SQLite storage
       /       \
      v         v
    

    Dashboard Local MCP server

                 |
    
    
                 v
          Cursor / Claude
    

    9. Key findings

    The implementation provides several important safeguards:

    • Project records are scoped by absolute root path.
    • File exclusions and size limits are applied during scanning.
    • Embeddings are generated locally.
    • File and chunk updates use SQLite transactions.
    • Stale records are reconciled during full reindexing.
    • Live file updates are queued and processed sequentially.
    • Live Monitoring and MCP access require a verified Pro license.

    One documentation discrepancy is worth noting: "README_MCP.md" describes indexing batches of up to 16 texts, while the current "src/indexer/pipeline.ts" sets "EMBEDDING_BATCH_SIZE" to 8. The implementation value should be reflected in the documentation.

    Conclusion: ContextVault uses a local, project-aware indexing pipeline that transforms eligible source files into overlapping semantic chunks, embeds them through Ollama, stores the resulting context and vectors in SQLite, and supports incremental updates through Live Monitoring.

    • Read your context and instructions
    • Compiled the contextvault

    CONTEXTVAULT — PROJECT INDEXING & SEMANTIC SEARCH

    Overview

    ContextVault transforms a local codebase into a searchable knowledge source for compatible AI coding agents.

    Instead of depending entirely on manually opened files or copied code snippets, the agent can retrieve relevant implementation context using natural-language questions.

    The project-indexing workflow consists of six main stages:

    File Scanning → Chunking → Embedding Generation → SQLite Storage → Semantic Search → Change Monitoring

    1. File Scanning

    The indexing process starts in "src/indexer/pipeline.ts" and uses "scanProject()" from "src/indexer/fileWatcher.ts".

    The scanner recursively explores the authorized project directory and:

    • Reads eligible files as UTF-8.
    • Records file paths, contents, modification times, sizes, and programming languages.
    • Skips symbolic links.
    • Excludes directories such as "node_modules", ".git", "dist", and "build".
    • Ignores configured file types and files larger than 500 KiB.

    Each indexed file retains its relative path and owning project root.

    Relevant files

    • "src/indexer/fileWatcher.ts"
    • "src/config/ignorePatterns.ts"
    • "src/indexer/pipeline.ts"
    1. Text Chunking

    Large files are divided into smaller pieces to make semantic retrieval more useful.

    The current implementation uses

    const CHUNK_SIZE_CHARS = 3200;
    const CHUNK_OVERLAP_CHARS = 400;
    

    Chunks preserve their original file paths, line boundaries, and chunk indexes.

    For supported programming languages, ContextVault also attempts to use meaningful boundaries such as function and class declarations.

    Relevant file: "src/indexer/fileWatcher.ts"

    1. Local Embedding Generation

    ContextVault uses Ollama and the "nomic-embed-text" model to generate embeddings locally.

    The indexing pipeline currently processes up to eight chunks per embedding batch.

    The embedding layer

    • Sends requests to the local Ollama API.
    • Validates returned embedding vectors.
    • Handles request timeouts and errors.
    • Uses a managed request queue.
    • Records embedding diagnostics.

    The default local API endpoint is

    http://127.0.0.1:11434/api/embed

    Relevant file: "src/indexer/embedder.ts"

    1. SQLite Storage

    After embedding generation, ContextVault stores project information and searchable chunks in its local SQLite database.

    Database table| Information stored
    "files"| File path, project root, content, modification time, size, and language
    "chunks"| Chunk content, file reference, line boundaries, chunk index, and embedding data

    Embedding vectors are stored as binary Float32 data.

    Project-aware storage uses

    UNIQUE (root_path, path)

    This allows different projects to contain files with identical relative paths without overwriting each other's records.

    File and chunk persistence uses SQLite transactions.

    Relevant files

    • "src/storage/db.ts"
    • "src/storage/vectors.ts"
    1. Semantic Search

    Once the project has been indexed, the connected AI agent can use the local MCP server.

    ContextVault exposes two tools

    "index_project"

    Indexes an authorized local project directory using an absolute "rootPath".

    "search_context"

    Searches indexed project context using a natural-language query.

    It supports

    • "query": the search question.
    • "limit": maximum number of returned results, from 1 to 100.
    • "filter": optional file scope:
      • "code" — default.
      • "docs" — documentation.
      • "all" — both.

    The search layer compares the query embedding against stored vectors using cosine similarity and returns matching file paths, source snippets, and relevance scores.

    Both MCP tools require a verified Pro license.

    Relevant files

    • "src/mcp.ts"
    • "src/storage/vectors.ts"
    • "src/indexer/embedder.ts"
    1. Stale-File Cleanup

    ContextVault also handles deleted and renamed files during a full reindex.

    After the current project files have been processed, "pruneProjectIndex()" compares the scanned paths with the existing records for that project root.

    Records for paths that disappeared are removed together with their associated chunks.

    The implementation delays stale-file cleanup until the current indexing work has been processed, helping preserve the previous complete index when embedding fails.

    Relevant file: "src/storage/vectors.ts"

    1. Live Monitoring

    ContextVault provides Live Monitoring through its local application.

    The implementation uses Chokidar to observe file additions and modifications.

    The workflow is

    1. Detect a filesystem event.
    2. Debounce the event for 500 milliseconds.
    3. Read the changed file.
    4. Generate its chunks and embeddings.
    5. Update its SQLite records.
    6. Process queued updates sequentially.

    Live Monitoring requires a verified Pro license and the local application must remain running.

    Important: The current live watcher handles additions and modifications. Deleted or renamed files are reconciled during a full reindex, not through a dedicated live deletion handler.

    Relevant files

    • "src/indexer/fileWatcher.ts"
    • "src/indexer/liveWatcher.ts"
    • "src/indexer/pipeline.ts"
    1. Retrieved Documentation

    The investigation identifies these relevant project resources:

    File| Relevant information
    "README.md"| Product architecture, local indexing, requirements, and semantic search
    "README_MCP.md"| MCP setup, supported clients, tool descriptions, and privacy
    "src/indexer/pipeline.ts"| Complete project-indexing orchestration
    "src/indexer/fileWatcher.ts"| File scanning, chunking, filtering, and filesystem watching
    "src/indexer/embedder.ts"| Ollama integration and embedding generation
    "src/storage/db.ts"| SQLite schema and project-scoped storage
    "src/storage/vectors.ts"| Embedding persistence, similarity search, and stale-file cleanup
    "src/indexer/liveWatcher.ts"| Live update processing

    Documentation evidence from "README_MCP.md":

    «File scanning, embedding generation, semantic search, and SQLite persistence run locally in ContextVault using the local Ollama service.»

    The documentation also clarifies that the Agensi skill and the local ContextVault MCP connection are separate components.

    1. Architecture Summary

    Authorized Local Project

          |
    
    
          v
      File Scanner
    
          |
    
    
          v
    

    Filtering & Chunking

          |
    
    
          v
    

    Local Ollama Embeddings

          |
    
    
          v
     SQLite Database
    
          |
    
    
          +----------------+
    
          |                |
    
    
          v                v
    

    Web Dashboard Local MCP Server

                           |
    
    
                           v
                  Cursor / Claude Desktop
    
                           |
    
    
                           v
                  AI Context Retrieval
    

    Final Outcome

    ContextVault provides a project-aware local indexing pipeline that turns eligible source files into searchable semantic context.

    Its main value is not simply storing code. It gives compatible AI coding agents a structured way to find relevant implementation details without requiring developers to manually locate and share every file.

    The combination of local embeddings, SQLite persistence, semantic retrieval, and Live Monitoring creates a reusable context layer around the developer's codebase.

    The result: better codebase discovery, more relevant retrieved context, and a more direct connection between AI coding agents and the actual project implementation.

    Official documentation
    https://github.com/ahmedfayedesmail-ui/contextvault/blob/main/README_MCP.md

    Source code
    https://github.com/ahmedfayedesmail-ui/contextvault

    README.md

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

    About this skill

    ContextVault — Search Your Codebase by Meaning

    ContextVault helps AI coding agents find relevant implementation context inside your local codebase.

    Instead of relying only on filenames, manually opened files, or copied snippets, ContextVault builds a searchable index of your project. You can ask natural-language questions and retrieve relevant source code, implementation details, and file paths through semantic search.

    ContextVault uses local Ollama embeddings and SQLite storage, and provides a local Model Context Protocol (MCP) server for compatible desktop AI coding clients.

    Important: You must install ContextVault locally before using this skill. The Agensi skill provides instructions only. It does not install the ContextVault application, Ollama, or configure the local MCP server.

    What ContextVault does

    • Semantic code search: Find relevant implementation details using natural-language questions.
    • Local project indexing: Scan an authorized project directory and build a searchable index.
    • MCP integration: Give compatible AI clients access to indexed project context through local MCP tools.
    • Project-aware storage: Associate indexed file records with their project roots.
    • Stale-file cleanup: Remove deleted or renamed files from the index after a successful reindex.
    • Local embeddings: Generate embeddings using Ollama and the "nomic-embed-text" model.
    • Local storage: Store indexed project content and embeddings in SQLite.
    • Agent context retrieval: Return relevant source snippets and file paths to the connected AI client.

    How it works

    1. Install ContextVault on your computer.
    2. Install and start Ollama with the "nomic-embed-text" model.
    3. Start ContextVault and index a project directory you own or are authorized to inspect.
    4. Configure your supported AI client to connect to the local ContextVault MCP server.
    5. Ask natural-language questions about your codebase.
    6. The agent can retrieve relevant indexed code through the available MCP tools.

    Available MCP tools

    ContextVault exposes two local MCP tools:

    "index_project"

    Indexes a local project directory.

    • Required input: "rootPath"
    • The path must be absolute.
    • Only index a directory when the user explicitly authorizes it.

    "search_context"

    Searches the local index and returns relevant matching code snippets.

    • Required input: "query"
    • Optional input: "limit" — maximum number of results, from 1 to 100. Default: 5.
    • Optional input: "filter" — controls the type of files searched:
      • "code" — source code files. This is the default.
      • "docs" — documentation files.
      • "all" — both code and documentation.

    Both MCP tools require a verified ContextVault Pro license.

    Free and Pro plans

    ContextVault includes a Free plan for evaluating local semantic search and a Pro plan for developers who want MCP integration and a larger indexed codebase.

    Free

    • One indexed project at a time.
    • Up to 1,000 eligible files.
    • Dashboard semantic search.
    • Local Ollama embeddings and SQLite storage.
    • No license key required.

    Pro

    • Unlimited project roots.
    • Unlimited eligible files.
    • Full access to "index_project" and "search_context".
    • Live Monitoring.
    • Requires a verified Pro license key.

    The 1,000-file Free limit applies to files eligible for indexing after ContextVault's built-in exclusion and file-size rules.

    Compatibility and requirements

    The documented local MCP setup supports:

    • Claude Desktop
    • Cursor

    The MCP client must support launching a local stdio MCP server on the same computer where ContextVault is installed.

    Requirements:

    • Node.js 22.13 or newer.
    • Ollama.
    • The "nomic-embed-text" embedding model.
    • SQLite, managed by the ContextVault application.

    Cloud-only and mobile AI clients that cannot launch local processes cannot directly connect to the local ContextVault MCP server.

    ContextVault does not currently provide a hosted remote MCP endpoint.

    Privacy and data handling

    ContextVault is designed around local indexing:

    • Project scanning runs locally.
    • Embedding generation uses the local Ollama service.
    • Indexed project content and embeddings are stored in local SQLite.
    • ContextVault does not send project files to a hosted embedding API for indexing.

    However, when ContextVault returns code snippets to a connected AI client, those snippets become part of that AI provider's context and may be processed according to the provider's own data-handling terms and settings.

    Do not describe the entire workflow as fully offline unless the connected AI model also runs locally.

    Only index project directories you own or are authorized to inspect. Avoid indexing credentials, private keys, and other sensitive files.

    Known limitations

    • The Agensi skill provides instructions; it does not install or host the local ContextVault application.
    • The ContextVault application and its local MCP server must be installed and configured separately.
    • Agensi's marketplace connection is separate from ContextVault's local MCP connection.
    • Both MCP tools require a verified Pro license.
    • Live Monitoring requires a verified Pro license and runs inside the local ContextVault application while it is running.
    • Live Monitoring is not exposed as a separate MCP tool.
    • The "filter" parameter controls code versus documentation search; it does not select a project root.
    • When multiple projects share the same local database, "search_context" does not provide a project-path filter. Review returned file paths to confirm which project the results belong to.
    • ContextVault retrieves code context. It does not edit source files, execute tests, or deploy projects.

    Installation and documentation

    Official setup guide:

    https://github.com/ahmedfayedesmail-ui/contextvault/blob/main/README_MCP.md

    Source code and installers:

    https://github.com/ahmedfayedesmail-ui/contextvault

    Both MCP tools (index_project and search_context) require a verified Pro license.

    • Live Monitoring also requires a verified Pro license and runs locally while the ContextVault application is running.
    • The current MCP interface exposes only two tools: index_project and search_context. There is no separate MCP tool for controlling Live Monitoring.
    • Live Monitoring detects new and modified files. Deleted or renamed files are reconciled during a full project reindex.
    • Search retrieves matching results from the locally stored SQLite index.
    • The search_context tool does not currently provide a project-root filter when multiple projects share the same local database. Review returned file paths to identify the source project.
    • The Agensi skill provides instructions only. It does not install or host the ContextVault application or its local MCP server.

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

    • Free with an Agensi account

    Requires

    Node.js 22.13+
    npm
    Ollama
    nomic-embed-text
    Node.js

    Permissions

    Read Files

    Users select a local project folder, and ContextVault indexes eligible files within that project. Indexed file content and embeddings are stored in a local SQLite database. ContextVault does not modify project source files. Embeddings are generated through the user's local Ollama service. Retrieved code snippets are passed to the connected AI agent as context and may be processed by that agent's provider under its own data-handling policies.

    Listed11 days ago

    What's inside

    Frequently Asked Questions

    ContextVault indexes your selected local project, divides eligible files into searchable chunks, generates embeddings using Ollama, and stores the index in SQLite. Compatible AI clients can then retrieve relevant code snippets and file paths through the local MCP server using natural-language queries. Both MCP tools require a verified Pro license.

    Project scanning, embedding generation, semantic search, and SQLite storage run locally on your computer. ContextVault does not send project files to a hosted embedding API for indexing. However, when code snippets are returned to a connected AI client, they become part of that provider's context and may be processed under the provider's own data-handling terms and settings. For fully local AI processing, use a locally running AI model as well.

    Install ContextVault on the same computer as your AI coding client. The current requirements include Node.js 22.13 or newer, npm, Ollama, and the nomic-embed-text model. You must also configure the local ContextVault MCP server separately in a compatible client. The documented integrations are Claude Desktop and Cursor.

    Yes. With Live Monitoring enabled, ContextVault detects newly added and modified files and updates their indexed content while the local application is running. Live Monitoring requires a verified Pro license. Deleted or renamed files are reconciled during a full project reindex.

    New in LLM Ops