MoltBot, anciennement connu sous le nom de ClawdBot, se distingue comme un agent auto-hébergé qui s'intègre directement aux plateformes de messagerie telles que Telegram, WhatsApp, Discord et Slack. Il exécute des tâches réelles sur votre machine tout en préservant la confidentialité et en offrant une faible latence.
La connexion de Kimi K2.5 à MoltBot crée un assistant polyvalent et économique. Les utilisateurs bénéficient de performances solides pour les tâches générales, le travail créatif et les comportements d'agent à une fraction du coût de modèles comme Claude 3.5 Sonnet ou GPT-4o. Pour les configurations axées sur la confidentialité, le déploiement local utilisant des poids GGUF quantifiés élimine toute transmission de données externes.
Ce guide explique en détail les méthodes API et locales. Il comprend des exemples de configuration, des étapes de vérification et des solutions aux problèmes fréquents.
Pourquoi associer MoltBot à Kimi K2.5 ?
MoltBot sert de couche d'exécution, tandis que le LLM fournit l'intelligence. Kimi K2.5 offre des avantages distincts dans ce rôle.
Le modèle offre une capacité élevée grâce à sa conception MoE, activant efficacement les experts pertinents. Il gère les entrées multimodales nativement, permettant à MoltBot de traiter des captures d'écran, des conceptions d'interface utilisateur ou de courtes vidéos pour des tâches comme la génération de code à partir de visuels.
La longueur du contexte atteint 256K tokens dans la plupart des déploiements, permettant la rétention de vastes bases de code de projets, de documentations ou d'historiques de conversations – essentiels pour les assistants persistants.
Les coûts d'API restent bas par rapport aux alternatives occidentales. Les gros utilisateurs réalisent des économies substantielles sur le long terme. Pour une dépense continue nulle et un contrôle maximal, l'inférence locale fonctionne sur du matériel grand public avec quantification.
Kimi K2.5 démontre de fortes capacités d'agent, y compris des essaims auto-dirigés allant jusqu'à 100 sous-agents pour l'exécution parallèle d'outils. Lorsqu'elles sont acheminées via le système de compétences de MoltBot, ces fonctionnalités automatisent des flux de travail complexes directement à partir de messages de chat.
La flexibilité de MoltBot prend en charge tout point de terminaison compatible OpenAI. Changer de fournisseur ne nécessite que des mises à jour de configuration, ce qui permet aux utilisateurs d'expérimenter facilement.
Prérequis
Préparez ces éléments avant la configuration.
Installez MoltBot entièrement. Exécutez le script d'installation si ce n'est pas déjà fait :
curl -fsSL https://molt.bot/install.sh | bash
Le projet a été renommé de ClawdBot à MoltBot le 27 janvier 2026, suite à une demande de marque déposée d'Anthropic. Les anciennes installations peuvent conserver le répertoire ~/.clawdbot, mais les versions récentes utilisent les commandes moltbot et ~/.moltbot ou des chemins similaires. Consultez la documentation sur molt.bot ou le dépôt GitHub (github.com/moltbot/moltbot) pour votre configuration exacte.
Obtenez l'accès à Kimi K2.5 :
- Route API : Créez un compte sur platform.moonshot.ai, générez une clé API et notez les limites budgétaires du projet.
- Route locale : Téléchargez les poids quantifiés (par exemple, depuis Hugging Face moonshotai/Kimi-K2.5 ou des dépôts communautaires comme unsloth/Kimi-K2.5-GGUF). Installez llama.cpp et démarrez un serveur.
Installez Apidog pour les tests. Il gère efficacement les en-têtes d'authentification, les corps JSON et le streaming des réponses.
Assurez-vous que Node.js est exécuté pour MoltBot. Une familiarité de base avec le terminal aide à l'édition des fichiers JSON.
Méthode 1 : Connexion via l'API Moonshot (recommandée pour la plupart des utilisateurs)
Cette approche nécessite un matériel minimal et offre un contexte complet de 256K ainsi qu'un support multimodal.
Étape 1 : Valider la connexion API à l'aide d'Apidog
Lancez Apidog et créez une nouvelle requête POST.
Définissez l'URL sur :
https://api.moonshot.ai/v1/chat/completions
Ajoutez l'en-tête :
Authorization: Bearer sk-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
(Remplacez par votre clé réelle.)
Utilisez ce corps pour un test de base :
{
"model": "kimi-k2.5",
"messages": [
{
"role": "user",
"content": "Confirmez que vous êtes Kimi K2.5 et décrivez brièvement vos capacités."
}
],
"temperature": 0.7,
"max_tokens": 256
}
Envoyez la requête. Une réponse 200 réussie avec une sortie cohérente confirme que la clé fonctionne. Notez toute erreur de limitation de débit ou de budget ici.
Étape 2 : Localiser et modifier le fichier de configuration
MoltBot stocke les paramètres dans un fichier JSON, généralement :
~/.moltbot/moltbot.json- Ou héritage :
~/.clawdbot/moltbot.json/~/.clawdbot/agents/default/config.json
Ouvrez-le avec un éditeur.
Ajoutez ou modifiez la section des fournisseurs :
{
"agent": {
"model": {
"primary": "moonshot/kimi-k2.5"
}
},
"models": {
"providers": {
"moonshot": {
"baseUrl": "https://api.moonshot.ai/v1",
"apiKey": "sk-votre-cle-api-moonshot-ici",
"api": "openai-completions",
"models": [
{
"id": "kimi-k2.5",
"name": "Kimi K2.5 (API)",
"contextWindow": 262144,
"maxTokens": 8192
}
]
}
}
}
}
Note de sécurité : Évitez de coder en dur les clés en production. Définissez une variable d'environnement (par exemple, export MOONSHOT_API_KEY=sk-...) et référencez-la si MoltBot prend en charge l'expansion.
Étape 3 : Appliquer les changements et redémarrer
Enregistrez le fichier, puis redémarrez :
moltbot restart
Ou arrêtez et démarrez la passerelle/le service si nécessaire.
Méthode 2 : Connexion via un déploiement local de Kimi K2.5
L'exécution locale privilégie la confidentialité et élimine les coûts récurrents, bien qu'elle exige une VRAM/RAM substantielle.
Étape 1 : Lancer le serveur d'inférence local
Utilisez llama.cpp pour la compatibilité.
Construisez llama.cpp avec le support GPU si disponible :
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make LLAMA_CUDA=1 # ou les drapeaux appropriés
Téléchargez une variante GGUF quantifiée (par exemple, UD-TQ1_0 pour l'équilibre) :
Utilisez huggingface-cli ou le téléchargement direct.
Démarrez le serveur compatible OpenAI :
./llama-server \
-m /chemin/vers/Kimi-K2.5-UD-TQ1_0.gguf \
--port 8080 \
--ctx-size 32768 \ # Ajustez jusqu'à la limite matérielle ; 256K nécessite des ressources extrêmes
--n-gpu-layers 99 \
--host 0.0.0.0
Vérifiez en naviguant sur http://localhost:8080/v1/models.
Étape 2 : Mettre à jour la configuration de MoltBot pour le point de terminaison local
Modifiez le fichier JSON :
{
"agent": {
"model": {
"primary": "local-kimi/kimi-k2.5"
}
},
"models": {
"providers": {
"local-kimi": {
"baseUrl": "http://127.0.0.1:8080/v1",
"apiKey": "sk-aucune-cle-requise",
"api": "openai-completions",
"models": [
{
"id": "kimi-k2.5-local",
"name": "Kimi K2.5 Local",
"contextWindow": 32768, // Doit correspondre à --ctx-size
"maxTokens": 4096
}
]
}
}
}
}
Note Docker : Si MoltBot est exécuté dans un conteneur, remplacez 127.0.0.1 par host.docker.internal.
Étape 3 : Redémarrer et surveiller l'utilisation des ressources
Redémarrez MoltBot et surveillez les moniteurs système. L'inférence locale consomme beaucoup de mémoire ; déchargez les couches ou réduisez le contexte si nécessaire.
Test et vérification
Confirmez que l'intégration fonctionne.
Envoyez un message à votre instance MoltBot (via l'application connectée) :
"Par qui êtes-vous propulsé en ce moment ?"
Kimi K2.5 répond généralement en s'identifiant comme Moonshot AI.
Vérifiez les journaux :
moltbot logs
Recherchez les requêtes acheminées vers api.moonshot.ai ou localhost:8080.
Testez le multimodal si vous utilisez l'API : Téléchargez une image via le chat et demandez une description ou une génération de code à partir de celle-ci.
Dépannage des problèmes courants
La vérification du fournisseur échoue → Retestez l'exact baseUrl + clé dans Apidog. Les proxys réseau ou les pare-feu interfèrent souvent.
Erreurs de débordement de contexte → Alignez contextWindow dans JSON avec --ctx-size du serveur. MoltBot tronque ou résume lorsque les limites sont atteintes ; des valeurs incohérentes provoquent des plantages.
Réponses lentes localement → Réduisez les gpu-layers, utilisez une quantification inférieure ou activez l'attention flash dans llama.cpp.
Formatage inattendu/hallucinations → Expérimentez avec la température (0.6–1.0) ou ajoutez des invites système personnalisées dans la configuration de l'agent MoltBot pour un réglage spécifique à Kimi.
Épuisement du budget API → Surveillez l'utilisation sur platform.moonshot.ai et définissez des limites quotidiennes.
Conclusion
L'intégration de Kimi K2.5 avec MoltBot offre un agent IA personnel haute performance, économique et optionnellement entièrement privé. La méthode API offre commodité et capacités maximales, tandis que la configuration locale assure une souveraineté totale des données.
Expérimentez avec les deux approches. Utilisez Apidog tout au long du processus pour isoler rapidement les problèmes. Alors que Moonshot continue de mettre à jour les modèles Kimi et que MoltBot évolue, cette combinaison positionne les utilisateurs à l'avant-garde de l'IA agentive accessible.
Commencez la configuration dès maintenant—votre assistant amélioré vous attend.
