チャットボットフレームワーク 2026 — Slack Bolt / discord.js / Discord.py(復活)/ JDA / py-cord / Telegram / LINE / KakaoTalk 徹底ガイド

import { App } from '@slack/bolt';

const app = new App({
  token: process.env.SLACK_BOT_TOKEN,
  signingSecret: process.env.SLACK_SIGNING_SECRET,
  socketMode: true,
  appToken: process.env.SLACK_APP_TOKEN,
});

// スラッシュコマンド
app.command('/hello', async ({ command, ack, respond }) => {
  await ack();
  await respond(`こんにちは、<@${command.user_id}>さん!`);
});

// メッセージイベント
app.message('ヘルプ', async ({ message, say }) => {
  await say('何かお手伝いできますか?');
});

// インタラクティブボタン
app.action('button_click', async ({ ack, body, respond }) => {
  await ack();
  await respond('ボタンが押されました');
});

(async () => {
  await app.start();
  console.log('Bolt アプリ起動中');
})();

from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
import os

app = App(token=os.environ["SLACK_BOT_TOKEN"])

@app.command("/hello")
def handle_hello(ack, respond, command):
    ack()
    respond(f"こんにちは、<@{command['user_id']}>さん!")

@app.message("ヘルプ")
def handle_help(message, say):
    say("何かお手伝いできますか?")

@app.action("button_click")
def handle_button(ack, respond):
    ack()
    respond("ボタンが押されました")

if __name__ == "__main__":
    SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"]).start()

import com.slack.api.bolt.App;
import com.slack.api.bolt.AppConfig;

public class SlackBotApp {
  public static void main(String[] args) {
    var config = new AppConfig();
    config.setSigningSecret(System.getenv("SLACK_SIGNING_SECRET"));
    config.setSingleTeamBotToken(System.getenv("SLACK_BOT_TOKEN"));
    var app = new App(config);

    app.command("/hello", (req, ctx) -> {
      return ctx.ack("こんにちは、" + req.getPayload().getUserName() + "さん!");
    });

    var server = new com.slack.api.bolt.jetty.SlackAppServer(app);
    try { server.start(); } catch (Exception e) { e.printStackTrace(); }
  }
}

import { Client, GatewayIntentBits, SlashCommandBuilder } from 'discord.js';

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
  ],
});

client.once('ready', () => {
  console.log(`ログイン完了: ${client.user?.tag}`);
});

// スラッシュコマンドを登録
const ping = new SlashCommandBuilder()
  .setName('ping')
  .setDescription('レイテンシ測定');

client.on('interactionCreate', async (interaction) => {
  if (!interaction.isChatInputCommand()) return;
  if (interaction.commandName === 'ping') {
    const ms = Date.now() - interaction.createdTimestamp;
    await interaction.reply(`Pong (${ms}ms)`);
  }
});

client.login(process.env.DISCORD_TOKEN);

import { ShardingManager } from 'discord.js';

const manager = new ShardingManager('./bot.js', {
  totalShards: 'auto',
  token: process.env.DISCORD_TOKEN,
});

manager.on('shardCreate', (shard) => console.log(`シャード ${shard.id} 起動`));
manager.spawn();

import discord
from discord import app_commands
from discord.ext import commands

intents = discord.Intents.default()
intents.message_content = True

bot = commands.Bot(command_prefix='!', intents=intents)

@bot.event
async def on_ready():
    print(f'ログイン完了: {bot.user}')
    await bot.tree.sync()

@bot.tree.command(name='ping', description='レイテンシ測定')
async def ping(interaction: discord.Interaction):
    latency = round(bot.latency * 1000)
    await interaction.response.send_message(f'Pong ({latency}ms)')

bot.run('YOUR_TOKEN')

from discord.ext import commands
from discord import app_commands
import discord

class Moderation(commands.Cog):
    def __init__(self, bot):
        self.bot = bot

    @app_commands.command(name='kick', description='ユーザーを追放')
    async def kick(self, interaction: discord.Interaction, member: discord.Member):
        await member.kick()
        await interaction.response.send_message(f'{member} を追放しました')

async def setup(bot):
    await bot.add_cog(Moderation(bot))

import discord
from discord.ext import commands

bot = commands.Bot()

@bot.slash_command(name='ping', description='レイテンシ')
async def ping(ctx: discord.ApplicationContext):
    await ctx.respond(f'Pong ({round(bot.latency * 1000)}ms)')

bot.run('TOKEN')

import nextcord
from nextcord.ext import commands

bot = commands.Bot(command_prefix='!')

@bot.slash_command(description='レイテンシ')
async def ping(interaction: nextcord.Interaction):
    await interaction.send(f'Pong')

bot.run('TOKEN')

import net.dv8tion.jda.api.JDABuilder;
import net.dv8tion.jda.api.events.session.ReadyEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import net.dv8tion.jda.api.requests.GatewayIntent;

public class Bot extends ListenerAdapter {
  public static void main(String[] args) throws Exception {
    JDABuilder.createDefault(System.getenv("DISCORD_TOKEN"))
        .enableIntents(GatewayIntent.MESSAGE_CONTENT)
        .addEventListeners(new Bot())
        .build();
  }

  @Override
  public void onReady(ReadyEvent event) {
    System.out.println("ログイン: " + event.getJDA().getSelfUser().getAsTag());
  }
}

import discord4j.core.DiscordClient;
import discord4j.core.event.domain.message.MessageCreateEvent;

public class Bot {
  public static void main(String[] args) {
    var client = DiscordClient.create(System.getenv("DISCORD_TOKEN"))
        .login()
        .block();

    client.on(MessageCreateEvent.class, event -> {
      var message = event.getMessage();
      if (message.getContent().equals("!ping")) {
        return message.getChannel()
            .flatMap(channel -> channel.createMessage("Pong"));
      }
      return reactor.core.publisher.Mono.empty();
    }).blockLast();
  }
}

use serenity::async_trait;
use serenity::model::channel::Message;
use serenity::prelude::*;

struct Handler;

#[async_trait]
impl EventHandler for Handler {
    async fn message(&self, ctx: Context, msg: Message) {
        if msg.content == "!ping" {
            if let Err(why) = msg.channel_id.say(&ctx.http, "Pong").await {
                println!("送信失敗: {:?}", why);
            }
        }
    }
}

#[tokio::main]
async fn main() {
    let token = std::env::var("DISCORD_TOKEN").expect("トークンなし");
    let intents = GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT;
    let mut client = Client::builder(&token, intents)
        .event_handler(Handler)
        .await
        .expect("クライアント生成失敗");

    if let Err(why) = client.start().await {
        println!("実行エラー: {:?}", why);
    }
}

using Discord;
using Discord.WebSocket;

var client = new DiscordSocketClient(new DiscordSocketConfig {
    GatewayIntents = GatewayIntents.AllUnprivileged | GatewayIntents.MessageContent
});

client.Log += msg => { Console.WriteLine(msg.ToString()); return Task.CompletedTask; };

client.MessageReceived += async msg => {
    if (msg.Content == "!ping") await msg.Channel.SendMessageAsync("Pong");
};

await client.LoginAsync(TokenType.Bot, Environment.GetEnvironmentVariable("DISCORD_TOKEN"));
await client.StartAsync();
await Task.Delay(-1);

const Eris = require('eris');
const bot = new Eris(process.env.DISCORD_TOKEN, {
  intents: ['guilds', 'guildMessages', 'messageContent'],
});

bot.on('ready', () => console.log('準備完了'));
bot.on('messageCreate', (msg) => {
  if (msg.content === '!ping') bot.createMessage(msg.channel.id, 'Pong');
});
bot.connect();

from nio import AsyncClient, MatrixRoom, RoomMessageText

async def message_callback(room: MatrixRoom, event: RoomMessageText):
    if event.body == "!ping":
        await client.room_send(
            room_id=room.room_id,
            message_type="m.room.message",
            content={"msgtype": "m.text", "body": "Pong"},
        )

client = AsyncClient("https://matrix.example.org", "@bot:example.org")
client.add_event_callback(message_callback, RoomMessageText)

import { MatrixClient, SimpleFsStorageProvider } from 'matrix-bot-sdk';

const client = new MatrixClient(
  'https://matrix.example.org',
  process.env.MATRIX_TOKEN!,
  new SimpleFsStorageProvider('bot.json'),
);

client.on('room.message', async (roomId, event) => {
  if (!event.content || event.sender === (await client.getUserId())) return;
  if (event.content.body === '!ping') {
    await client.sendMessage(roomId, { msgtype: 'm.text', body: 'Pong' });
  }
});

client.start();

from mattermostdriver import Driver

driver = Driver({
    'url': 'mattermost.example.com',
    'token': 'BOT_TOKEN',
    'scheme': 'https',
    'port': 443,
})
driver.login()

# メッセージ送信
driver.posts.create_post({
    'channel_id': 'CHANNEL_ID',
    'message': 'こんにちは',
})

const { RocketChatApp } = require('@rocket.chat/apps-engine/definition/RocketChatApp');

class HelloApp extends RocketChatApp {
  async executeSlashCommand(context, read, modify) {
    const sender = context.getSender();
    const room = context.getRoom();
    const builder = modify.getCreator().startMessage()
      .setSender(sender)
      .setRoom(room)
      .setText('こんにちは!');
    await modify.getCreator().finish(builder);
  }
}

from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text('こんにちは!')

app = Application.builder().token('YOUR_TOKEN').build()
app.add_handler(CommandHandler('start', start))
app.run_polling()

import { Telegraf } from 'telegraf';

const bot = new Telegraf(process.env.TELEGRAM_TOKEN!);
bot.start((ctx) => ctx.reply('こんにちは!'));
bot.command('ping', (ctx) => ctx.reply('Pong'));
bot.launch();

from aiogram import Bot, Dispatcher, types
from aiogram.filters import Command
import asyncio

bot = Bot(token='YOUR_TOKEN')
dp = Dispatcher()

@dp.message(Command('start'))
async def handle_start(message: types.Message):
    await message.answer('こんにちは!')

async def main():
    await dp.start_polling(bot)

asyncio.run(main())

curl -X POST "https://graph.facebook.com/v18.0/PHONE_NUMBER_ID/messages" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "messaging_product": "whatsapp",
    "to": "819012345678",
    "type": "text",
    "text": {"body": "こんにちは"}
  }'

curl -X POST "https://graph.facebook.com/v18.0/PHONE_NUMBER_ID/messages" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "messaging_product": "whatsapp",
    "to": "819012345678",
    "type": "template",
    "template": {
      "name": "order_confirmation",
      "language": {"code": "ja"}
    }
  }'

import { Client, middleware } from '@line/bot-sdk';
import express from 'express';

const config = {
  channelAccessToken: process.env.LINE_ACCESS_TOKEN!,
  channelSecret: process.env.LINE_CHANNEL_SECRET!,
};

const client = new Client(config);
const app = express();

app.post('/webhook', middleware(config), async (req, res) => {
  const events = req.body.events;
  for (const event of events) {
    if (event.type === 'message' && event.message.type === 'text') {
      await client.replyMessage(event.replyToken, {
        type: 'text',
        text: `エコー: ${event.message.text}`,
      });
    }
  }
  res.sendStatus(200);
});

app.listen(3000);

from linebot import LineBotApi, WebhookHandler
from linebot.models import MessageEvent, TextMessage, TextSendMessage
from flask import Flask, request

app = Flask(__name__)
line_bot_api = LineBotApi('YOUR_ACCESS_TOKEN')
handler = WebhookHandler('YOUR_CHANNEL_SECRET')

@app.route('/webhook', methods=['POST'])
def webhook():
    signature = request.headers['X-Line-Signature']
    body = request.get_data(as_text=True)
    handler.handle(body, signature)
    return 'OK'

@handler.add(MessageEvent, message=TextMessage)
def handle_message(event):
    line_bot_api.reply_message(
        event.reply_token,
        TextSendMessage(text=f'エコー: {event.message.text}')
    )

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/skill/order-status', methods=['POST'])
def order_status():
    data = request.json
    user_id = data['userRequest']['user']['id']
    utterance = data['userRequest']['utterance']

    # 実際には DB 参照
    status = '配送中'

    response = {
        'version': '2.0',
        'template': {
            'outputs': [{
                'simpleText': {
                    'text': f'注文状態: {status}'
                }
            }]
        }
    }
    return jsonify(response)

if __name__ == '__main__':
    app.run(port=5000)