<div align="center">

<a href="https://moltis.org"><img src="https://raw.githubusercontent.com/moltis-org/moltis/main/website/favicon.svg" alt="Moltis" width="64"></a>

# Moltis — Um servidor de agente pessoal persistente e seguro em Rust

Um único binário — isolado em sandbox, seguro, seu.

[![CI](https://github.com/moltis-org/moltis/actions/workflows/ci.yml/badge.svg)](https://github.com/moltis-org/moltis/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/moltis-org/moltis/graph/badge.svg)](https://codecov.io/gh/moltis-org/moltis)
[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json&style=flat&label=CodSpeed)](https://codspeed.io/moltis-org/moltis)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
[![Rust](https://img.shields.io/badge/Rust-1.91+-orange.svg)](https://www.rust-lang.org)
[![Discord](https://img.shields.io/discord/1469505370169933837?color=5865F2&label=Discord&logo=discord&logoColor=white)](https://discord.gg/XnmrepsXp5)

[Instalação](#installation) • [Comparação](#comparison) • [Arquitetura](#architecture--crate-map) • [Segurança](#security) • [Recursos](#features) • [Como Funciona](#how-it-works) • [Contribuindo](https://github.com/moltis-org/moltis/blob/main/CONTRIBUTING.md)

</div>

---

O Moltis recentemente alcançou [a página inicial do Hacker News](https://news.ycombinator.com/item?id=46993587). Por favor, [abra uma issue](https://github.com/moltis-org/moltis/issues) para qualquer dificuldade que encontrar. Estou focado em tornar o Moltis excelente.

**Seguro por design** — Suas chaves nunca saem da sua máquina. Cada comando é executado em um contêiner isolado em sandbox, nunca no seu host.

**Seu hardware** — Roda em um Mac Mini, um Raspberry Pi ou qualquer servidor que você possua. Um único binário Rust, sem Node.js, sem npm, sem runtime.

**Completo em recursos** — Voz, memória, recordação entre sessões, checkpoints automáticos de edição, agendamento, Telegram, Signal, Discord, automação de navegador, servidores MCP, execução remota via SSH ou baseada em nós, chaves de deploy gerenciadas com fixação de host na interface web, um inventário ao vivo em Configurações → Ferramentas, contexto de projeto compatível com Cursor e verificação de ameaças em arquivos de contexto — tudo integrado. Sem marketplace de plugins para ser atacado via cadeia de suprimentos.

**Auditável** — O executor do agente e a interface de modelos cabem em ~7,5 mil linhas, com os provedores em ~19 mil adicionais. O workspace Rust tem ~270 mil linhas distribuídas em 59 crates modulares que você pode auditar de forma independente, com mais de 470 arquivos Rust contendo testes. O código unsafe está isolado nas fronteiras de FFI e de runtime pré-compilado, não no loop principal do agente.

## Instalação

```bash
# One-liner install script (macOS / Linux)
curl -fsSL https://www.moltis.org/install.sh | sh

# macOS / Linux via Homebrew
brew install moltis-org/tap/moltis

# Docker (multi-arch: amd64/arm64)
docker pull ghcr.io/moltis-org/moltis:latest

# Or build from source
cargo install moltis --git https://github.com/moltis-org/moltis
```

## Comparação

| | OpenClaw | Hermes Agent | **Moltis** |
|---|---|---|---|
| Stack principal | TypeScript + apps complementares Swift/Kotlin | Python + superfícies TUI/web em TypeScript | **Rust** |
| Runtime | Node.js + npm/pnpm/bun | Python + uv/pip, peças opcionais de UI em Node | **Binário Rust único** |
| Tamanho do checkout local\* | ~1,1M LoC de app | ~152K LoC de app | **~270K LoC Rust** |
| Arquitetura | Gateway amplo, canal, nó e ecossistema de apps | Agente CLI/gateway com loop de aprendizado e ferramentas de pesquisa | **Servidor de agente pessoal persistente com crates modulares** |
| Crates/módulos | pacotes npm, extensões, apps | pacotes Python, plugins, ferramentas, TUI | **59 crates do workspace Rust** |
| Sandbox/backends | Permissões em nível de app, ferramentas de browser/nó | Local, Docker, SSH, Daytona, Singularity, Modal | **Docker/Podman + Apple Container + WASM** |
| Autenticação/acesso | Emparelhamento e controles de gateway local | Configuração de CLI e gateway de mensagens | **Senha + Passkey + Chaves de API + Vault** |
| E/S de voz | Modos de ativação por voz e conversação | Transcrição de memorandos de voz | **Provedores STT + TTS integrados** |
| MCP | Suporte a plugins/integração | Integração MCP | **stdio + HTTP/SSE** |
| Skills | Skills empacotadas, gerenciadas e de workspace | Skills autoaperfeiçoáveis e suporte ao Skills Hub | **Skills empacotadas/de workspace + aprimoramento autônomo + importação do OpenClaw** |
| Memória/RAG | Memória e motor de contexto com suporte de plugins | Memória curada pelo agente, busca de sessão, modelagem de usuário | **SQLite + FTS + memória vetorial** |

\* LoC medido com `tokei`, excluindo `node_modules`, saída de build gerada, `dist` e `target`.

> [Comparação completa na documentação →](https://docs.moltis.org/comparison.html)

## Arquitetura — Mapa de Crates

Workspace Rust atual: ~270K LoC em 59 crates. A tabela abaixo agrupa os principais crates por função para manter a arquitetura legível.

**Runtime principal**:

| Crate | LoC | Função |
|-------|-----|------|
| `moltis-gateway` | 37,4K | Servidor HTTP/WS, RPC, autenticação, ligação de inicialização |
| `moltis-tools` | 37,0K | Execução de ferramentas, sandboxing, ferramentas WASM |
| `moltis-providers` | 18,9K | Implementações de provedores LLM |
| `moltis-agents` | 14,5K | Loop do agente, streaming, montagem de prompt |
| `moltis-chat` | 14,2K | Motor de chat, orquestração de agentes |
| `moltis-config` | 10,3K | Configuração, validação |
| `moltis-httpd` | 9,9K | Primitivas e middleware de servidor HTTP |
| `moltis` (CLI) | 4,7K | Ponto de entrada, comandos CLI |
| `moltis-sessions` | 3,5K | Persistência de sessões |
| `moltis-common` | 1,5K | Utilitários compartilhados |
| `moltis-service-traits` | 1,2K | Interfaces de serviço compartilhadas |
| `moltis-protocol` | 0,7K | Tipos de protocolo de comunicação |

**Crates de recursos e integrações**:

| Categoria | Crates | LoC combinadas |
|----------|--------|-------------|
| Canais | `moltis-telegram`, `moltis-whatsapp`, `moltis-signal`, `moltis-discord`, `moltis-msteams`, `moltis-matrix`, `moltis-slack`, `moltis-nostr`, `moltis-channels` | 34,0K |
| Web e APIs | `moltis-web`, `moltis-graphql`, `moltis-webhooks` | 10,8K |
| Extensibilidade | `moltis-mcp`, `moltis-mcp-agent-bridge`, `moltis-skills`, `moltis-plugins` | 11,5K |
| Memória e contexto | `moltis-memory`, `moltis-qmd`, `moltis-code-index`, `moltis-projects` | 11,7K |
| Voz e browser | `moltis-voice`, `moltis-browser` | 9,2K |
| Autenticação e segurança | `moltis-auth`, `moltis-oauth`, `moltis-vault`, `moltis-secret-store`, `moltis-network-filter`, `moltis-tls` | 8,5K |
| Agendamento e automação | `moltis-cron`, `moltis-caldav`, `moltis-auto-reply` | 4,7K |
| Configuração e importação | `moltis-provider-setup`, `moltis-openclaw-import`, `moltis-onboarding` | 11,7K |
| Hosts nativos e de nó | `moltis-swift-bridge`, `moltis-node-host`, `moltis-courier` | 5,7K |
| Ferramentas WASM | `moltis-wasm-precompile`, `moltis-wasm-calc`, `moltis-wasm-web-fetch`, `moltis-wasm-web-search` | 1,4K |
| Crates de suporte | `moltis-media`, `moltis-metrics`, `moltis-tailscale`, `moltis-routing`, `moltis-canvas`, `moltis-schema-export`, `benchmarks` | 2,1K |

Use `--no-default-features --features lightweight` para dispositivos com recursos limitados (Raspberry Pi, etc.).

## Segurança

- **Superfície de unsafe reduzida** — o código principal do agente/gateway permanece em Rust seguro; o unsafe fica isolado nas fronteiras de FFI do Swift, wrappers de modelos locais e WASM pré-compilado
- **Execução em sandbox** — Docker + Apple Container, isolamento por sessão
- **Tratamento de segredos** — `secrecy::Secret`, zerado ao ser descartado, ocultado da saída das ferramentas
- **Autenticação** — senha + passkey (WebAuthn), com limite de taxa, throttle por IP
- **Proteção contra SSRF** — resolução via DNS, bloqueia loopback/privado/link-local
- **Validação de origem** — rejeita upgrades de WebSocket cross-origin
- **Gating de hooks** — hooks `BeforeToolCall` podem inspecionar/bloquear qualquer invocação de ferramenta
- **Integridade da cadeia de suprimentos** — [atestados de artefatos](https://github.com/moltis-org/moltis/attestations), assinatura keyless com Sigstore, assinatura GPG (YubiKey), checksums SHA-256/SHA-512

Consulte [Security Architecture](https://docs.moltis.org/security.html) para detalhes.
Verifique as releases com `gh attestation verify <artifact> -R moltis-org/moltis` ou consulte [Release Verification](https://docs.moltis.org/release-verification.html).

## Features

- **Reasoning Defaults** - Esforço de raciocínio padrão configurável para sessões principais sem modelo e novas, com substituições explícitas por sessão de Off ou de nível
- **AI Gateway** — Suporte a múltiplos provedores de LLM (OpenAI Codex, GitHub Copilot, Local), respostas em streaming, loop de agente com delegação a sub-agentes, modos de sessão, execução paralela de ferramentas
- **Comunicação** — Interface web com prompts de agente via paleta de comandos e cópia/exportação em Markdown, Telegram, Signal, Microsoft Teams, Discord, Slack com cards nativos de ferramentas ao vivo, DMs Nostr + chat em grupo NIP-29 (incl. canais Buzz da Block), acesso via API, E/S de voz (8 provedores TTS + 7 STT), PWA móvel com notificações push
- **Aplicativo Desktop** — Cliente nativo em Rust/gpui que se conecta a um daemon em execução localmente, via HTTPS ou por um túnel SSH; chaves de API com escopo armazenadas no keychain, certificate pinning, markdown nativo em streaming, aprovações com notificações do sistema
- **Memória e Recall** — Workspaces de memória por agente, memória de longo prazo com embeddings, busca híbrida vetorial + texto completo, persistência de sessão com auto-compactação, recall entre sessões, contexto de projeto compatível com Cursor, verificação de segurança de arquivos de contexto
- **Managed Files** - Gerenciamento de arquivos aninhados autenticado em Settings, com um caminho de host anunciado pelo agente e mounts independentes somente leitura por padrão para sandboxes Docker, Podman e Apple Container
- **Edição de Agente Mais Segura** — Checkpoints automáticos antes de mutações em skills e memória integradas, ferramentas de restauração, ramificação de sessão
- **Extensibilidade** — Servidores MCP (stdio + HTTP/SSE), sistema de skills, 15 eventos de hook de ciclo de vida com circuit breaker, guarda de comandos destrutivos
- **Agent Client Protocol** — controla agentes ACP externos (`codex-acp`, `claude-agent-acp`, Cursor) e serve o Moltis para clientes ACP via stdio por meio de `moltis acp`
- **Primeira Execução** — Abre o onboarding no seu navegador com o código de configuração pré-preenchido, serve `http://localhost` sem certificado, oferece uma vez a confiança em uma CA local com nome restrito para HTTPS em LAN, e fixa a URL da interface web abaixo dos logs do terminal (com uma dica de `ssh -L` via SSH)
- **Segurança** — Cofre com criptografia em repouso (XChaCha20-Poly1305 + Argon2id), autenticação por senha + passkey + chave de API, isolamento em sandbox, proteção contra SSRF/CSWSH
- **Operações** — Agendamento via Cron, CalDAV local durável, Gmail, e-mail Himalaya, e conjuntos de dados de mensagens reutilizáveis para Slack/Discord/Matrix/Teams, ferramentas de agente somente leitura específicas por provedor, busca rápida em texto completo, projeções JSONL/Markdown, instrumentação de agente (Langfuse para traces de LLM, OTLP para Grafana/Datadog), métricas Prometheus, deploy em nuvem (Fly.io, DigitalOcean), integração com Tailscale, chaves de deploy SSH gerenciadas, alvos remotos fixados ao host, inventário de ferramentas ao vivo em Settings, e fluxos de doctor para execução remota via CLI/web

## Como Funciona

O Moltis é um **servidor de agente persistente local-first** — um único binário Rust que
fica entre você e múltiplos provedores de LLM, mantém estado de sessão durável e
pode se comunicar com você por vários canais sem entregar seus dados a um relay na nuvem.

```
┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│   Web UI    │  │  Telegram   │  │  Discord    │
└──────┬──────┘  └──────┬──────┘  └──────┬──────┘
       │                │                │
       └────────┬───────┴────────┬───────┘
                │   WebSocket    │
                ▼                ▼
        ┌─────────────────────────────────┐
        │          Gateway Server         │
        │   (Axum · HTTP · WS · Auth)     │
        ├─────────────────────────────────┤
        │        Chat Service             │
        │  ┌───────────┐ ┌─────────────┐  │
        │  │   Agent   │ │    Tool     │  │
        │  │   Runner  │◄┤   Registry  │  │
        │  └─────┬─────┘ └─────────────┘  │
        │        │                        │
        │  ┌─────▼─────────────────────┐  │
        │  │    Provider Registry      │  │
        │  │  Multiple providers       │  │
        │  │  (Codex · Copilot · Local)│  │
        │  └───────────────────────────┘  │
        ├─────────────────────────────────┤
        │  Sessions  │ Memory  │  Hooks   │
        │  (JSONL)   │ (SQLite)│ (events) │
        └─────────────────────────────────┘
                       │
               ┌───────▼───────┐
               │    Sandbox    │
               │ Docker/Apple  │
               │  Container    │
               └───────────────┘
```

Consulte o [Quickstart](https://docs.moltis.org/quickstart.html) para obter detalhes sobre a inicialização do gateway, o fluxo de mensagens, as sessões e a memória.

## Primeiros Passos

### Compilar e Executar

Requer [just](https://github.com/casey/just) (executor de comandos) e Node.js (para Tailwind CSS).

```bash
git clone https://github.com/moltis-org/moltis.git
cd moltis
just build-css                  # Build Tailwind CSS for the web UI
just build-release              # Build in release mode
cargo run --release --bin moltis
```

Para uma compilação de lançamento completa, incluindo as ferramentas de sandbox WASM:

```bash
just build-release-with-wasm    # Builds WASM artifacts + release binary
cargo run --release --bin moltis
```

Abra `https://moltis.localhost:3000`. Na primeira execução, um código de configuração é impresso no
terminal — insira-o na interface web para definir sua senha ou registrar uma passkey.

Flags opcionais: `--config-dir /path/to/config --data-dir /path/to/data`

### Docker

```bash
# Docker / OrbStack
docker run -d \
  --name moltis \
  -p 13131:13131 \
  -p 13132:13132 \
  -p 1455:1455 \
  -v moltis-config:/home/moltis/.config/moltis \
  -v moltis-data:/home/moltis/.moltis \
  -v /var/run/docker.sock:/var/run/docker.sock \
  ghcr.io/moltis-org/moltis:latest
```

Abra `https://localhost:13131` e conclua a configuração. Para implantações Docker não assistidas, defina `MOLTIS_PASSWORD`, `MOLTIS_PROVIDER` e `MOLTIS_API_KEY` antes da primeira inicialização para ignorar o assistente de configuração. Consulte a [documentação do Docker](https://docs.moltis.org/docker.html) para detalhes sobre Podman, OrbStack, confiança TLS e persistência.

### Implantação em Nuvem

| Provedor | Implantar |
|----------|--------|
| DigitalOcean | [![Deploy to DO](https://www.deploytodo.com/do-btn-blue.svg)](https://cloud.digitalocean.com/apps/new?repo=https://github.com/moltis-org/moltis/tree/main) |

**Fly.io** (CLI):

```bash
fly launch --image ghcr.io/moltis-org/moltis:latest
fly secrets set MOLTIS_PASSWORD="your-password"
```

Todas as configurações de nuvem usam `--no-tls` porque o provedor lida com a terminação TLS.
Consulte a [documentação de implantação em nuvem](https://docs.moltis.org/cloud-deploy.html) para obter detalhes.

## Licença

MIT
Baixar ferramenta
Mais Populares

moltis
