Moss

A sub-10 ms semantic search runtime that embeds in your app for browser, edge, on-device, and cloud AI retrieval.

Source repo
usemoss/moss
Stars
★ 889
Last updated
2d ago
License
BSD-2-Clause
Primary language
Python

At a glance

How it runs
Library / SDK
Works with
Portable with changes
Cost
Free tier plus a paid hosted plan
Setup effort
Low · running in minutes
You'll need
Python 3.10+Node.js 20+Shell / CLINetwork accessLocal filesystem
Typical use
Developers building voice customer-support agents where retrieval latency above a few milliseconds makes conversation feel laggy.
Not a fit if
  • Teams that can't have indexes hosted on Moss Cloud
  • Fully offline or air-gapped environments
Website
moss.dev ↗ set on GitHub
Maintenance
Commits in the last 30 dayslast commit 2026-11-19latest release c-sdk-v0.32.0 (2026-11-17)+12.0 ★/day over 7 days

What does this agent do, and when should you use it?

Moss is a retrieval runtime that runs search and embedding inside your own process instead of calling a remote vector database. It has three parts: Moss Cloud handles ingestion, embedding, storage, and distribution; an Index packages your documents and their vectors as a single artifact; and the Runtime is embedded in your application, pulls indexes over HTTPS, holds them in memory, and serves queries locally. SDKs expose create_index, load_index, and query, with hybrid semantic plus keyword retrieval, built-in embedding models, metadata filtering ($eq, $and, $in, $near), and a WebAssembly build (@moss-dev/moss-web) that runs entirely client-side. The project's benchmark on 100,000 documents reports 3.1 ms P50 end-to-end latency, versus hundreds of milliseconds for remote vector databases. The repository also ships a CLI, database connectors, and integrations for LangChain, LlamaIndex, Pipecat, LiveKit, Vapi, ElevenLabs and more, under BSD-2-Clause.

The end-to-end flow starts at moss.dev, where you sign up for a project_id and project_key. You then call MossClient.create_index with documents that carry an id and text; Moss Cloud generates embeddings and packages them into a distributable index. Calling load_index pulls that index over HTTPS into local memory, and query performs embedding plus search inside the same process, returning a docs list together with time_taken_ms. Queries accept QueryOptions(top_k=...) or { topK } to control result count, and metadata operators filter results. For browser use, @moss-dev/moss-web is a separate WebAssembly build that downloads the index and answers queries client-side with no server. The repository additionally contains the moss-cli package for terminal index management, moss-data-connector for ingesting from SQLite, MongoDB, MySQL and Supabase, and runnable examples and apps covering multiple languages, voice agents, and framework cookbooks.

  1. Developers building voice customer-support agents where retrieval latency above a few milliseconds makes conversation feel laggy.
  2. Backend teams assembling a RAG stack who would rather embed the runtime than operate a vector database cluster.
  3. Frontend teams building static sites or browser extensions that need client-side semantic search via the WebAssembly SDK.
  4. Teams already on LangChain, LlamaIndex, DSPy, or CrewAI who want to swap in a lower-latency retriever.
  5. Builders of Pipecat, LiveKit, Vapi, or ElevenLabs voice pipelines that need retrieval inside a real-time audio loop.
  6. Teams syncing existing SQLite, MongoDB, MySQL, or Supabase data who want a ready ingestion connector.

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Install / run
  • pip install moss
  • npm install @moss-dev/moss
  • npm install @moss-dev/moss-web
  • pip install -r requirements.txt
Config files
../../.env.example .env

How do you install or deploy this agent?

Server-side, install the SDK for your language and register at moss.dev for a project_id and project_key. Python requires 3.10+:

pip install moss

TypeScript / Node.js requires 20+:

npm install @moss-dev/moss

For the browser, use the separate WebAssembly package:

npm install @moss-dev/moss-web

To run a bundled example, copy the env template and fill in your credentials:

cd examples/python
pip install -r requirements.txt
cp ../../.env.example .env
python load_and_query_sample.py

How do you use this agent?

End-to-end Python usage:

from moss import MossClient, QueryOptions

client = MossClient("your_project_id", "your_project_key")

await client.create_index("support-docs", [
    {"id": "1", "text": "Refunds are processed within 3-5 business days."},
    {"id": "2", "text": "You can track your order on the dashboard."},
    {"id": "3", "text": "We offer 24/7 live chat support."},
])

await client.load_index("support-docs")
results = await client.query("support-docs", "how long do refunds take?", QueryOptions(top_k=3))

End-to-end TypeScript usage:

import { MossClient } from "@moss-dev/moss";

const client = new MossClient("your_project_id", "your_project_key");

await client.createIndex("support-docs", [
  { id: "1", text: "Refunds are processed within 3-5 business days." },
  { id: "2", text: "You can track your order on the dashboard." },
  { id: "3", text: "We offer 24/7 live chat support." },
]);

await client.loadIndex("support-docs");
const results = await client.query("support-docs", "how long do refunds take?", { topK: 3 });

What are this agent's strengths and limitations?

Pros
  • Queries execute inside your process; the published benchmark reports 3.1 ms P50 on 100,000 documents, two orders of magnitude below remote vector databases
  • Built-in embedding models mean no external embedding API key is required, with a bring-your-own-embedding path as well
  • Two runtime targets: server-side SDKs plus a WebAssembly browser build for fully client-side search
  • SDKs for Python, TypeScript, Elixir, and C, plus a CLI, database connectors, and many framework and voice-agent example apps
  • BSD-2-Clause licensed with SDKs, examples, and integrations fully open source
Limitations
  • Index ingestion, embedding, storage, and distribution happen on Moss Cloud, so you need project credentials and cannot build indexes entirely offline
  • Benchmark numbers are self-reported, and the comparison uses external embedding services for competitors, so absolute gains should be reproduced on your own data
  • Documentation and examples are English-first, which adds work for non-English teams
  • Python SDK needs 3.10+ and Node.js needs 20+, so older runtimes are unsupported

How does this agent compare with similar options?

The README benchmarks Moss against Pinecone (432.6 ms end-to-end P50), Qdrant (597.6 ms), and ChromaDB (351.8 ms), arguing those systems pay a remote round trip while Moss runs search and embedding in-process. It also states explicitly that Moss is not a database: there are no clusters to manage, no HNSW parameters to tune, and no sharding to consider.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Moss This agent 53 · Major gaps Library / SDKFreemium ★ 889 2d ago Python —
MCP Memory Service 68 · Some gaps MCP serverFree ★ 2.1k 1d ago Python ChatGPT · Codex · Claude Code · Claude.ai
RAGLight 66 · Some gaps CLIFree + model costs ★ 672 1mo ago Python OpenAI API
AgentOS 64 · Some gaps Library / SDKFree + model costs ★ 691 1d ago TypeScript Claude Code · OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
53/ 100 5-point scale 2.7 / 5
This review covers the source as of Nov 08, 2026. The project has shipped 6 stable release(s) since, which have not been re-reviewed. The score and verdict describe the reviewed version only. Recent releases ↓
Trust 11/29
Reliability 6/14
Adaptability 12/18
Convention 10/18
Effectiveness 10/13
Verifiability 4/8
Why each dimension lost points
Trust11 / 29 · 1.9/5

AGENTS.md distinguishes local querying from cloud index distribution, examples show credentials supplied through environment variables, and the Agora example restricts the available MCP tool; this supports data-flow transparency and a limited-permission assessment. Points are deducted because retrieval, index creation, document addition, and deletion are shown without confirmation or recovery mechanisms; examples involve PDF uploads, cloud services, and credentials without enough detail on sensitive-data protection, dependency risk, or organizational responsibility. Attribution names the Moss team, while publisher identity remains unknown.

Reliability6 / 14 · 2.1/5

README, AGENTS.md, and the examples are broadly consistent about SDKs, cloud indexes, and the local runtime, and the CI file lists several checks and tests. However, the repository spans multiple SDKs, integrations, and apps, and this sample cannot establish consistency or dependency availability across the whole product. The Python Docker example clearly reports missing environment variables, and the PDF app gives concrete responses for empty extraction and seed-index load failure, so failure messaging scores relatively well within the supplied evidence.

Adaptability12 / 18 · 3.3/5

README and AGENTS.md describe clear scenarios across Python, TypeScript, browser, cloud, edge/on-device use, frameworks, and voice agents, with strong audience and scenario coverage. They also state that Moss is a search runtime rather than a database and distinguish server and browser SDKs; however, the supplied material says little about scale, data governance, or deployment constraints. The Zo skill has broad triggers, including searching before giving advice, and directs automatic index listing, loading, and searching at the start of most conversations, so trigger boundaries are not precise.

Convention10 / 18 · 2.8/5

README and AGENTS.md provide detailed repository maps, integration tables, quickstarts, and instructions for running examples; the Zo skill maps commands and user signals to actions. Limitations include the experimental status of live labs, the statement that Moss is not a database, and SDK runtime requirements. Points are deducted because README describes differing licenses across SDKs while the supplied metadata says BSD-2-Clause; version history is absent from the packet; naming and release scope show possible inconsistencies (README and AGENTS.md describe different JS package names); and maintenance responsibility is represented mainly by a team name and security-report email, with little further evidence of an update path.

Effectiveness10 / 13 · 3.8/5

The product offers local querying after index loading, hybrid semantic and keyword search, filtering, and multiple SDKs and integrations. Quickstarts and examples show how to issue queries and present results, giving the repository practical integration value. README supplies latency figures and a reproduction pointer, but this packet contains only the claims and pointer, not enough to verify comparison conditions. Cost-benefit claims rely mainly on performance and reduced cluster management, with little detail on resource use, index synchronization, or operating costs, so full marks are not justified.

Verifiability4 / 8 · 2.5/5

README, AGENTS.md, examples, CI workflows, and the security policy provide some corroborating evidence about capabilities and processes, and README gives benchmark parameters and a reproduction pointer. Points are deducted because key performance and product claims remain largely self-reported, while the packet omits benchmark implementation, primary SDK source, and complete test evidence; README also contains apparent inconsistencies in license presentation and package naming. The materials do not consistently distinguish measured facts from inference, so this criterion scores low.

Risks and how to mitigate them
  • Performance benchmarks are reported in the README; this static review did not run the code or verify benchmark methods or results.
  • Check the license for the specific SDK, example, or component in use. README describes BSD-2-Clause and PolyForm Shield coverage, so the supplied license metadata alone may not settle component licensing.
  • The Zo skill recommends automatically listing and loading indexes in new conversations and searching under broad conditions; review its data-access scope and triggers before deployment.
Evidence confidence: Low Reviewed Nov 08, 2026 Reviewed revision b5a862f48ee6 New commits since this review; the score may not cover them
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/moss.svg)](https://followagents.com/en/agents/moss)
<a href="https://followagents.com/en/agents/moss"><img src="https://followagents.com/badge/moss.svg" alt="FARS review"></a>

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. c-sdk-v0.32.0 libmoss v0.32.0
    Release notes excerpt
    Precompiled C SDK binaries for the Moss SDK. Added - Each archive carries LICENSE.txt, the PolyForm Shield License 1.0.0 terms of the library. The release notes name them too. Changed - A new client loads an index from cache_path in about one round trip to the Moss cloud when another client or session in the same process has the index's model loaded. Clients in one process share the project's token and each loaded embedding model, and on macOS, Linux and Windows also their connections to the cloud; every load still checks the cloud version of the index. Freeing the last client …
    View on GitHub ↗
  2. v0.16.0 Moss iOS SDK v0.16.0
    Release notes excerpt
    Moss iOS SDK v0.16.0. SwiftPM consumption ```swift .package(url: "https://github.com/usemoss/moss", from: "0.16.0"), ``` Package.swift binary target ```swift .binaryTarget( name: "MossC", url: "https://github.com/usemoss/moss/releases/download/v0.16.0/Moss.xcframework.zip", checksum: "054bad915dea8f219bde016f36f69a9559277975e316da7b45403a780918c2ab" ) ``` SHA-256: 054bad915dea8f219bde016f36f69a9559277975e316da7b45403a780918c2ab What's in the zip - Moss.xcframework with the iOS device (arm64) and simulator (arm64) slices …
    View on GitHub ↗
  3. android-sdk-v0.32.0 Moss Android SDK v0.32.0
    Release notes excerpt
    Moss Android SDK v0.32.0. AAR: moss-android-0.32.0.aar (arm64-v8a, minSdk 24, namespace dev.usemoss.moss). SHA-256: d59042e00235e64ddb311f9afa93adbb9394709e91c215907e72b13965a06278 Added - License. The AAR carries LICENSE.txt, the PolyForm Shield License 1.0.0 terms of the SDK, at META-INF/LICENSE.txt and beside the notices at assets/moss/LICENSE.txt. The release attaches it and its notes name the terms. Changed - A client created after another one in the same app reuses the project's token …
    View on GitHub ↗

FAQ

Do I have to pay to use Moss?
The README says a free tier is available after signing up at moss.dev for project_id and project_key. The repository code is BSD-2-Clause, but indexes are hosted on Moss Cloud, so cost depends on your plan there.
Does my document data leave my machine?
Yes. Per the architecture section, Moss Cloud handles ingestion, embedding, storage, and distribution; the runtime only pulls indexes over HTTPS and serves queries locally. If data cannot go to an external service, this model does not fit.
Can it run with no server at all?
The @moss-dev/moss-web WebAssembly package queries indexes entirely client-side, which removes the server from the query path, but the index itself is still built and distributed by Moss Cloud.
How is this different from a vector database?
The README states Moss is not a database but a search runtime: you index documents, load them into the runtime, and query, without managing clusters, tuning HNSW parameters, or worrying about sharding.
Is Moss open source?
Yes. The source code is on GitHub (usemoss/moss) under the BSD-2-Clause licence.
Is Moss safe to use?
FollowAgents' FARS review (Nov 08, 2026) scored Moss 11/29 on trust and safety. None of the eight safety controls the review checks for was missing outright. The repository has changed since that review.
Is Moss still maintained?
Yes. The latest commit on GitHub is from 2026-11-19, within the last 30 days. The latest release is c-sdk-v0.32.0 (2026-11-17).
Who makes Moss?
Moss is published on GitHub by the account usemoss. FollowAgents has not verified which person or company is behind that account.
What is Moss's official website?
The project's GitHub repository lists https://moss.dev as its website. That link is set by the repository owner; the source code itself is on GitHub (usemoss/moss).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts