Moss review, pricing and limits

Moss is a retrieval SDK for AI agents, made by a San Francisco team backed by Y Combinator, that runs semantic search in-process at extremely low latency, cutting token usage compared with network-based RAG. It has surpassed a quarter million installs and ships as JavaScript, Python, Elixir, and C SDKs, with a free tier and three paid tiers above it.

Moss has passed 250,000 installs as a semantic search SDK for AI agents and voice copilots, running retrieval in-process instead of through a separate vector database. Built by a Y Combinator-backed team in San Francisco, it now publishes four pricing tiers, including an Enterprise plan with SOC2 and HIPAA compliance. Developers integrate it via JavaScript, Python, or TypeScript SDKs.

Maker: Moss (YC F25) · Protocol: REST · Auth: api key

Compatible agents: LangChain, DSPy, Vercel AI SDK, Pipecat, LiveKit, VAPI, ElevenLabs, VitePress, Next.js, Claude Desktop (via official MCP server), Any LLM with function-calling support

Required runtime: Node.js >= 16 (for JavaScript/TypeScript SDK), Python 3.9+ (for Python SDK), Moss Cloud project_id and project_key (free at moss.dev)

About Moss

Moss is a semantic search runtime built by Sri Raghu Malireddi and Harsha Nalluru (YC F25, San Francisco, founded 2024, now operating as InferEdge Inc.). Unlike a standalone vector database, Moss is a retrieval library embedded inside your own application: it runs queries entirely in-process with no network round trip to an external service. By September 2026 the SDK had passed a quarter million installs, with adoption concentrated among voice AI and real-time copilot teams.

The architecture works in two layers. Moss Cloud handles document ingestion, embedding, storage, and distribution. Developers register at moss.dev to receive a project_id and project_key, then pass them to the SDK. At startup the runtime downloads the vector index over HTTPS, holds it in memory, and serves every query locally. Once an index is loaded, no query leaves the process, which is the source of the low latency: on a 100,000-document benchmark (Apple M4 Pro, 750 measured queries, top_k=5), median retrieval finished in 3.1 milliseconds and P99 latency measured 5.4 milliseconds, covering both embedding inference and end-to-end retrieval. Moss publishes the same benchmark against ChromaDB, Qdrant, and Pinecone on its own site, each running well over 100x slower on the same workload.

Moss ships SDKs for JavaScript and TypeScript (browser via WebAssembly and Node.js), Python, Elixir, and C. Official integrations span agent and LLM frameworks (LangChain, DSPy, Vercel AI SDK), voice platforms (LiveKit, Pipecat, VAPI, ElevenLabs), and web or documentation tooling (Next.js, VitePress), plus an official MCP server for Claude Desktop, Cursor, and VS Code. In production pilots across voice AI and developer platforms, teams report cutting LLM token usage by 70-90% versus sending full documents as context.

Moss offers a no-cost entry plan with a limited monthly usage-credit allowance; three paid tiers, Hobbyist, Start-up, and a custom Enterprise plan, sit above it, with the Enterprise tier adding SSO, dedicated support, and compliance certifications for regulated production deployments. The core runtime is open source and hosted at github.com/usemoss/moss; Moss Cloud, the hosted ingestion and distribution layer, is not.

Key Features

• Sub-10ms Latency: Moss returns results in 3.1ms at P50 and 5.4ms at P99 across a 100,000-document, Apple M4 Pro benchmark, including embedding inference and end-to-end retrieval time.
• No Vector Database Required: Moss packages the entire index as a single artifact that lives in Moss Cloud and loads into the SDK runtime in memory, removing the need to manage a separate Pinecone, Qdrant, or Weaviate cluster.
• Runs Everywhere: A single SDK targets browsers (via WebAssembly), Node.js, edge runtimes, mobile devices, and cloud servers without code changes, letting the same retrieval logic run client-side or server-side.
• Hybrid Retrieval: Combines dense vector (semantic) search with keyword scoring in a single call, improving recall for queries that mix natural-language intent with specific product names or identifiers.
• Built-in Embeddings: Moss includes embedding models such as moss-minilm bundled with the SDK, so developers do not need to wire up a separate embedding API call before indexing or querying documents.
• Meaningful Token Savings: By retrieving only the top-k relevant passages instead of sending full documents to the LLM context window, production pilots report cutting token usage by 70-90% compared to standard RAG pipelines.
• Enterprise Compliance Tier: The Enterprise plan adds SOC2 and HIPAA compliance, single sign-on, and a 99.9% uptime SLA, closing the compliance gap that used to keep Moss out of regulated production deployments.
• Quarter-Million Installs: The Moss SDK has passed a quarter million installs across teams building voice AI, copilots, and other latency-sensitive retrieval systems in production.

Use Cases

• Voice Agent FAQ Retrieval: A voice agent calls client.query() to retrieve the top 3 matching FAQ answers in under 5ms, keeping the conversation flowing without a perceptible pause between the user question and the spoken response.
• Offline Browser Copilot: A JavaScript copilot loads the Moss WebAssembly runtime and a pre-built index, then serves semantic search entirely in the browser with no backend server, enabling privacy-first or air-gapped AI assistants.
• Real-Time Customer Support Agent: A support copilot indexes product documentation and queries Moss for relevant passages with each user message, cutting token usage by 70-90% compared to sending full documents to the LLM context window.
• On-Device Mobile AI Search: A mobile app bundles the Moss index and runtime on the device, giving users instant semantic search over personal notes or knowledge bases without a network connection.
• RAG Pipeline Latency Reduction: Teams migrating from Pinecone or Qdrant replace the external vector DB call with a local Moss runtime call, reducing retrieval latency from 80-300ms round trips down to 3-5ms while also cutting API costs.

Install

npm install @moss/sdk

Requirements

• Node.js >= 16 or Python 3.9+ (depending on SDK language)
• Sign up at moss.dev to obtain a free project_id and project_key
• Index your documents using client.createIndex() before querying

Actions

Create Index

Creates a new semantic search index from an array of documents and optionally specifies an embedding model.

import { MossClient } from '@moss/sdk';

const client = new MossClient({ projectId: 'proj_abc123', projectKey: 'key_xyz789' });

await client.createIndex('product-faq', [
  { id: 'doc1', text: 'Returns are accepted within 30 days of purchase.' },
  { id: 'doc2', text: 'Shipping takes 3 to 5 business days for standard delivery.' },
  { id: 'doc3', text: 'Contact support at help@example.com for order issues.' }
], { modelId: 'moss-minilm' });

• indexName (string) — required: Unique name for the index within the project.
• documents (array) — required: Array of document objects, each with an id (string) and text (string) field. Optionally include an embedding array for pre-computed vectors.
• options (object): Configuration object. Accepts modelId (string) to specify the embedding model, e.g. 'moss-minilm'.

Load Index

Downloads a pre-built index from Moss Cloud into the local runtime memory, enabling sub-10ms queries without further network calls.

await client.loadIndex('product-faq');

• indexName (string) — required: Name of the index to load from Moss Cloud into local memory.

Query

Performs a semantic search on a loaded index and returns the top-k most relevant documents, with optional hybrid keyword scoring.

const results = await client.query('product-faq', 'how long does shipping take', { topK: 3 });

for (const result of results) {
  console.log(result.id, result.score, result.text);
}

• indexName (string) — required: Name of the index to search against. Must be loaded first with loadIndex().
• queryText (string) — required: The natural-language query string to embed and search.
• options (object): Options object. Accepts topK (number, default 5) for the number of results to return, and embedding (array) to supply a pre-computed query vector.

Add Documents

Appends new documents to an existing index and updates the index on Moss Cloud without rebuilding from scratch.

await client.addDocuments('product-faq', [
  { id: 'doc4', text: 'We offer free shipping on orders over $50.' },
  { id: 'doc5', text: 'Gift wrapping is available at checkout for $5.' }
]);

• indexName (string) — required: Name of the existing index to append documents to.
• documents (array) — required: Array of document objects, each with an id (string) and text (string). Ids must be unique within the index.

List Indexes

Returns the names and metadata of all indexes in the current Moss Cloud project.

const indexes = await client.listIndexes();

for (const idx of indexes) {
  console.log(idx.name, idx.documentCount, idx.createdAt);
}

How to Invoke

Developers call SDK methods directly in application code: client.createIndex(), client.loadIndex(), client.query(), and client.addDocuments(). Queries run locally in-process after the index is loaded from Moss Cloud. Moss ships an official MCP server package (@moss-tools/mcp-server) that exposes index management as Model Context Protocol tools for Claude Desktop, Cursor, and VS Code.

Pricing

Moss publishes four tiers. Developer is free with $5 of monthly usage credits, unlimited local queries, and community support. Hobbyist is $30/month plus usage and adds the Continuous Sync Engine, unlimited projects and indexes, and 7-day session replays. Start-up is $200/month plus usage and adds Hot Path Cloud Search, 150 concurrent sessions, and 30-day session replays. Enterprise is custom-priced and adds a 99.9% SLA, single sign-on, 24/7 Slack support, and SOC2 and HIPAA compliance. All paid tiers add usage-based costs on top of the base subscription.

Strengths

• In-process retrieval finishes fast enough for real-time voice-agent turns, with no perceptible delay.
• WebAssembly build runs in the browser with no backend server, enabling fully offline or privacy-first AI applications.
• SDKs in four languages (JS/TS, Python, Elixir, C) plus ten official integrations across agent frameworks, voice platforms, and web frameworks cover most production AI stacks.
• No vector database infrastructure to provision, scale, or tune: one free-tier signup gives a working retrieval layer in minutes.

Weaknesses

• The free Developer tier includes only a small monthly usage-credit allowance, so production-scale indexing and querying typically requires a paid tier.
• Priority and round-the-clock support are limited to the top Enterprise tier; the Hobbyist and Start-up tiers rely on community or email support.
• Holding indexes in-process increases application memory footprint, which can be a constraint on low-RAM devices or edge runtimes.

View the official Moss skill page