Building an Advanced AI-Powered Trivia Bot for Discord: A Step-by-Step Guide

DISCORD_TOKEN = your_discord_bot_token_here
GOOGLE_API_KEY = your_google_studio_API_key_here

pip install discord.py google-generativeai PyPDF2 requests beautifulsoup4 python-dotenv

# Import required libraries
import os
import discord
from discord.ext import commands
import google.generativeai as genai
import PyPDF2
import requests
from bs4 import BeautifulSoup
from dotenv import load_dotenv
import asyncio

# Load environment variables
load_dotenv()

# Configure Gemini
genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))
model = genai.GenerativeModel('gemini-pro')

class KnowledgeBase:
    def __init__(self):
        self.content = []

    async def add_text(self, text):
        """Add raw text to knowledge base"""
        self.content.append({"type": "text", "content": text})

    async def add_website(self, url):
        """Scrape and add website content"""
        try:
            response = requests.get(url)
            soup = BeautifulSoup(response.text, 'html.parser')
            # Extract text content from paragraphs
            text = ' '.join([p.text for p in soup.find_all('p')])
            self.content.append({"type": "website", "content": text, "source": url})
            return True
        except Exception as e:
            print(f"Error processing website: {e}")
            return False

    async def add_pdf(self, file_path):
        """Extract and add PDF content"""
        try:
            with open(file_path, 'rb') as file:
                reader = PyPDF2.PdfReader(file)
                text = ''
                for page in reader.pages:
                    text += page.extract_text()
                self.content.append({"type": "pdf", "content": text, "source": file_path})
            return True
        except Exception as e:
            print(f"Error processing PDF: {e}")
            return False

    async def get_content(self):
        """Get all content"""
        return self.content

    async def update_content(self, index, new_content):
        """Update content at a specific index"""
        if index < len(self.content):
            self.content[index]["content"] = new_content
            return True
        else:
            return False

    async def delete_content(self, index):
        """Delete content at a specific index"""
        if index < len(self.content):
            del self.content[index]
            return True
        else:
            return False

    def get_combined_content(self):
        """Get all content combined"""
        return ' '.join([item['content'] for item in self.content])

class TriviaBot(commands.Bot):
    def __init__(self):
        intents = discord.Intents.default()
        intents.message_content = True
        super().__init__(command_prefix='!', intents=intents)
        self.knowledge_base = KnowledgeBase()
        self.current_questions = {}
        self.scores = {}

    async def generate_question(self, context):
        """Generate a question using Gemini based on knowledge base"""
        try:
            prompt = f"""
            Based on the following content, generate a trivia question with 4 multiple choice options (A, B, C, D) and indicate the correct answer. Always respond with the same format, as spacing and new line matters.
            Format: Question
            A) 
            B)
            C)
            D)
            Correct Answer: X being either A or B or C or D

            Content: {self.knowledge_base.get_combined_content()[:10000]}  # Limit content length
            """
            
            response = model.generate_content(prompt)
            response_text = response.text
            
            # Parse response to extract question, options, and answer
            lines = response_text.strip().split('\n')
            question = lines[0]
            options = lines[1:5]
            correct_answer = lines[-1].split()[-1]
            
            return {
                'question': question,
                'options': options,
                'correct_answer': correct_answer
            }
        except Exception as e:
            print(f"Error generating question: {e}")
            return None

# Set up bot commands
def setup_bot():
    bot = TriviaBot()

    @bot.event
    async def on_ready():
        print(f'{bot.user} has connected to Discord!')

    @bot.command(name='addtext')
    async def add_text(ctx, *, text):
        """Add text to knowledge base"""
        await bot.knowledge_base.add_text(text)
        await ctx.send("Text added to knowledge base!")

    @bot.command(name='addwebsite')
    async def add_website(ctx, url):
        """Add website content to knowledge base"""
        success = await bot.knowledge_base.add_website(url)
        if success:
            await ctx.send("Website content added to knowledge base!")
        else:
            await ctx.send("Error processing website!")

    @bot.command(name='addpdf')
    async def add_pdf(ctx):
        """Add PDF content to knowledge base"""
        if len(ctx.message.attachments) == 0:
            await ctx.send("Please attach a PDF file!")
            return

        attachment = ctx.message.attachments[0]
        if not attachment.filename.endswith('.pdf'):
            await ctx.send("Please attach a PDF file!")
            return

        # Download and save PDF temporarily
        await attachment.save(attachment.filename)
        success = await bot.knowledge_base.add_pdf(attachment.filename)
        os.remove(attachment.filename)  # Clean up

        if success:
            await ctx.send("PDF content added to knowledge base!")
        else:
            await ctx.send("Error processing PDF!")

    @bot.command(name='view')
    async def view_knowledge_base(ctx):
        """View the current knowledge base content"""
        content = await bot.knowledge_base.get_content()
        if not content:
            await ctx.send("Knowledge base is empty.")
            return

        response = "Current Knowledge Base:\n\n"
        for i, item in enumerate(content):
            response += f"{i}. {item['type']}: {item['content'][:100]}{'...' if len(item['content']) > 100 else ''}\n"
        await ctx.send(response)

    @bot.command(name='update')
    async def update_knowledge_base(ctx, index: int, *, new_content):
        """Update content in the knowledge base"""
        success = await bot.knowledge_base.update_content(index, new_content)
        if success:
            await ctx.send("Knowledge base content updated.")
        else:
            await ctx.send("Invalid index. Unable to update content.")

    @bot.command(name='delete')
    async def delete_knowledge_base(ctx, index: int):
        """Delete content from the knowledge base"""
        success = await bot.knowledge_base.delete_content(index)
        if success:
            await ctx.send("Knowledge base content deleted.")
        else:
            await ctx.send("Invalid index. Unable to delete content.")

    @bot.command(name='trivia')
    async def trivia(ctx):
        """Start a trivia question"""
        if not bot.knowledge_base.content:
            await ctx.send("No content in knowledge base! Add some content first.")
            return

        question_data = await bot.generate_question(ctx)
        if not question_data:
            await ctx.send("Error generating question!")
            return

        # Format and send question
        question_msg = f"**{question_data['question']}**\n\n"
        for i, option in enumerate(question_data['options']):
            question_msg += f"{option}\n"

        await ctx.send(question_msg)
        bot.current_questions[ctx.channel.id] = question_data

        # Wait for answer
        def check(m):
            return m.channel == ctx.channel and m.content.upper() in ['A', 'B', 'C', 'D']

        try:
            answer = await bot.wait_for('message', timeout=30.0, check=check)
            if answer.content.upper() == question_data['correct_answer']:
                # Update score
                if answer.author.id not in bot.scores:
                    bot.scores[answer.author.id] = 0
                bot.scores[answer.author.id] += 1
                
                await ctx.send(f"🎉 Correct, {answer.author.mention}! Your score: {bot.scores[answer.author.id]}")
            else:
                await ctx.send(f"❌ Wrong! The correct answer was {question_data['correct_answer']}")
        except asyncio.TimeoutError:
            await ctx.send(f"Time's up! The correct answer was {question_data['correct_answer']}")

        del bot.current_questions[ctx.channel.id]

    @bot.command(name='score')
    async def score(ctx):
        """Check your score"""
        score = bot.scores.get(ctx.author.id, 0)
        await ctx.send(f"{ctx.author.mention}, your score is: {score}")

    return bot

# Main execution
def main():
    # Create and set up bot
    bot = setup_bot()
    
    # Run bot
    bot.run(os.getenv('DISCORD_TOKEN'))

if __name__ == "__main__":
    main()