freemcplab / Annuaire / Playground / Moltis

● Officiel moltis-org ⚡ Instantané

Moltis

Name: Moltis MCP Server
Author: moltis-org

Un serveur d'agent personnel à exécution continue : conserve la mémoire, exécute des outils dans un sandbox, prend en charge plusieurs fournisseurs LLM et s'expose via MCP.

Moltis est un service d'agent personnel écrit en Rust. Vous le connectez à Claude via MCP et il fournit une mémoire persistante, l'exécution de code/shell dans un sandbox, le routage multi-fournisseur LLM, ainsi que des surfaces voix et chat. Utile quand vous souhaitez un agent 24/7 qui survit d'une session à l'autre.

▶ Voir la démo 📦 Installer 💡 Cas d'usage

Pourquoi l'utiliser

Fonctionnalités clés

Mémoire persistante entre les sessions
Exécution de code/shell dans un sandbox
Routage multi-fournisseur LLM
Intégrations voix et chat
Auto-hébergé, binaire Rust
Expose ses capacités à Claude via MCP

Démo en direct

Aperçu en pratique

prêt

Installer

Choisissez votre client

~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "moltis-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-p",
        "8080:8080",
        "ghcr.io/moltis-org/moltis:latest"
      ]
    }
  }
}

Ouvrez Claude Desktop → Settings → Developer → Edit Config. Redémarrez après avoir enregistré.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "moltis-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-p",
        "8080:8080",
        "ghcr.io/moltis-org/moltis:latest"
      ]
    }
  }
}

Cursor utilise le même schéma mcpServers que Claude Desktop. La config projet l'emporte sur la globale.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "moltis-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-p",
        "8080:8080",
        "ghcr.io/moltis-org/moltis:latest"
      ]
    }
  }
}

Cliquez sur l'icône MCP Servers dans la barre latérale Cline, puis "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "moltis-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-p",
        "8080:8080",
        "ghcr.io/moltis-org/moltis:latest"
      ]
    }
  }
}

Même format que Claude Desktop. Redémarrez Windsurf pour appliquer.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "moltis-mcp",
      "command": "docker",
      "args": [
        "run",
        "-p",
        "8080:8080",
        "ghcr.io/moltis-org/moltis:latest"
      ]
    }
  ]
}

Continue utilise un tableau d'objets serveur plutôt qu'une map.

~/.config/zed/settings.json

{
  "context_servers": {
    "moltis-mcp": {
      "command": {
        "path": "docker",
        "args": [
          "run",
          "-p",
          "8080:8080",
          "ghcr.io/moltis-org/moltis:latest"
        ]
      }
    }
  }
}

Ajoutez dans context_servers. Zed recharge à chaud à la sauvegarde.

claude mcp add moltis-mcp -- docker run -p 8080:8080 ghcr.io/moltis-org/moltis:latest

Une seule ligne. Vérifiez avec claude mcp list. Supprimez avec claude mcp remove.

Cas d'usage

Usages concrets : Moltis

Exécuter un agent personnel toujours actif avec mémoire

👤 Développeurs ⏱ ~15 min intermediate

Quand l'utiliser : Vous souhaitez que le contexte persiste d'une session Claude à l'autre sans tout réexpliquer.

Déroulement

Déployer

Lancez l'image Docker Moltis et connectez vos clés LLM.✓ Copié

→ Service opérationnel
Connecter Claude

Ajoutez Moltis comme serveur MCP dans la configuration de Claude.✓ Copié

→ Outils visibles
Initialiser la mémoire

Indiquez à l'agent qui vous êtes, vos projets, vos préférences.✓ Copié

→ Mémoire persistée
Réutiliser

À la prochaine session, Claude lit depuis Moltis plutôt que de repartir de zéro.✓ Copié

→ Continuité

Résultat : Claude utilise Moltis comme mémoire long terme et sandbox.

Combinaisons

Associez-le à d'autres MCPs pour un effet X10

moltis-mcp + filesystem

Charger des fichiers dans le sandbox avant exécution

Combiner moltis-mcp avec filesystem : charger des fichiers dans le sandbox avant exécution✓ Copié

Outils

Ce que ce MCP expose

Outil	Entrées	Quand appeler	Coût
memory_read	(voir la documentation)	Lire des entrées mémoire par clé ou sujet	1 appel
memory_write	(voir la documentation)	Persister un fait ou une note	1 appel
sandbox_exec	(voir la documentation)	Exécuter du code/shell dans un environnement sandbox	1 appel

Coût et limites

Coût d'exécution

Quota d'API: Limité par votre fournisseur LLM
Tokens par appel: Les appels d'outils sont légers
Monétaire: OSS gratuit ; vos coûts d'hébergement + LLM
Astuce: Hébergez sur un petit VPS — le binaire Rust est léger

Sécurité

Permissions, secrets, portée

Portées minimales : agent:read agent:write

Stockage des identifiants : Clés LLM dans les variables d'environnement ; données de l'agent sur disque

Sortie de données : Vos fournisseurs LLM configurés

Ne jamais accorder : expose agent endpoint publicly without auth

Dépannage

Erreurs courantes et correctifs

Le sandbox refuse l'exécution

Vérifiez le profil seccomp ; certains appels système sont bloqués par conception

Alternatives

Moltis vs autres

Alternative	Quand l'utiliser	Compromis
memsearch	Vous n'avez besoin que de la mémoire	Pas de sandbox

Plus

Ressources

📖 Lire le README officiel sur GitHub

🐙 Voir les issues ouvertes

🔍 Parcourir les 400+ serveurs MCP et Skills