Moss and the three newest releases that are all titled iOS SDK
The retrieval layer for production AI systems. Lightning-fast (<10ms) search without vector databases. Built for browser, edge, on-device, and cloud.
At a glance
- What is it?
- A retrieval runtime that embeds search and embedding in your process and claims single-digit millisecond queries without a vector database. Its two browser packages live under different npm scopes, its most recent tags belong to the iOS SDK, and the benchmark counts an embedding step its competitors do not.
- Who is it for?
- The architecture is coherent and the numbers are worth checking against your own query shape before you believe them. Two things decide whether it fits.
- Can I use it commercially?
- Yes. BSD-2-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- usemoss/moss805 ★ · +133
| Repository | 2026-09-11 | 2026-11-15 |
|---|---|---|
| usemoss/moss | 672 | 805 |
133 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Two npm scopes, one project, and a badge pointing elsewhere
The install names do not line up. The Node and TypeScript SDK is `@moss-js/moss`, and `npm install @moss-js/moss` is the command in the readme. The browser build is a different package under a different scope, `@moss-dev/moss-web`, distributed as WebAssembly for client-side semantic search with no server.
So the same project publishes to the `moss-js` scope and the `moss-dev` scope, and the npm badge at the top of the file appears twice, both times pointing at `@moss-js/moss`. A dependency name has to be chosen per target rather than per project.
The Python name has its own wrinkle. The install line is `pip install moss`, while the download-count badge in the header points at a project named `inferedge-moss-core` on pepy. Two names for one distribution is not necessarily wrong, since a badge can track a related distribution, but nothing in the file explains the relationship, and the quick start hands you credentials from moss.dev without saying which package name to look up.
The three newest release tags are all iOS SDK versions
Read the release titles rather than the repository description. The three most recent releases are v0.6.2 on 29 June 2026, v0.6.3 on 25 September, and v0.7.0 on 29 September, and every one of them is titled Moss iOS SDK.
The repository's primary language is Python, its quick start leads with `pip install moss`, and its feature list enumerates Python, TypeScript, Elixir and C as the SDKs. What sits at the root alongside those directories is a `Package.swift` file, and the example listing includes an `ios/` folder. So the release history that a subscriber to this repository sees is the history of the Swift package, not of the Python client or the retrieval runtime.
That does not tell you the runtime is neglected, since the last push to the default branch is dated 1 October 2026. It does mean version numbers from the release feed tell you very little about which component moved. If you are pinning, pin from the package you install rather than from the newest tag.
The index is fetched once, and only the query is local
The headline claim is that there is no network hop on the hot path and no clusters to tune, and the quick start tells you to point the SDK at Moss Cloud, load your index, and query it. Those three verbs are three different kinds of work.
`create_index` sends documents somewhere. `load_index` pulls the built index into your process. `query` runs locally against what was loaded, and that is the step the latency claim is about. The example makes the order explicit: create, then load, then query, with the comment that results come back in under 10 ms attached to the load and query pair.
The feature list confirms the built-in embedding runs on your side, since no OpenAI key is required unless you bring your own. So embedding and search both happen locally after the index arrives, and the cost of building and shipping the index is not part of the per-query number. That is a reasonable design for an interactive agent, and it is also the thing to be clear about before treating the latency figure as the whole cost of retrieval.
The benchmark counts local embedding and the competitors do not
The table is specific about its conditions: end-to-end query latency covering embedding and search, 100,000 documents, 750 measured queries, top_k of 5, on a MacBook Pro with an M4 Pro and 24 GB of memory. Moss comes out at 3.1 ms P50, 4.3 ms P95, 5.4 ms P99, and a 3.3 ms mean.
The three comparison systems are two orders of magnitude away: ChromaDB at 351.8 ms P50, Pinecone at 432.6 ms, and Qdrant at 597.6 ms, with their P99s between 538.5 and 934.2 ms. So against the nearest competitor the claim is roughly a hundredfold, not a small improvement.
The file states its own caveat, which is the part worth reading twice. Moss includes embedding in the measurement, while the competitors use an external embedding service, and Pinecone and Qdrant were run as cloud search. That means Moss's number includes work the other three numbers exclude, which makes the comparison favourable to Moss rather than neutral. The measurements were also taken on a laptop rather than in a cloud region, and there is a `./benchmarks/` directory for anyone who wants to run it again.
Node 20+ in the readme, a narrower floor in the manifest
The quick start says the snippets need Python 3.10 or newer, or Node.js 20 or newer. The root manifest says something stricter about the second one.
npm install @moss-js/moss`engines` in the root package.json is `^20.19.0 || >=22.12.0`, so Node 20.0 satisfies the readme and fails the manifest. The Python side has no equivalent second statement, and 3.10 is stated once.
That manifest is also not the runtime package. It is named `moss-samples-root`, marked private, versioned 1.0.0, and its single dependency is `vitepress` at ^1.6.4, which is the documentation site. Its two scripts, `type-check` and `lint`, are chained into exactly two directories, `examples/javascript` and `apps/next-js`. Everything else in the tree, the Python examples, the C and Go folders, the cookbook, the voice agents and the workshop, has no type check wired at the root. The `overrides` block pins esbuild, postcss and vite, which is a samples tree managing its transitive toolchain rather than a published library shipping one.
One env file is not enough for the paths that need competitors
Every run instruction in the examples section starts the same way, copying the root env template.
cd examples/python
pip install -r requirements.txt
cp ../../.env.example .env # Add your credentials
python load_and_query_sample.pyThe template itself contains two variables and a warning. `MOSS_PROJECT_ID` and `MOSS_PROJECT_KEY` are the only things every example and app needs. The comment above them says per-feature credentials, naming LiveKit, Qdrant, OpenAI and Pinecone, live in the env template of the specific subdirectory that needs them, and that you should copy this file plus the subdirectory's template into your local env.
So the documented single-copy command is enough for the Moss-only paths and insufficient for the rest. Anything touching the comparison systems in the benchmark needs a second file, and so does the Pipecat voice agent, whose quickstart directory is listed with no commands at all and a pointer to its own README. The fully local stack is the exception that needs no credentials at all, since `docker compose up` in the ollama-local directory runs Ollama, Moss and Pipecat together.
top_k in Python, topK in TypeScript, and both snippets stop mid-expression
The same option is spelled two ways across the two quick starts. The Python client takes `QueryOptions(top_k=3)` with a class and a keyword argument, and the TypeScript client takes an object literal, `{ topK: 3 }`. Snake case and camel case on the same field, which is unsurprising and still costs anyone porting an example the one thing examples are supposed to remove.
Both snippets also end inside an expression. The Python one finishes at `for doc in results.d` and the TypeScript one at `results.docs.for`, so the loop that consumes the results is cut off in both, and the field name has to be inferred from the TypeScript fragment alone.
What is complete is the sequence before them, and it is the part that matters for understanding the design. Documents go in with an explicit id and a text field, the index is loaded by name, and the query takes the index name, the question text and the options object. The results object carries a docs collection. Metadata filtering is configured separately from the query options, with `$eq`, `$and`, `$in` and `$near` named as the available operators.
The examples tree stops mid-line and leaves out four directories
The directory block in the examples section lists `python/` with four sample files, `python-classification/`, `javascript/` with three, `javascript-web/`, `c/`, `go/`, and then `voice-agents/` with a comment cut off after two words. The listing at the top of the repository is longer: alongside those, there are `ios/`, `cookbook/`, `moss-pikachu/` and `python-moss-agent/`.
Two mismatches follow from that. A `go/` directory of samples exists while the SDK list names only Python, TypeScript, Elixir and C, so either the Go binding is undocumented or the folder is stale. And an `ios/` folder of samples exists while the release tags are the iOS SDK versions, with no iOS line anywhere in the examples section.
The integrations table narrows it further. LangChain and DSPy are marked available, with examples under `examples/cookbook/langchain/`, and the feature list also names LlamaIndex, Pipecat, LiveKit, Vapi, ElevenLabs and Strands Agents, so eight frameworks are claimed and two have a visible path. The apps directory holds the Next.js demo on port 3000 and two Pipecat variants, one of which is a cloud deployment and one of which is the fully local Ollama stack.
Editorial conclusion
The architecture is coherent and the numbers are worth checking against your own query shape before you believe them. Two things decide whether it fits. If your index cannot leave your process, Moss needs a cloud service to hold it first, because `create_index` and `load_index` are the steps that talk to moss.dev and only `query` is local. And if you are evaluating against Pinecone, Qdrant or ChromaDB, the published table gives Moss a local embedding step its competitors do not pay for in the measurement. Before committing, read the benchmark under `benchmarks/` and check whether your own numbers hold with the same comparison. Pin the SDK, expect two different npm scopes if you also want the browser build, and remember the release line you have been tracking belongs to the iOS SDK while the language in the repository root is Python.
Frequently asked questions
What is Moss?
A semantic search runtime for conversational AI agents, with hybrid retrieval combining semantic and keyword search in one query, built-in embedding models so no OpenAI key is required unless you bring your own, and metadata filtering through $eq, $and, $in and $near operators. It is installed with pip install moss, npm install @moss-js/moss, or a separate WebAssembly package for browsers.
How is Moss different from a hosted vector database?
The claim is that search and embedding both run inside your process instead of crossing a network hop, so a query stays in single-digit milliseconds. Its published benchmark puts Moss at 3.1 ms P50 and 5.4 ms P99 over 100,000 documents, against 351.8 ms for ChromaDB, 432.6 ms for Pinecone and 597.6 ms for Qdrant, measured on an M4 Pro laptop. The file notes the competitor figures exclude their external embedding step.
How do I get Moss credentials and which packages do I install?
You sign up at moss.dev for a project_id and project_key, with a free tier available. Python 3.10 and newer installs the package named moss, Node 20 and newer installs @moss-js/moss, and the browser build is the separately scoped @moss-dev/moss-web package compiled to WebAssembly. The Elixir and C SDKs are distributed through the repository releases as libmoss.
Does Moss provide SDKs for Go and iOS?
The SDK list in the file names Python, TypeScript and Node, Elixir and C, and does not mention Go or iOS. Both exist in the directory listing regardless: there is a go folder of samples and an ios folder, and the three most recent release tags, v0.6.2, v0.6.3 and v0.7.0, are all titled Moss iOS SDK even though the repository's primary language is Python.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/usemoss-moss)Star history chart for your README
[](https://hysenlabs.com/projects/usemoss-moss)Was this useful?