RetrievalKit is a local retrieval engine for on-device semantic, keyword, and graph search in edge AI apps, with SDKs for Swift, Python, TypeScript, and Kotlin plus a browser WebAssembly build. After model download, zero network calls. v0.1.0 published preview.
Fast, private retrieval for edge AI.
RetrievalKit is a local retrieval SDK for on-device semantic, keyword, and application-graph search. No retrieval server, account, or API key.
A query and app-owned data enter RetrievalKit inside your process and return results without a retrieval server.
1K to fewer than 50K chunksNo account or API keyZero network calls after model download
SwiftPM · PyPI · npm · Maven CentralApache-2.0 · v0.1.0 published preview · github.com/gungorbasa/RetrievalKit
On July 19, after Apollo 11 had flown behind the moon out of contact with Earth, came the first lunar orbit insertion maneuver. At about 75 hours, 50 minutes into the flight, a retrograde firing of the SPS for 357.5 seconds placed the spacecraft into an initial, elliptical-lunar orbit of 69 by 190 miles.
vector #1 · keyword #5 · matched lunar, orbit
One real hybrid run over all 15 Apollo 11 passages. Scores combine exact vector similarity and BM25.
event-lunar-landing · 1969-07-20
NEXT_EVENTLunar landing2 states visited · 1 edge traversed · no embedding
A real graph-only traversal over app-declared relationships. It returns the related Event record directly, so there is no relevance score.
Eagle → related events → evidence passagesArmstrong and Aldrin spent 21 hours, 36 minutes on the moon’s surface. After a rest period that included seven hours of sleep, the ascent stage engine fired at 124 hours, 22 minutes.
ranked #1 inside 6 graph-selected passages
Graph scope narrowed 15 passages to 6; vector similarity ordered the eligible hits.
Every question runs live through local browser models and RetrievalKit's WebAssembly core. No canned answers or hosted fallback. Open any citation to see the exact passage in the source document.
Choose retrieval, graph, or graph-scoped search through separate APIs over the same local corpus. Your app supplies relationships; RetrievalKit handles traversal and ranking.
The API shapes are exact; the domains are illustrative. No hand-written fusion or query translation layer.
RetrievalDatabaseRank the whole corpus with exact vector similarity and BM25.
let hits = try await retrievalDatabase.search(
text: "What did we decide about offline sync?",
embedding: queryEmbedding,
alpha: 0.6,
limit: 5
)GraphDatabaseSelect records by relationship. No embedding or retrieval ranker is involved.
let selection = try await graphDatabase.query(
from: [GraphNodeID(
nodeType: "Notebook",
recordID: "product-research"
)],
traversing: [GraphTraversal(
relationship: "references"
)]
)GraphRetrievalDatabaseSelect candidates with the graph, then rank only that scope with vector + BM25.
let selection = try await graphRetrievalDatabase.query(
from: [GraphNodeID(
nodeType: "Project",
recordID: "mobile-app"
)],
traversing: [GraphTraversal(
relationship: "contains"
)]
)
let hits = try await graphRetrievalDatabase.search(
text: "Why is cold start slow on Android?",
embedding: queryEmbedding,
alpha: 0.6,
within: selection,
limit: 5
)RetrievalDatabaseRank the whole corpus with exact vector similarity and BM25.
hits = retrieval_database.retrieval.hybrid_search(
"What did we decide about offline sync?",
query_embedding,
alpha=0.6,
limit=5,
)GraphDatabaseSelect records by relationship. No embedding or retrieval ranker is involved.
selection = graph_database.graph.query(
seeds=[GraphNode("Notebook", "product-research")],
traversals=[GraphTraversal("references")],
)GraphRetrievalDatabaseSelect candidates with the graph, then rank only that scope with vector + BM25.
selection = graph_retrieval_database.graph.query(
seeds=[GraphNode("Project", "mobile-app")],
traversals=[GraphTraversal("contains")],
)
hits = graph_retrieval_database.retrieval.hybrid_search(
"Why is cold start slow on Android?",
query_embedding,
alpha=0.6,
within=selection,
limit=5,
)RetrievalDatabaseRank the whole corpus with exact vector similarity and BM25.
const hits = await retrievalDatabase.search({
mode: "hybrid",
text: "What did we decide about offline sync?",
embedding: queryEmbedding,
alpha: 0.6,
limit: 5
});GraphDatabaseSelect records by relationship. No embedding or retrieval ranker is involved.
const selection = await graphDatabase.graph.query({
seed: {
kind: "nodes",
nodes: [{
kind: "record",
nodeType: "Notebook",
recordId: "product-research"
}]
},
traverse: [{ relationship: "references" }]
});GraphRetrievalDatabaseSelect candidates with the graph, then rank only that scope with vector + BM25.
const selection = await graphRetrievalDatabase.graph.query({
seed: {
kind: "nodes",
nodes: [{
kind: "record",
nodeType: "Project",
recordId: "mobile-app"
}]
},
traverse: [{ relationship: "contains" }]
});
const hits = await graphRetrievalDatabase.retrieval.search({
mode: "hybrid",
text: "Why is cold start slow on Android?",
embedding: queryEmbedding,
alpha: 0.6,
within: selection,
limit: 5
});RetrievalDatabaseRank the whole corpus with exact vector similarity and BM25.
val hits = retrievalDatabase.search(
text = "What did we decide about offline sync?",
embedding = queryEmbedding,
alpha = 0.6f,
limit = 5,
)GraphDatabaseSelect records by relationship. No embedding or retrieval ranker is involved.
graphDatabase.query(
GraphQuery(
seed = GraphSeed.Nodes(
listOf(GraphNodeId("Notebook", "product-research")),
),
traversals = listOf(GraphTraversal("references")),
),
).use { selection ->
selection.snapshot.matches.forEach(::println)
}GraphRetrievalDatabaseSelect candidates with the graph, then rank only that scope with vector + BM25.
graphRetrievalDatabase.query(
GraphQuery(
GraphSeed.Nodes(
listOf(GraphNodeId("Project", "mobile-app")),
),
traversals = listOf(GraphTraversal("contains")),
),
).use { selection ->
val hits = graphRetrievalDatabase.search(
text = "Why is cold start slow on Android?",
embedding = queryEmbedding,
alpha = 0.6f,
within = selection,
limit = 5,
)
}Across 10K, 25K, and 50K chunks, RetrievalKit completed exact top-10 queries 7.17–7.60× faster. Filtered queries were 8.43–10.38× faster.
Speedup vs sqlite-vec 0.1.9 · higher is better
| Search mode | 10K chunks | 25K chunks | 50K chunks |
|---|---|---|---|
| Exact search | 7.17× faster | 7.60× faster | 7.29× faster |
| Filtered search | 10.38× faster | 9.08× faster | 8.43× faster |
In this documented comparison, RetrievalKit is the only product with built-in relationship traversal, relationship-scoped ranking, and a detailed trace for every hybrid result.
Swipe horizontally to compare products.
| Capability | RetrievalKitLocal retrieval SDK | Moss | sqlite-vec | Zvec | LanceDB OSS | Qdrant Edge |
|---|---|---|---|---|---|---|
| Follow application relationships | Built inGraph query API | Not documentedID + metadata only | Requires SQLDefine relationships | Not documented | Not documented | Not documented |
| Rank only within related records | Built inGraph-scoped retrieval | Requires app codeBuild candidate filter | Requires SQLBuild candidate set | Requires app codeBuild candidate filter | Requires app codeBuild candidate filter | Requires app codeBuild candidate filter |
| Explain every hybrid result | Detailed traceRanks + matched terms | Final score only | Requires SQLSelect each component | Final score only | Final score only | Final score only |
All compared products can query locally. Moss builds and updates its durable index in the cloud, then downloads a local query snapshot.
Comparison based on linked official documentation. Not documented means no native API was found; it may still be built in application code. A remote embedding service can still send application data off-device.
HotpotQA, 296 queries, 12,670 chunks. Retrieval-only baseline → graph-scoped, same exact ranker: 121 wins, 157 ties, 18 losses on NDCG@10, zero empty scopes. One dataset, one configuration, self-comparison against our own unscoped baseline — not a competitor benchmark, and candidate reduction is not a latency speedup.
RetrievalKit exact top-10 retrieval measured 7.17 times sqlite-vec 0.1.9 at 10K chunks, 7.60 times at 25K, and 7.29 times at 50K; for filtered queries, 10.38, 9.08, and 8.43 times, all on Apple M1 Max. On HotpotQA, graph scoping raised NDCG@10 from 0.858 to 0.928, Recall@10 from 0.872 to 0.958, and complete-evidence Recall@10 from 0.743 to 0.922.
RetrievalKit is strongest when one user owns a focused local corpus: notes, transcripts, personal knowledge bases, document assistants, or enterprise data that can’t leave the device.
You choose the embedding model. RetrievalKit indexes and searches inside your application process; native targets can persist the index locally.
This is a deliberate exact-search envelope. For million-scale corpora or approximate nearest-neighbor indexing, choose a general vector database; HNSW and ANN are not part of this preview.
Every package ships under Apache-2.0. Registry publication is not device support: no Linux or Windows until a release manifest lists them. A physical iPhone 17 Pro Max passed the supported 10K, 25K, and 50K F32/I8 qualification workloads, with embedding excluded. Review the full evidence. Check Swift and Apple integration, or inspect the browser Worker boundary. If your app calls a remote embedding service, that step isn’t local; privacy is a property of the whole pipeline you assemble.
Available from a signed tag through SwiftPM, PyPI, npm, and Maven Central. This is a 0.x preview: minor releases may refine APIs, with changelog entries and migration guidance. The downloadable Python source preview contains the released wrapper source.
Three query paths, one engine, in your process — on the device that owns the data.