Vector Search
FreeEfficient vector search for large and small datasets.
Free · Opens the source repo
What Vector Search does
Vector Search is a powerful tool designed for efficient searching and querying of vector embeddings. It provides two distinct search paths tailored to different use cases: the embeddings_* path for large-scale corpus searches and the ruvllm_hnsw_* path for routing queries to a limited number of high-priority patterns. The large-scale path utilizes HNSW (Hierarchical Navigable Small World) algorithms to handle millions of vectors with impressive speed and accuracy, achieving a recall rate of approximately 0.99. This path is ideal for scenarios where you need to search through extensive datasets, such as document collections or large-scale machine learning applications.
For memory-constrained environments or smaller datasets, the RaBitQ quantization technique offers a significant memory reduction of up to 32 times while maintaining performance. This is particularly useful when working with corpora of 5,000 vectors or more, allowing for efficient searches without overwhelming system resources. The plugin also supports various operations, including string comparison and hierarchical data representation through hyperbolic embeddings, making it versatile for different data structures.
The skill is suitable for developers and data scientists looking to implement efficient vector search capabilities in their applications. It provides a clear workflow for initializing the embedding engine, generating embeddings from text, and executing searches, all while allowing for fine-tuning of parameters to balance recall and latency based on specific needs. Whether you are dealing with large-scale data or need to quickly route queries to a small set of patterns, Vector Search offers the necessary tools to optimize your search processes.
When to use it
Use this skill when you need to search through large corpora or when working with memory-constrained environments that require efficient indexing and retrieval.
When not to use it
This skill may not be suitable for very small datasets (less than 5,000 vectors) where the overhead of quantization outweighs the benefits, or when you need to perform searches outside the defined capabilities of the tool.
What you can build with it
Searching Large Document Collections
Use the `embeddings_search` path to efficiently query through large datasets of documents, achieving high recall rates.
Memory-Constrained Environments
Leverage RaBitQ quantization for efficient searches in environments with limited memory, maintaining performance while reducing memory footprint.
Routing Queries to Hot Patterns
Utilize the `ruvllm_hnsw_route` functionality to quickly route incoming queries to a small set of high-priority patterns.
How to install Vector Search
View source1. Install with the skills CLI
npx skills add ruvnet/ruflo/vector-search --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by ruvnetVector Search
Two distinct vector-search paths live in this plugin. Pick the right one — they're not interchangeable.
| Path | Tool family | Backing | Capacity | Latency |
|---|---|---|---|---|
| Large-scale corpus | embeddings_* | @claude-flow/memory HNSW (Rust/Native) | up to millions of vectors | ~1.9× at N=20k, ~3.2×–4.7× at N=5k vs brute-force (measured; recall@10 ≈ 0.99). ANN wins above the crossover |
| Hot-path router | ruvllm_hnsw_* | WASM-backed router (v2.0.1) | ~11 patterns max (ruvllm-tools.ts:58) | sub-ms; designed for high-priority routing, not corpus search |
The "12,500×" headline applies to the large-scale embeddings_search path. The WASM router is not that path.
When to use
| Need | Path |
|---|---|
| Search a corpus of N ≥ 500 documents | embeddings_search |
| Memory-constrained corpus (≥5,000 vectors) | RaBitQ quantized — see "Quantized search" below |
| Compare two strings | embeddings_compare |
| Hierarchical / taxonomic data | embeddings_hyperbolic (Poincare ball) |
| Route a query to one of ≤11 hot patterns | ruvllm_hnsw_route |
| Cross-namespace search | memory_search_unified |
Standard search
- Check status —
mcp__plugin_ruflo-core_ruflo__embeddings_statusto verify the embedding engine. - Initialize —
mcp__plugin_ruflo-core_ruflo__embeddings_initif not active. - Generate —
mcp__plugin_ruflo-core_ruflo__embeddings_generatefor text input. - Search —
mcp__plugin_ruflo-core_ruflo__embeddings_searchwith the query. - Compare —
mcp__plugin_ruflo-core_ruflo__embeddings_compareto measure similarity. - Unified search —
mcp__plugin_ruflo-core_ruflo__memory_search_unifiedfor cross-namespace.
Quantized search (32× memory reduction)
For corpora ≥5,000 vectors and/or memory-constrained environments, use the RaBitQ 1-bit quantization workflow. Below 5,000 vectors the rebuild cost outweighs the savings — use the standard path instead.
| Step | Tool | Purpose |
|---|---|---|
| 1 | embeddings_init | Engine warm |
| 2 | embeddings_rabitq_build | One-time build of the 1-bit index after corpus is loaded |
| 3 | embeddings_rabitq_search | Hamming-prefilter returns top-N candidate IDs (cheap) |
| 4 | embeddings_search | Optional exact rerank on the candidate set (full-precision) |
| 5 | embeddings_rabitq_status | Index health, memory footprint, build time |
Note:
embeddings_rabitq_searchreturns candidate IDs only — the rerank in step 4 is the user's responsibility (mirrors the docstring atembeddings-tools.ts:911). Without rerank, results are approximate; with rerank, you get full-precision quality at 32× lower memory.
Tuning
HNSW exposes three knobs that trade recall against latency. The "12,500×" headline assumes defaults; tune deliberately for your workload:
| Profile | efSearch | M | When to use |
|---|---|---|---|
recall-first | 200 | 32 | Pattern recall during planning; quality matters more than ms |
balanced (default) | 64 | 16 | General-purpose semantic recall |
latency-first | 16 | 8 | Hot-path routing where p99 latency matters |
efSearch is passed via ruvllm_hnsw_create (ruvllm-tools.ts:64). M is registry-level today; raise as a follow-up if it should be MCP-tunable. efConstruction defaults to 200 in the lite index (hnsw-index.ts:537).
HNSW pattern router (WASM, ≤11 patterns)
For routing a small number of high-priority patterns:
mcp__plugin_ruflo-core_ruflo__ruvllm_hnsw_create— create the WASM index (cap ~11)mcp__plugin_ruflo-core_ruflo__ruvllm_hnsw_add— add a patternmcp__plugin_ruflo-core_ruflo__ruvllm_hnsw_route— route an incoming query
This is not a corpus index. Treat it as a fast classifier over a curated set of patterns.
Hyperbolic embeddings
For hierarchical data (code trees, org charts), use mcp__plugin_ruflo-core_ruflo__embeddings_hyperbolic which maps to Poincare ball space. Distance is geodesic, not cosine.
CLI alternative
npx @claude-flow/cli@latest embeddings search --query "authentication patterns"
npx @claude-flow/cli@latest embeddings init
npx @claude-flow/cli@latest memory search --query "your query"
Performance
Measured numbers (source: scripts/benchmark-intelligence.mjs, ruvector NAPI backend; recall@10 ≈ 0.99). The older "150×–12,500×" figures were brute-force-fallback artifacts and have been retired — see project CLAUDE.md "V3 Performance Targets".
| Method | Measured speedup vs brute-force |
|---|---|
| Brute-force scan | Baseline |
| HNSW (N=5,000) | ~3.2×–4.7× faster |
| HNSW (N=20,000) | ~1.9× faster |
| HNSW (below crossover, small N) | ties/loses vs brute-force |
| RaBitQ quantization | 32× memory reduction; 0.60 ms/query at N≈14.7k |
ruvllm_hnsw_route (n≤11) | sub-ms per route, fixed cost |
Frequently asked questions about Vector Search
Similar skills
Power BI Semantic Modeling
Optimize your Power BI data models with best practices.
Data Context Extractor
Tailor data analysis skills to your company's needs.
Power BI Performance Troubleshooting
Systematic guidance for optimizing Power BI performance.
Power BI Model Design Review
Optimize your Power BI data models with expert reviews.
Power BI DAX Formula Optimizer
Optimize your DAX formulas for better performance and clarity.
Fabric Lakehouse
Optimize your data solutions with Lakehouse best practices.