Библиотека WhatsApp GPT Bot Go#

go get github.com/green-api/whatsapp-chatgpt-go

package main

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

    "github.com/green-api/whatsapp-chatgpt-go"
)

func main() {
    // Инициализация бота
    bot := whatsapp_chatgpt_go.NewWhatsappGptBot(whatsapp_chatgpt_go.GPTBotConfig{
        IDInstance:       "your-instance-id",
        APITokenInstance: "your-token",
        OpenAIApiKey:     "your-openai-api-key",
        Model:            whatsapp_chatgpt_go.ModelGPT4o,
        SystemMessage:    "Ты полезный ассистент.",
    })

    // Настройка обработки сигналов для корректного завершения
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    // Запуск бота в горутине
    go func() {
        log.Println("Запуск WhatsApp GPT бота...")
        bot.StartReceivingNotifications()
    }()

    // Ожидание сигнала завершения
    <-sigChan

    // Завершение работы
    log.Println("Завершение работы бота...")
    bot.StopReceivingNotifications()
    log.Println("Бот остановлен.")
}

bot := whatsapp_chatgpt_go.NewWhatsappGptBot(whatsapp_chatgpt_go.GPTBotConfig{
    IDInstance:       "your-instance-id",
    APITokenInstance: "your-token",
    OpenAIApiKey:     "your-openai-api-key",
    Model:            whatsapp_chatgpt_go.ModelGPT4o,
    SystemMessage:    "Вы - полезный ассистент.",
})

// Начать прослушивание вебхуков и обработку сообщений
bot.StartReceivingNotifications()

gptBot := whatsapp_chatgpt_go.NewWhatsappGptBot(whatsapp_chatgpt_go.GPTBotConfig{
    IDInstance:       "your-instance-id",
    APITokenInstance: "your-token",
    OpenAIApiKey:     "your-openai-api-key",
    Model:            whatsapp_chatgpt_go.ModelGPT4o,
    SystemMessage:    "Вы - полезный ассистент.",
})

// Не нужно вызывать StartReceivingNotifications - просто используйте ProcessMessage когда нужно
response, updatedSessionData, err := gptBot.ProcessMessage(
    ctx, 
    notification,  // Уведомление из вашего обработчика вебхуков
    sessionData    // Ваши собственные данные сессии
)
if err != nil {
    // Обработка ошибки
}

// Обработайте ответ своим способом
// Сохраните обновленные данные сессии в своей системе состояний

type GPTBotConfig struct {
    // API-ключ OpenAI
    OpenAIApiKey string

    // Модель для использования (по умолчанию: gpt-4o)
    Model OpenAIModel

    // Максимальное количество сообщений для хранения в истории (по умолчанию: 10)
    MaxHistoryLength int

    // Системное сообщение для установки поведения бота
    SystemMessage string

    // Температура для генерации ответов (по умолчанию: 0.5)
    Temperature float32

    // Сообщение об ошибке для отображения при возникновении проблем
    ErrorMessage string

    // ID инстанса GREEN-API
    IDInstance string

    // API токен инстанса GREEN-API
    APITokenInstance string

    // Следует ли очищать очередь вебхуков при запуске
    ClearWebhookQueueOnStart bool
}

bot := whatsapp_chatgpt_go.NewWhatsappGptBot(whatsapp_chatgpt_go.GPTBotConfig{
    // Обязательные параметры
    IDInstance:       "your-instance-id",
    APITokenInstance: "your-token",
    OpenAIApiKey:     "your-openai-api-key",

    // Опциональные GPT-специфические параметры
    Model:            whatsapp_chatgpt_go.ModelGPT4o,
    MaxHistoryLength: 15,
    SystemMessage:    "Вы - полезный ассистент, специализирующийся на поддержке клиентов.",
    Temperature:      0.7,
    ErrorMessage:     "Извините, я не смог обработать ваш запрос. Пожалуйста, попробуйте снова.",

    // Опциональные параметры поведения
    ClearWebhookQueueOnStart: true,
})

// Создание пользовательского обработчика сообщений
type CustomMessageHandler struct{}

func (h *CustomMessageHandler) CanHandle(notification *whatsapp_chatbot_golang.Notification) bool {
    // Логика для определения, может ли этот обработчик обработать сообщение
    return true
}

func (h *CustomMessageHandler) ProcessMessage(
    notification *whatsapp_chatbot_golang.Notification,
    client *openai.Client,
    model whatsapp_chatgpt_go.OpenAIModel,
) (interface{}, error) {
    // Обработка сообщения
    return "Обработанный контент", nil
}

// Регистрация пользовательского обработчика
bot.RegisterMessageHandler(&CustomMessageHandler{})

// Обработка сообщений перед отправкой в GPT
bot.AddMessageMiddleware(func(
    notification *whatsapp_chatbot_golang.Notification,
    messageContent interface{},
    messages []openai.ChatCompletionMessage,
    sessionData *whatsapp_chatgpt_go.GPTSessionData,
) (interface{}, []openai.ChatCompletionMessage, error) {
    // Добавление пользовательского контекста или изменение сообщения
    sender, _ := notification.Sender()
    log.Printf("Обработка сообщения от %s: %v", sender, messageContent)

    return messageContent, messages, nil
})

// Обработка ответов GPT перед отправкой пользователю
bot.AddResponseMiddleware(func(
    response string,
    messages []openai.ChatCompletionMessage,
    sessionData *whatsapp_chatgpt_go.GPTSessionData,
) (string, []openai.ChatCompletionMessage, error) {
    // Форматирование или изменение ответа
    formattedResponse := response + "\n\n_Работает на GREEN-API_"

    return formattedResponse, messages, nil
})

type GPTSessionData struct {
    // Сообщения в разговоре
    Messages []openai.ChatCompletionMessage `json:"messages"`

    // Временная метка последней активности
    LastActivity int64 `json:"lastActivity"`

    // Пользовательские данные
    UserData map[string]interface{} `json:"userData,omitempty"`

    // Контекст для текущего разговора
    Context map[string]interface{} `json:"context,omitempty"`
}

if whatsapp_chatgpt_go.SupportsImages(bot.GetModel()) {
    // Обработка рабочего процесса на основе изображений
}

package main

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

    "github.com/green-api/whatsapp-chatbot-golang"
    "github.com/green-api/whatsapp-chatgpt-go"
    "github.com/joho/godotenv"
    "github.com/sashabaranov/go-openai"
)

func truncateString(s string, length int) string {
    if len(s) > length {
        return s[:length] + "..."
    }
    return s
}

func main() {
    err := godotenv.Load()
    if err != nil {
        log.Println("Предупреждение: Ошибка загрузки файла .env:", err)
    }

    idInstance := os.Getenv("GREEN_API_ID_INSTANCE")
    apiTokenInstance := os.Getenv("GREEN_API_TOKEN_INSTANCE")
    openaiToken := os.Getenv("OPENAI_API_KEY")

    if idInstance == "" || apiTokenInstance == "" || openaiToken == "" {
        log.Fatalf("Отсутствуют обязательные переменные окружения: GREEN_API_ID_INSTANCE, GREEN_API_TOKEN_INSTANCE, OPENAI_API_KEY")
    }

    config := whatsapp_chatgpt_go.GPTBotConfig{
        IDInstance:               idInstance,
        APITokenInstance:         apiTokenInstance,
        OpenAIApiKey:             openaiToken,
        Model:                    whatsapp_chatgpt_go.ModelGPT4o,
        MaxHistoryLength:         10,
        SystemMessage:            "Ты ассистент, отвечающий через WhatsApp.",
        Temperature:              0.7,
        ErrorMessage:             "Извините, я столкнулся с ошибкой при обработке вашего сообщения.",
        ClearWebhookQueueOnStart: true,
    }

    bot := whatsapp_chatgpt_go.NewWhatsappGptBot(config)

    // Пример промежуточного ПО: Логирует детали о входящих сообщениях.
    bot.AddMessageMiddleware(func(notification *whatsapp_chatbot_golang.Notification,
        messageContent interface{},
        messages []openai.ChatCompletionMessage,
        sessionData *whatsapp_chatgpt_go.GPTSessionData) (interface{}, []openai.ChatCompletionMessage, error) {

        sender, _ := notification.Sender()

        var contentLog string
        if parts, ok := messageContent.([]openai.ChatMessagePart); ok {
            contentLog = "Части мультиконтента: ["
            for i, p := range parts {
                if i > 0 {
                    contentLog += ", "
                }
                contentLog += fmt.Sprintf("{Тип: %s, ", p.Type)
                if p.Type == openai.ChatMessagePartTypeText {
                    contentLog += fmt.Sprintf("Текст: '%s'", p.Text)
                } else if p.Type == openai.ChatMessagePartTypeImageURL && p.ImageURL != nil {
                    urlStr := p.ImageURL.URL
                    if len(urlStr) > 50 {
                        urlStr = urlStr[:47] + "..."
                    }
                    contentLog += fmt.Sprintf("URL изображения: %s", urlStr)
                } else {
                    contentLog += "Другие данные"
                }
                contentLog += "}"
            }
            contentLog += "]"
        } else {
            contentLog = fmt.Sprintf("Текстовый контент: '%s'", truncateString(fmt.Sprintf("%v", messageContent), 100))
        }
        log.Printf("--> MID: Получено от %s: %s", sender, contentLog)
        log.Printf("--> MID: История содержит %d сообщений перед добавлением текущего.", len(messages))

        return messageContent, messages, nil
    })

    // Пример промежуточного ПО: Логирует отправляемый ответ.
    bot.AddResponseMiddleware(func(response string,
        messages []openai.ChatCompletionMessage,
        sessionData *whatsapp_chatgpt_go.GPTSessionData) (string, []openai.ChatCompletionMessage, error) {

        log.Printf("<-- MID: Отправка ответа: %s", truncateString(response, 100))
        log.Printf("<-- MID: История содержит %d сообщений после добавления ответа ассистента.", len(messages))
        return response, messages, nil
    })

    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        log.Println("Запуск WhatsApp GPT бота...")
        bot.StartReceivingNotifications()
        log.Println("Цикл получения уведомлений остановлен.")
    }()

    <-sigChan

    log.Println("Завершение работы бота...")
    bot.StopReceivingNotifications()
    log.Println("Бот остановлен.")
}