moltis

A Rust-native claw you can trust. One binary — sandboxed, secure, auditable. Voice, memory, MCP tools, and multi-channel access built-in.

Installation

Run this command in your terminal to add the MCP server to Claude Code.

Run in terminal:

View docs

Command

claude mcp add --transport stdio moltis-org-moltis docker run -i ghcr.io/moltis-org/moltis:latest \
  --env MOLP_RUNTIME="Describe runtime mode if needed or placeholder" \
  --env MOLTIS_LOG_LEVEL="log level placeholder (e.g., info)"

How to use

Moltis is a Rust-native, single-binary AI gateway that runs your tools and agents in sandboxed environments on your own hardware. It provides a unified interface for orchestrating LLM providers, tool execution, memory and context management, and a variety of integration channels (web UI, messaging platforms, API access, and more). With Moltis you can deploy MCP servers that expose stdio and HTTP/SSE interfaces, allowing you to run tools and workflows securely inside isolated containers while keeping all data on your machine. The included features cover authentication, sandboxing, memory management, scheduling, and a suite of built-in MCP capabilities, so you can build complex AI-assisted workflows without relying on external runtimes.

To use Moltis, start the provided server (for example via the Docker image) and connect to its MCP interface. The gateway handles HTTP/WS communication and routes tool invocations to the appropriate providers and tools. You can leverage the built-in MCP ecosystem to add agents, memory workspaces, and tool execution strategies, and you can interact through the Web UI or programmatically via the API. Refer to the repository’s security and architecture sections to understand sandboxing, authentication, and how to audit and extend the system with additional providers and stores.

How to install

Prerequisites:

Docker installed on your machine (for the recommended run method)
Optional: Rust toolchain if you prefer building from source

Installation steps (Docker image):

Pull the Moltis Docker image: docker pull ghcr.io/moltis-org/moltis:latest
Run Moltis in a container (interactive): docker run -i ghcr.io/moltis-org/moltis:latest
If you want to run with specific environment variables, pass them through docker run: docker run -e MOLP_RUNTIME=production -e MOLTIS_LOG_LEVEL=info -it ghcr.io/moltis-org/moltis:latest

Alternative: install from source (requires Rust and Cargo):

Install Rust toolchain (Rust 1.91+ as recommended by the project): curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh source $HOME/.cargo/env
Build and install Moltis from GitHub: cargo install moltis --git https://github.com/moltis-org/moltis
Run the binary locally (if built from source and available on PATH): moltis

Note: The project also offers a Homebrew tap and a script-based installer for macOS/Linux as shown in the README. Use the method you’re most comfortable with.

Additional notes

Tips and considerations:

Docker deployment is the easiest way to get started and ensures sandboxing aligns with Moltis’ security model.
For constrained devices like Raspberry Pi, you can use --no-default-features --features lightweight when building from source.
Review the Security section in the project docs to understand how Moltis handles authentication, sandboxing, and secret management.
If you plan to expose an API or integrate with external providers, ensure proper network and firewall rules to limit exposure.
Keep the container image updated to receive security fixes and performance improvements.
The MCP capability includes stdio + HTTP/SSE interfaces; you can define and plug in custom MCP servers for tools and workflows.
Use the built-in store, hooks, and scheduling features to build robust, auditable automation pipelines.