mkdir discord-chatbot
cd discord-chatbot
go mod init discord-chatbot

go get github.com/bwmarrin/discordgo
go get google.golang.org/genai
go get github.com/joho/godotenv

package main

import (
	"context"
	"fmt"
	"sync"

	"google.golang.org/genai"
)

// GeminiClient wraps the Google GenAI client and manages conversation history
type GeminiClient struct {
	client   *genai.Client
	sessions map[string][]*genai.Content // Key: Channel ID, Value: Conversation History
	mu       sync.Mutex                  // Mutex to protect map from concurrent access
}

func NewGeminiClient(apiKey string) (*GeminiClient, error) {
	ctx := context.Background()
	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		APIKey: apiKey,
	})
	if err != nil {
		return nil, fmt.Errorf("failed to create genai client: %w", err)
	}

	return &GeminiClient{
		client:   client,
		sessions: make(map[string][]*genai.Content),
	}, nil
}

// Chat sends a message to Gemini and maintains conversation history
func (gc *GeminiClient) Chat(channelID, userMessage string) (string, error) {
	gc.mu.Lock()
	defer gc.mu.Unlock()

	// Initialize history for the channel if it doesn't exist
	if _, ok := gc.sessions[channelID]; !ok {
		gc.sessions[channelID] = []*genai.Content{}
	}

	// Append user message to history
	gc.sessions[channelID] = append(gc.sessions[channelID], &genai.Content{
		Role: "user",
		Parts: []*genai.Part{
			{Text: userMessage},
		},
	})

	// Optimization: Keep only the last 20 messages to prevent Token limit issues or excessive resource usage
	const maxHistory = 20
	if len(gc.sessions[channelID]) > maxHistory {
		gc.sessions[channelID] = gc.sessions[channelID][len(gc.sessions[channelID])-maxHistory:]
	}

	// Specify the Gemini model
	model := "gemini-2.5-flash"

	// Call Gemini API
	resp, err := gc.client.Models.GenerateContent(context.Background(), model, gc.sessions[channelID], nil)
	if err != nil {
		return "", fmt.Errorf("failed to generate content: %w", err)
	}

	// Parse the response
	if len(resp.Candidates) == 0 || len(resp.Candidates[0].Content.Parts) == 0 {
		return "", fmt.Errorf("no response candidates returned")
	}

	var aiResponse string
	for _, part := range resp.Candidates[0].Content.Parts {
		if part.Text != "" {
			aiResponse += part.Text
		}
	}

	// Append AI response to history
	gc.sessions[channelID] = append(gc.sessions[channelID], &genai.Content{
		Role: "model",
		Parts: []*genai.Part{
			{Text: aiResponse},
		},
	})

	return aiResponse, nil
}

// Reset clears the conversation history for a specific channel
func (gc *GeminiClient) Reset(channelID string) {
	gc.mu.Lock()
	defer gc.mu.Unlock()
	delete(gc.sessions, channelID)
}

package main

import (
	"fmt"
	"log"
	"os"
	"os/signal"
	"strings"
	"syscall"

	"github.com/bwmarrin/discordgo"
	"github.com/joho/godotenv"
)

var geminiClient *GeminiClient

func main() {
	// Load .env
	godotenv.Load()

	botToken := os.Getenv("DISCORD_BOT_TOKEN")
	geminiKey := os.Getenv("GEMINI_API_KEY")

	if botToken == "" || geminiKey == "" {
		log.Fatal("Please set DISCORD_BOT_TOKEN and GEMINI_API_KEY in the .env file")
	}

	// Initialize Gemini Client
	var err error
	geminiClient, err = NewGeminiClient(geminiKey)
	if err != nil {
		log.Fatal("Error creating Gemini client:", err)
	}

	// Initialize Discord Session
	dg, err := discordgo.New("Bot " + botToken)
	if err != nil {
		log.Fatal("error creating Discord session,", err)
	}

	// Register message event handler
	dg.AddHandler(messageCreate)

	// Set Intent
	dg.Identify.Intents = discordgo.IntentsGuildMessages

	// Open connection
	err = dg.Open()
	if err != nil {
		log.Fatal("error opening connection,", err)
	}
	defer dg.Close()

	fmt.Println("Bot is now running. Press CTRL-C to exit.")

	// Wait for interrupt signal
	sc := make(chan os.Signal, 1)
	signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt)
	<-sc
}

func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
	if m.Author.ID == s.State.User.ID {
		return
	}

	// Command: !reset (Clear memory)
	if m.Content == "!reset" {
		if geminiClient != nil {
			geminiClient.Reset(m.ChannelID)
			s.ChannelMessageSend(m.ChannelID, "🧹 Conversation history for this channel has been cleared, we can start over!")
		}
		return
	}

	// Command: !ai <message>
	if strings.HasPrefix(m.Content, "!ai ") {
		userMessage := strings.TrimPrefix(m.Content, "!ai ")
		if userMessage == "" {
			s.ChannelMessageSend(m.ChannelID, "Please enter a message, e.g., `!ai Hello`")
			return
		}

		// Show "Typing..." status
		s.ChannelTyping(m.ChannelID)

		if geminiClient != nil {
			response, err := geminiClient.Chat(m.ChannelID, userMessage)
			if err != nil {
				log.Println("Gemini Error:", err)
				s.ChannelMessageSend(m.ChannelID, "❌ AI encountered an error, please try again later.")
				return
			}

			// Discord message limit is 2000 characters, simple truncation here
			if len(response) > 2000 {
				s.ChannelMessageSend(m.ChannelID, response[:1990]+"...\n(Response truncated due to length)")
			} else {
				s.ChannelMessageSend(m.ChannelID, response)
			}
		}
	}
}

DISCORD_BOT_TOKEN=YourToken
GEMINI_API_KEY=YourAPIKey

go run .