Building Advanced Chatbots with MindsDB: A Comprehensive Guide

from mindsdb import MindsDB

# Initialize MindsDB
mdb = MindsDB()

# Train the model using the reformatted data
mdb.train(
    name='chat_model',
    from_data='reformatted_chat_data.csv',
    to_predict='response'
)

from mindsdb import MindsDB
from textblob import TextBlob
import logging
import time
from collections import defaultdict

# Initialize MindsDB
mdb = MindsDB()
project = mdb.get_project('chat_model')

# Initialize logging
logging.basicConfig(level=logging.INFO, filename='bot.log', filemode='a',
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# Rate limiting configuration
rate_limit_window = 60  # 1 minute
rate_limit_max_requests = 5
user_request_log = defaultdict(list)

def analyze_sentiment(text):
    analysis = TextBlob(text)
    return analysis.sentiment.polarity

def get_response(input_text):
    prediction = project.predict(when={'input': input_text})
    return prediction['response']

def get_response_with_sentiment(input_text):
    sentiment = analyze_sentiment(input_text)
    response = get_response(input_text)

    if sentiment < 0:
        response = "It seems like you're having a tough time. " + response
    elif sentiment > 0:
        response = "I'm glad to hear that! " + response

    return response

def safe_get_response(input_text):
    try:
        response = get_response_with_sentiment(input_text)
    except Exception as e:
        response = "Sorry, I encountered an error while processing your message."
        logging.error(f"Error: {e}")
    return response

def log_interaction(platform, user, message, response):
    logging.info(f"Platform: {platform}, User: {user}, Message: {message}, Response: {response}")

def rate_limited(user):
    current_time = time.time()
    request_times = user_request_log[user]

    # Remove requests that are outside the rate limit window
    user_request_log[user] = [t for t in request_times if current_time - t < rate_limit_window]

    if len(user_request_log[user]) >= rate_limit_max_requests:
        return True
    else:
        user_request_log[user].append(current_time)
        return False

def handle_command(command, user):
    if command == "/help":
        return "Here are the commands you can use: ..."
    elif command == "/info":
        return "This bot helps you with ..."
    else:
        return "Unknown command. Type /help for the list of commands."

def process_message(message):
    if message.startswith("/"):
        command = message.split()[0]
        return handle_command(command)
    else:
        return safe_get_response(message)

import os
from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
from config import SLACK_BOT_TOKEN, SLACK_APP_TOKEN
from bot_logic import process_message, log_interaction, rate_limited

app = App(token=SLACK_BOT_TOKEN)

@app.message("")
def handle_message_events(message, say):
    user = message['user']
    user_message = message['text']

    if rate_limited(user):
        say("You are sending messages too quickly. Please wait a while before trying again.")
        return

    response = process_message(user_message)
    log_interaction('Slack', user, user_message, response)
    say(response)

def start_slack_bot():
    handler = SocketModeHandler(app, SLACK_APP_TOKEN)
    handler.start()

import os
import tweepy
from config import TWITTER_API_KEY, TWITTER_API_SECRET_KEY, TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_TOKEN_SECRET
from bot_logic import process_message, log_interaction, rate_limited

auth = tweepy.OAuthHandler(TWITTER_API_KEY, TWITTER_API_SECRET_KEY)
auth.set_access_token(TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_TOKEN_SECRET)
api = tweepy.API(auth)

class MyStreamListener(tweepy.StreamListener):
    def on_status(self, status):
        user = status.user.screen_name
        user_message = status.text

        if rate_limited(user):
            return

        response = process_message(user_message)
        log_interaction('Twitter', user, user_message, response)
        api.update_status(f"@{user} {response}", in_reply_to_status_id=status.id)

def start_twitter_bot():
    myStreamListener = MyStreamListener()
    myStream = tweepy.Stream(auth=api.auth, listener=myStreamListener)
    myStream.filter(track=['@YourTwitterBotHandle'])

import os
import discord
from config import DISCORD_TOKEN
from bot_logic import process_message, log_interaction, rate_limited

client = discord.Client()

@client.event
async def on_message(message):
    if message.author == client.user:
        return

    user = str(message.author)
    user_message = message.content

    if rate_limited(user):
        await message.channel.send("You are sending messages too quickly. Please wait a while before trying again.")
        return

    response = process_message(user_message)
    log_interaction('Discord', user, user_message, response)
    await message.channel.send(response)

def start_discord_bot():
    client.run(DISCORD_TOKEN)

from multiprocessing import Process
from slack_bot import start_slack_bot
from twitter_bot import start_twitter_bot
from discord_bot import start_discord_bot

if __name__ == "__main__":
    slack_process = Process(target=start_slack_bot)
    twitter_process = Process(target=start_twitter_bot)
    discord_process = Process(target=start_discord_bot)

    slack_process.start()
    twitter_process.start()
    discord_process.start()

    slack_process.join()
    twitter_process.join()
    discord_process.join()

mindsdb
slack-bolt
tweepy
discord.py
textblob
python-dotenv

pip install -r requirements.txt

SLACK_BOT_TOKEN=your_slack_bot_token
SLACK_APP_TOKEN=your_slack_app_token
TWITTER_API_KEY=your_twitter_api_key
TWITTER_API_SECRET_KEY=your_twitter_api_secret_key
TWITTER_ACCESS_TOKEN=your_twitter_access_token
TWITTER_ACCESS_TOKEN_SECRET=your_twitter_access_token_secret
DISCORD_TOKEN=your_discord_bot_token

python main.py