Moorcheh Community Edition: Own Your Data. Run Your Search. Keep Your Memory.

We are releasing Moorcheh Community Edition for free - because retrieval and memory should not be locked behind a vendor's cloud. Moorcheh On-Prem is the self-hosted edition: the same information-theoretic search engine that powers our platform, running on your machine, under your control.

That choice is deliberate. The best way to say you should own your data is to ship software that makes ownership the default - not a premium tier, not an enterprise upsell, not a fork you have to negotiate for. Your documents, your embeddings, your indexed memory live on your disk, in your network, on your terms.

The question we keep hearing from teams building RAG and agentic AI is not "which vector database?" It is simpler: can our data stay ours? Moorcheh On-Prem exists so the answer is yes - without giving up semantic search, grounded answers, or production-grade retrieval.

How we license it: Moorcheh Community Edition is source-available and free for builders, researchers, and side projects - single-node, non-commercial deployments only (at most one active server instance). It includes the full vector search and RAG capabilities for that tier. Need clustering, enterprise SLAs, or commercial SaaS deployment? Moorcheh Enterprise handles scale-out production. Contact sales@moorcheh.ai.

The problem: your data is everywhere except with you

Most teams building retrieval-augmented generation (RAG) or agent memory end up with something like this:

• A vector database (Pinecone, Qdrant, Weaviate, pgvector…) - often hosted by someone else
• A separate embedding service - another API call, another vendor
• A chunking and ingestion pipeline
• A separate reranker (Cohere Rerank, cross-encoder models, or another API) to fix weak first-pass retrieval
• An LLM provider
• Glue code - often LangChain or LlamaIndex - to wire it all together

Every layer is a place where your documents, embeddings, and agent context can leave your boundary. Vector search alone often returns plausible-but-wrong chunks; so teams bolt on reranking as a second stage - more latency, more cost, more vendors. For regulated workloads you ask: who holds our index? who can see our queries? what happens when the API is down?

That assembly works - until ownership matters. Healthcare records, legal discovery, internal strategy docs, agent memories that accumulate over months - these are not workloads where "trust the SaaS" is good enough.

You should own your data. Not as a slogan. As architecture.

Moorcheh On-Prem is built around that principle: the retrieval layer runs on your hardware, stores under your home directory, and answers to you - not to a third-party vector SaaS dashboard.

What is Moorcheh?

Moorcheh is The Information-Theoretic Search Engine for RAG & Agentic Memory.

Moorcheh builds retrieval for places where memory, privacy, and control matter as much as recall quality. The conventional stack - HNSW graph + float32 vectors + cosine similarity + a separate reranker - works well in the data center. When you self-host, you still pay in RAM, latency, and ops complexity - and you still assemble multiple services by hand.

Our research, From HNSW to Information-Theoretic Binarization, argues for a different path: compress embeddings into compact one-bit codes at ingest, then score similarity with a metric designed for those codes. That approach preserves semantic signal while cutting memory dramatically versus float32 - on the order of ~32× for 768-d codes. That idea is the foundation of the Moorcheh stack across cloud, on-prem, and edge.

Moorcheh On-Prem packages those ideas for your machine:

• Docker image moorcheh/server
• Python SDK moorcheh-client
• Local API at http://localhost:8080
• Data under ~/.moorcheh/data - on your disk, in your account

Cloud Moorcheh targets larger multi-tenant deployments. On-Prem is what you run when the data must not leave your infrastructure - on a laptop, a workstation, or a private server behind your firewall.

It does not replace your embedding model or LLM. Moorcheh owns the store and the scan. You choose the embedder and the LLM. Your indexed knowledge stays local. Your provider choices for inference stay yours.

MIB, EDM, and ITS

MIB (Maximum Information Binarization) runs at upload. Each float embedding becomes a packed one-bit-per-dimension code.

EDM (Efficient Distance Metric) runs at query time - CPU-friendly bitwise scoring instead of high-dimensional float cosine.

ITS (Information-Theoretic Scoring) replaces the separate reranker pass common in cloud RAG stacks. No extra model. No second network hop. No sending your candidate chunks to another vendor's reranking API.

That matters for ownership: fewer external dependencies means fewer places your retrieval pipeline leaks data or breaks when a vendor changes terms.

Introducing Moorcheh On-Prem

Moorcheh On-Prem is the self-hosted Community Edition of Moorcheh - source-available, local by default, one command to run.

• Free Community Edition - client, CLI, and server image under the Moorcheh Community License on GitHub. Free for single-node, non-commercial deployments.
• Your data, your paths - ~/.moorcheh/data for the index, ~/.moorcheh/uploads for files, ~/.moorcheh/config.json for settings
• Easy to run - moorcheh up pulls moorcheh/server and starts the stack locally
• Developer-friendly - pip install moorcheh-client gives you a Python SDK and the moorcheh CLI

pip install moorcheh-client
moorcheh up
moorcheh status

API: http://localhost:8080
Data: ~/.moorcheh/data

When you run moorcheh down, containers stop but your data is preserved. Back up ~/.moorcheh and you back up everything.

Embedding and LLM providers are your choice:

• Ollama - fully local inference; Moorcheh can bundle Ollama in Docker or reuse a host install
• OpenAI or Cohere - cloud models for generation while your indexed data stays on-prem

That is the ownership model: local index by default, optional cloud only where you explicitly choose it.

What you can build - when you own the stack

Moorcheh On-Prem is a full retrieval and generation engine on hardware you control. Everything below runs against data that stays in your namespace on your machine.

Private semantic search

Search your own documents without shipping them to a hosted vector SaaS. Text or vector queries, multi-namespace, relevance thresholds, kiosk mode for stricter production behavior.

from moorcheh import MoorchehClient
 
client = MoorchehClient("http://localhost:8080")
 
results = client.similarity_search.query(
    namespaces=["docs"],
    query="What is our refund policy?",
    top_k=5,
)

Your corpus. Your index. Your queries. No third party sitting in the middle.

Grounded RAG on your documents

Retrieve context from your namespace and generate answers with your configured LLM - without your knowledge base living in someone else's cloud.

answer = client.answer.generate(
    namespace="docs",
    query="Summarize our refund policy for customers.",
)

Direct AI mode (empty namespace) is also available when you want LLM-only responses without retrieval.

Your files, your index

Upload text via JSON or index files from ~/.moorcheh/uploads - PDFs, DOCX, TXT, and more. Moorcheh chunks, embeds, and stores the index locally. The files on disk stay yours; the indexed representation stays under ~/.moorcheh/data.

Agentic memory - with Memanto

Agents that forget between sessions are agents that cannot compound. Agentic memory means persistent, searchable context across conversations, workflows, and tools - and it raises the ownership question loudest: who holds what your agents learned?

For that layer we built Memanto - an open-source memory agent powered by Moorcheh.

Memanto gives AI agents persistent long-term memory through three operations: remember, recall, and answer. It is built for Claude Code, Cursor, Codex, and 14+ other agent environments. Unlike passive vector stores your agent has to wire up manually, Memanto is an active memory layer designed for agent workflows - with typed memories, session continuity, and grounded answers pulled directly from what the agent stored.

Memanto is 100% free and open source (MIT license). For on-prem deployments it routes retrieval to Moorcheh On-Prem at http://localhost:8080 - so agent memories never leave your network. No Moorcheh Cloud API key required. Same engine. Your hardware.

pip install memanto
memanto   # choose Moorcheh On-Prem as backend

Moorcheh On-Prem is the retrieval engine. Memanto is the memory agent on top. Together they answer: your agents remember, your data stays yours.

If you are building agent memory yourself, Moorcheh namespaces are the primitive - one namespace per agent, user, or project. If you want a production-ready memory agent out of the box, start with Memanto on Moorcheh On-Prem.

Why ownership changes the architecture

Moorcheh is not PostgreSQL with pgvector bolted on. It is a purpose-built retrieval and memory engine - with the ops surface of a single container and a data path you can audit, back up, and air-gap.

Source-available client, production server image

We are releasing the Moorcheh On-Prem client and runtime as Moorcheh Community Edition:

• GitHub: github.com/moorcheh-ai/moorcheh-on-prem
• PyPI: moorcheh-client
• License: Moorcheh Community License - free for single-node, non-commercial use

The Moorcheh search server ships as a prebuilt multi-arch Docker image (moorcheh/server:latest) for linux/amd64 and linux/arm64.

Agent memory on the same stack: Memanto on GitHub - MIT licensed, built on Moorcheh.

We welcome contributions. See CONTRIBUTING.md.

Who is this for?

Moorcheh On-Prem is a strong fit if you:

• Believe you should own your data - not rent retrieval infrastructure
• Need on-prem, air-gapped, or compliance-grade deployment
• Build RAG apps and want search + answers without a vector SaaS in the loop
• Run agentic systems and want memory on your network - especially with Memanto
• Already use Moorcheh Cloud and want a self-hosted path with the same SDK shape

It may not be the right fit if you:

• Need a general-purpose OLTP database with vectors as a side feature
• Expect unlimited storage on the local tier - On-Prem currently supports up to 100,000 indexed items

Need billion-scale, multi-tenant production in a private environment? That is not what the Community Edition package optimizes for out of the box - but it is exactly what Moorcheh Enterprise is for. We deploy the full stack into your private cloud or VPC: same engine, same ownership model, scaled and operated for your organization. You still own your data. We handle the deployment. Contact sales@moorcheh.ai for multi-node, high availability, or commercial SaaS licensing.

Getting started in five minutes

Requirements: Python 3.10+, Docker, and an embedding provider (Ollama, OpenAI, or Cohere).

pip install moorcheh-client
moorcheh up          # first run: interactive embedding/LLM setup
moorcheh status      # health + quota

from moorcheh import MoorchehClient
 
client = MoorchehClient("http://localhost:8080")
 
client.namespaces.create("docs", type="text")
job = client.documents.upload("docs", documents=[
    {"id": "doc-1", "text": "My data stays on my machine."},
])
 
# Poll job["job_id"] until status == "completed", then:
 
hits = client.similarity_search.query(namespaces=["docs"], query="where is my data?", top_k=5)
answer = client.answer.generate(namespace="docs", query="Where is my data stored?")

moorcheh down        # stop containers; data is kept

For agent memory on the same stack:

pip install memanto
memanto   # select Moorcheh On-Prem backend

Full docs: docs.moorcheh.ai/on-prem · Memanto docs

What's next

v0.1.5 is the Community Edition launch - source-available under the Moorcheh Community License, refreshed docs, and a clear path from install to first query on infrastructure you control.

Coming up:

• Expanded On-Prem documentation and tutorials
• Deeper Memanto + Moorcheh On-Prem integration guides
• LangChain, LlamaIndex, and agent framework examples
• Community feedback from GitHub issues and contributions

If your requirement is simple - own your data, run your retrieval, keep your agents' memory - this is the stack.

Try it today

• Moorcheh On-Prem: github.com/moorcheh-ai/moorcheh-on-prem
• Memanto: memanto.ai · github.com/moorcheh-ai/memanto
• Install: pip install moorcheh-client
• Docs: docs.moorcheh.ai/on-prem
• Docker Hub: moorcheh/server

Star the repos. Open an issue. Tell us what you build - on your machine, with your data.

Moorcheh Community Edition: Free for single-node and non-commercial deployments.