Slack bot IA avec l'API Claude : guide Node.js et Bolt

Un Slack bot IA d’équipe, c’est un assistant disponible 24h/24, capable de répondre aux questions techniques, analyser des tickets Jira, expliquer du code, rédiger de la documentation ou faire de la veille technologique — directement dans les canaux où votre équipe travaille déjà. Ce guide montre comment le construire avec l’API Claude d’Anthropic et Slack Bolt.

Cas d’usage concrets

Avant de coder, identifiez les problèmes récurrents dans votre équipe :

Besoin	Ce que le bot peut faire
Questions techniques répétitives	Répondre à “comment fonctionne notre pipeline CI ?” avec le contexte de votre doc interne
Revue de code légère	Analyser un extrait de code posté dans Slack et suggérer des améliorations
Tickets ambigtüs	Reformuler un ticket Jira en critères d’acceptance clairs
Documentation absente	Générer la doc d’une API depuis sa signature
Onboarding	Guider les nouveaux arrivants sur les outils et processus internes
Veille tech	Résumer un article ou comparer deux approches techniques

Architecture du bot

Slack workspace
    │
    │ Event (message, mention, commande)
    ▼
Slack API (Bolt SDK)
    │
    │ Texte + contexte de la conversation
    ▼
Votre serveur Node.js
    │
    │ Prompt enrichi (contexte équipe + historique)
    ▼
API Claude (Anthropic)
    │
    │ Réponse générée
    ▼
Slack (réponse dans le thread)

Chaque message envoyé en mention @MonBot ou dans un canal dédié déclenche un appel à l’API Claude avec un prompt construit dynamiquement.

Prérequis

• Compte Slack avec droits d’administration sur le workspace
• API Key Anthropic — console.anthropic.com
• Node.js 20+ sur le serveur ou en local pour les tests
• Une URL publique (ou ngrok en développement) pour les webhooks Slack

1. Créer l’app Slack

1. Allez sur api.slack.com/apps → Create New App → From scratch
2. Donnez un nom (ex : AssistantIA) et choisissez votre workspace
3. Dans OAuth & Permissions → Bot Token Scopes, ajoutez :
   • app_mentions:read — pour écouter les mentions
   • channels:history — pour lire l’historique du canal
   • chat:write — pour répondre
   • im:history et im:write — pour les messages privés (optionnel)
4. Install to Workspace → copiez le Bot User OAuth Token (commence par xoxb-)
5. Dans Socket Mode → activez et copiez le App Token (commence par xapp-)

2. Initialiser le projet Node.js

mkdir slack-bot-ia && cd slack-bot-ia
npm init -y
npm install @slack/bolt @anthropic-ai/sdk dotenv

Créez .env :

SLACK_BOT_TOKEN=xoxb-votre-token
SLACK_APP_TOKEN=xapp-votre-token
ANTHROPIC_API_KEY=sk-ant-votre-cle

3. Code du bot

// index.js
import { App } from "@slack/bolt";
import Anthropic from "@anthropic-ai/sdk";
import "dotenv/config";

const app = new App({
  token: process.env.SLACK_BOT_TOKEN,
  appToken: process.env.SLACK_APP_TOKEN,
  socketMode: true, // WebSocket — pas besoin d'URL publique en dev
});

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

// Contexte de votre équipe — personnalisez cette section
const SYSTEM_PROMPT = `Tu es l'assistant IA de l'équipe technique. Tu aides les développeurs sur :
- Les questions sur nos technologies : AEM, Java Spring Boot, React, Docker, Jenkins
- La revue de code et suggestions d'amélioration
- La rédaction de documentation technique
- L'analyse et reformulation de tickets
- Les questions de bonnes pratiques et architecture

Tu réponds en français, de façon concise et opérationnelle. 
Quand tu ne sais pas, tu le dis clairement plutôt que d'inventer.
Pour du code, utilise des blocs de code formatés.`;

// Historique par conversation (en mémoire — perdre au redémarrage)
// En production : Redis ou base de données
const conversationHistory = new Map();

// Écoute les mentions @NomDuBot
app.event("app_mention", async ({ event, say }) => {
  const userMessage = event.text.replace(/<@[A-Z0-9]+>/g, "").trim();
  const threadTs = event.thread_ts || event.ts;
  const historyKey = `${event.channel}-${threadTs}`;

  // Récupérer ou initialiser l'historique de ce thread
  if (!conversationHistory.has(historyKey)) {
    conversationHistory.set(historyKey, []);
  }
  const history = conversationHistory.get(historyKey);

  // Ajouter le message de l'utilisateur à l'historique
  history.push({ role: "user", content: userMessage });

  // Indicateur "en train de répondre..."
  await say({
    text: "⏳ Je réfléchis...",
    thread_ts: threadTs,
  });

  try {
    const response = await anthropic.messages.create({
      model: "claude-opus-4-8",
      max_tokens: 1500,
      system: SYSTEM_PROMPT,
      messages: history, // historique complet du thread
    });

    const assistantMessage = response.content[0].text;

    // Ajouter la réponse à l'historique
    history.push({ role: "assistant", content: assistantMessage });

    // Limiter l'historique à 20 messages pour éviter de dépasser les limites de tokens
    if (history.length > 20) {
      conversationHistory.set(historyKey, history.slice(-20));
    }

    await say({
      text: assistantMessage,
      thread_ts: threadTs,
    });
  } catch (error) {
    console.error("Erreur API Claude :", error);
    await say({
      text: "❌ Une erreur s'est produite. Réessayez dans quelques instants.",
      thread_ts: threadTs,
    });
  }
});

// Commande slash /ask pour une question rapide sans mention
app.command("/ask", async ({ command, ack, respond }) => {
  await ack();

  const response = await anthropic.messages.create({
    model: "claude-opus-4-8",
    max_tokens: 1000,
    system: SYSTEM_PROMPT,
    messages: [{ role: "user", content: command.text }],
  });

  await respond({
    text: response.content[0].text,
    response_type: "in_channel", // visible par tous — "ephemeral" pour privé
  });
});

(async () => {
  await app.start();
  console.log("⚡ Bot IA démarré en Socket Mode");
})();

4. Enrichir le contexte avec vos données internes

La puissance d’un bot d’équipe vient de sa connaissance de votre contexte. Plusieurs approches :

Contexte statique dans le system prompt

const SYSTEM_PROMPT = `...
Notre stack technique :
- Backend : Java 17 + Spring Boot 3.x + AEM 6.5
- Frontend : React 18 + Angular 17
- Infra : Jenkins + Docker + Kubernetes (GKE)
- Repos : GitLab (gitlab.monentreprise.com)
- Gestion tickets : Jira (monentreprise.atlassian.net)

Conventions de nommage :
- Branches : feature/TICKET-123-description
- Commits : "feat(scope): description" (Conventional Commits)
...`;

RAG — récupérer la doc à la demande

import { readFileSync, readdirSync } from "fs";

function searchDocs(query) {
  // Simplification — en production : embeddings + recherche vectorielle
  const docs = readdirSync("./docs").filter(f => f.endsWith(".md"));
  const relevant = docs
    .map(f => ({ file: f, content: readFileSync(`./docs/${f}`, "utf-8") }))
    .filter(d => d.content.toLowerCase().includes(query.toLowerCase()))
    .slice(0, 2);
  
  return relevant.map(d => `## ${d.file}\n${d.content.slice(0, 1000)}`).join("\n\n");
}

// Dans le handler :
const docsContext = searchDocs(userMessage);
const enrichedSystem = SYSTEM_PROMPT + (docsContext ? `\n\nDocumentation pertinente:\n${docsContext}` : "");

5. Déploiement

Option A — Serveur VPS (recommandé)

# Sur le serveur
npm install -g pm2
pm2 start index.js --name slack-bot
pm2 save && pm2 startup

# Mises à jour sans downtime
pm2 reload slack-bot

Option B — Docker

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
CMD ["node", "index.js"]

docker build -t slack-bot-ia .
docker run -d --env-file .env --restart always --name slack-bot slack-bot-ia

Option C — Serverless (AWS Lambda + API Gateway)

Pour les faibles volumes, le mode WebSocket ne fonctionne pas en serverless. Utilisez le mode HTTP Slack et configurez l’URL de votre Lambda comme Request URL dans les paramètres Slack.

6. Fonctionnalités avancées

Analyse de code avec formatage Slack

app.event("app_mention", async ({ event, say }) => {
  const hasCode = event.text.includes("```");
  
  const system = hasCode 
    ? SYSTEM_PROMPT + "\nL'utilisateur a partagé du code. Fais une revue technique : bugs potentiels, performances, lisibilité, bonnes pratiques."
    : SYSTEM_PROMPT;

  // ... appel Claude avec le system enrichi
});

Résumé de thread

app.command("/resume", async ({ command, ack, respond, client }) => {
  await ack();
  
  // Récupérer les messages du thread ou canal
  const result = await client.conversations.history({
    channel: command.channel_id,
    limit: 20,
  });
  
  const messages = result.messages
    .reverse()
    .map(m => m.text)
    .join("\n");

  const response = await anthropic.messages.create({
    model: "claude-opus-4-8",
    max_tokens: 500,
    messages: [{ 
      role: "user", 
      content: `Résume ces échanges en 5 points max :\n\n${messages}` 
    }],
  });

  await respond({ text: response.content[0].text });
});

Quel modèle Claude choisir ?

Modèle	Cas d’usage	Coût
claude-haiku-4-5	Questions simples, réponses rapides, fort volume	Le moins cher
claude-sonnet-4-6	Questions techniques, revue de code, analyse	Équilibré
claude-opus-4-8	Raisonnement complexe, architecture, décisions	Le plus capable

Pour un bot d’équipe, claude-sonnet-4-6 est le meilleur compromis qualité/coût. Réservez claude-opus-4-8 pour les commandes explicitement dédiées à des analyses profondes.

Sécurité et bonnes pratiques

• Ne jamais logger les messages des utilisateurs en clair — RGPD
• Valider l’origine des requêtes Slack avec le Signing Secret
• Rate limiting — 10 requêtes/minute par utilisateur pour éviter les abus
• Pas de données sensibles dans le system prompt (mots de passe, clés API)
• Historique éphémère — ne pas stocker les conversations indéfiniment

// Validation de la signature Slack (automatique avec Bolt)
// Mais explicitement si vous gérez le HTTP vous-même :
import { verifyRequestSignature } from "@slack/events-api";

verifyRequestSignature({
  signingSecret: process.env.SLACK_SIGNING_SECRET,
  requestSignature: req.headers["x-slack-signature"],
  requestTimestamp: req.headers["x-slack-request-timestamp"],
  body: rawBody,
});

Coût estimé

Pour une équipe de 10 développeurs posant ~50 questions/jour :

• Tokens moyens par échange : 500 input + 300 output
• claude-sonnet-4-6 : ~$0.003/échange
• Budget mensuel : ~4-5 $/mois

Très largement rentabilisé par le temps économisé sur les questions répétitives.

Conclusion

Un Slack bot IA d’équipe se déploie en quelques heures avec Bolt et l’API Claude. La valeur réelle vient de la personnalisation : enrichir le contexte système avec vos conventions, votre stack et votre documentation interne transforme un chatbot générique en véritable expert de votre projet. Commencez simple (une commande, un canal dédié), mesurez l’usage, et ajoutez des fonctionnalités selon les retours de votre équipe.