More screenshots
Works with the AI Agents you already use
ContextVault
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
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.
- 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"
- 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"
- 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"
- 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"
- 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.
- Live monitoring
ContextVault provides Live Monitoring in the local application.
The implementation uses Chokidar through "watchProject()".
When monitoring is active
- The watcher observes the selected project directory.
- New and modified files generate filesystem events.
- Events are debounced for 500 milliseconds.
- The changed file is read and passed to "indexSingleFile()".
- 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"
- 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.
- 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
- 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"
- 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"
- 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"
- 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"
- 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"
- 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"
- Live Monitoring
ContextVault provides Live Monitoring through its local application.
The implementation uses Chokidar to observe file additions and modifications.
The workflow is
- Detect a filesystem event.
- Debounce the event for 500 milliseconds.
- Read the changed file.
- Generate its chunks and embeddings.
- Update its SQLite records.
- 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"
- 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.
- 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
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
- Install ContextVault on your computer.
- Install and start Ollama with the "nomic-embed-text" model.
- Start ContextVault and index a project directory you own or are authorized to inspect.
- Configure your supported AI client to connect to the local ContextVault MCP server.
- Ask natural-language questions about your codebase.
- 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:
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
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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 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
Permissions
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.