skobkin/telegram-ollama-reply-bot
1
0
Fork 0
Code Issues 3 Pull requests 1 Releases Activity

Compare commits

base: skobkin:main
Branches Tags
skobkin:main
skobkin:feature_4_configuration
skobkin:0.5.2
skobkin:0.5.1
skobkin:0.5.0
skobkin:0.4.0
skobkin:0.3.2
skobkin:0.3.1
skobkin:0.3.0
skobkin:0.2.3
skobkin:0.2.2
skobkin:0.2.1
skobkin:0.2.0
skobkin:0.1.1
skobkin:0.1.0
skobkin:0.0.1
..
compare: skobkin:0.2.1
Branches Tags
skobkin:main
skobkin:feature_4_configuration
skobkin:0.5.2
skobkin:0.5.1
skobkin:0.5.0
skobkin:0.4.0
skobkin:0.3.2
skobkin:0.3.1
skobkin:0.3.0
skobkin:0.2.3
skobkin:0.2.2
skobkin:0.2.1
skobkin:0.2.0
skobkin:0.1.1
skobkin:0.1.0
skobkin:0.0.1

No commits in common. "main" and "0.2.1" have entirely different histories.
main ... 0.2.1

14 changed files with 141 additions and 583 deletions
Show stats Expand all files Collapse all files

7
Dockerfile
View file

@ -13,11 +13,4 @@ WORKDIR /app
COPY --from=builder /build/app .
# Do not forget "/v1" in the end
ENV OPENAI_API_BASE_URL="" \
OPENAI_API_TOKEN="" \
TELEGRAM_TOKEN="" \
MODEL_TEXT_REQUEST="llama3.1:8b-instruct-q6_K" \
MODEL_SUMMARIZE_REQUEST="llama3.1:8b-instruct-q6_K"
CMD ["/app/app"]

6
README.md
View file

@ -8,10 +8,8 @@
```shell
docker run \
-e OPENAI_API_TOKEN=123 \
-e OPENAI_API_BASE_URL=http://ollama.localhost:11434/v1 \
-e OLLAMA_TOKEN=123 \
-e OLLAMA_BASE_URL=http://ollama.tld:11434 \
-e TELEGRAM_TOKEN=12345 \
-e MODEL_TEXT_REQUEST=llama3.1:8b-instruct-q6_K
-e MODEL_SUMMARIZE_REQUEST=mistral-nemo:12b-instruct-2407-q4_K_M
skobkin/telegram-llm-bot
```

196
bot/bot.go
View file

@ -6,6 +6,7 @@ import (
th "github.com/mymmrac/telego/telegohandler"
tu "github.com/mymmrac/telego/telegoutil"
"log/slog"
"net/url"
"strings"
"telegram-ollama-reply-bot/extractor"
"telegram-ollama-reply-bot/llm"
@ -18,75 +19,47 @@ var (
ErrHandlerInit = errors.New("cannot initialize handler")
)
type BotInfo struct {
Id int64
Username string
Name string
}
type Bot struct {
api *telego.Bot
llm *llm.LlmConnector
extractor *extractor.Extractor
stats *stats.Stats
models ModelSelection
history map[int64]*MessageRingBuffer
profile BotInfo
markdownV1Replacer *strings.Replacer
}
func NewBot(
api *telego.Bot,
llm *llm.LlmConnector,
extractor *extractor.Extractor,
models ModelSelection,
) *Bot {
func NewBot(api *telego.Bot, llm *llm.LlmConnector, extractor *extractor.Extractor) *Bot {
return &Bot{
api: api,
llm: llm,
extractor: extractor,
stats: stats.NewStats(),
models: models,
history: make(map[int64]*MessageRingBuffer),
profile: BotInfo{0, "", ""},
markdownV1Replacer: strings.NewReplacer(
// https://core.telegram.org/bots/api#markdown-style
"_", "\\_",
//"*", "\\*",
//"`", "\\`",
//"[", "\\[",
),
}
}
func (b *Bot) Run() error {
botUser, err := b.api.GetMe()
if err != nil {
slog.Error("Cannot retrieve api user", "error", err)
slog.Error("Cannot retrieve api user", err)
return ErrGetMe
}
slog.Info("Running api as", "id", botUser.ID, "username", botUser.Username, "name", botUser.FirstName, "is_bot", botUser.IsBot)
b.profile = BotInfo{
Id: botUser.ID,
Username: botUser.Username,
Name: botUser.FirstName,
}
slog.Info("Running api as", map[string]any{
"id": botUser.ID,
"username": botUser.Username,
"name": botUser.FirstName,
"is_bot": botUser.IsBot,
})
updates, err := b.api.UpdatesViaLongPolling(nil)
if err != nil {
slog.Error("Cannot get update channel", "error", err)
slog.Error("Cannot get update channel", err)
return ErrUpdatesChannel
}
bh, err := th.NewBotHandler(b.api, updates)
if err != nil {
slog.Error("Cannot initialize bot handler", "error", err)
slog.Error("Cannot initialize bot handler", err)
return ErrHandlerInit
}
@ -95,60 +68,42 @@ func (b *Bot) Run() error {
defer b.api.StopLongPolling()
// Middlewares
bh.Use(b.chatHistory)
bh.Use(b.chatTypeStatsCounter)
// Command handlers
// Handlers
bh.Handle(b.startHandler, th.CommandEqual("start"))
bh.Handle(b.summarizeHandler, th.Or(th.CommandEqual("summarize"), th.CommandEqual("s")))
bh.Handle(b.heyHandler, th.CommandEqual("hey"))
bh.Handle(b.summarizeHandler, th.CommandEqual("summarize"))
bh.Handle(b.statsHandler, th.CommandEqual("stats"))
bh.Handle(b.helpHandler, th.CommandEqual("help"))
bh.Handle(b.textMessageHandler, th.AnyMessageWithText())
bh.Start()
return nil
}
func (b *Bot) textMessageHandler(bot *telego.Bot, update telego.Update) {
slog.Debug("/any-message")
func (b *Bot) heyHandler(bot *telego.Bot, update telego.Update) {
slog.Info("/hey")
message := update.Message
b.stats.HeyRequest()
switch {
// Mentions
case b.isMentionOfMe(update):
slog.Info("/any-message", "type", "mention")
b.processMention(message)
// Replies
case b.isReplyToMe(update):
slog.Info("/any-message", "type", "reply")
b.processMention(message)
// Private chat
case b.isPrivateWithMe(update):
slog.Info("/any-message", "type", "private")
b.processMention(message)
default:
slog.Debug("/any-message", "info", "Message is not mention, reply or private chat. Skipping.")
parts := strings.SplitN(update.Message.Text, " ", 2)
userMessage := "Hey!"
if len(parts) == 2 {
userMessage = parts[1]
}
}
func (b *Bot) processMention(message *telego.Message) {
b.stats.Mention()
slog.Info("/mention", "chat", message.Chat.ID)
chatID := tu.ID(message.Chat.ID)
chatID := tu.ID(update.Message.Chat.ID)
b.sendTyping(chatID)
requestContext := b.createLlmRequestContextFromMessage(message)
requestContext := b.createLlmRequestContext(update)
llmReply, err := b.llm.HandleChatMessage(message.Text, b.models.TextRequestModel, requestContext)
llmReply, err := b.llm.HandleSingleRequest(userMessage, llm.ModelMistralUncensored, requestContext)
if err != nil {
slog.Error("Cannot get reply from LLM connector")
_, _ = b.api.SendMessage(b.reply(message, tu.Message(
_, _ = b.api.SendMessage(b.reply(update.Message, tu.Message(
chatID,
"LLM request error. Try again later.",
)))
@ -156,27 +111,24 @@ func (b *Bot) processMention(message *telego.Message) {
return
}
slog.Debug("Got completion. Going to send.", "llm-completion", llmReply)
slog.Debug("Got completion. Going to send.", llmReply)
reply := tu.Message(
message := tu.Message(
chatID,
b.escapeMarkdownV1Symbols(llmReply),
llmReply,
).WithParseMode("Markdown")
_, err = b.api.SendMessage(b.reply(message, reply))
_, err = bot.SendMessage(b.reply(update.Message, message))
if err != nil {
slog.Error("Can't send reply message", "error", err)
slog.Error("Can't send reply message", err)
b.trySendReplyError(message)
return
b.trySendReplyError(update.Message)
}
b.saveBotReplyToHistory(message, llmReply)
}
func (b *Bot) summarizeHandler(bot *telego.Bot, update telego.Update) {
slog.Info("/summarize", "message-text", update.Message.Text)
slog.Info("/summarize", update.Message.Text)
b.stats.SummarizeRequest()
@ -184,7 +136,7 @@ func (b *Bot) summarizeHandler(bot *telego.Bot, update telego.Update) {
b.sendTyping(chatID)
args := strings.SplitN(update.Message.Text, " ", 2)
args := strings.Split(update.Message.Text, " ")
if len(args) < 2 {
_, _ = bot.SendMessage(tu.Message(
@ -197,8 +149,9 @@ func (b *Bot) summarizeHandler(bot *telego.Bot, update telego.Update) {
return
}
if !isValidAndAllowedUrl(args[1]) {
slog.Error("Provided text is not a valid URL", "text", args[1])
_, err := url.ParseRequestURI(args[1])
if err != nil {
slog.Error("Provided URL is not valid", args[1])
_, _ = b.api.SendMessage(b.reply(update.Message, tu.Message(
chatID,
@ -210,10 +163,10 @@ func (b *Bot) summarizeHandler(bot *telego.Bot, update telego.Update) {
article, err := b.extractor.GetArticleFromUrl(args[1])
if err != nil {
slog.Error("Cannot retrieve an article using extractor", "error", err)
slog.Error("Cannot retrieve an article using extractor", err)
}
llmReply, err := b.llm.Summarize(article.Text, b.models.SummarizeModel)
llmReply, err := b.llm.Summarize(article.Text, llm.ModelMistralUncensored)
if err != nil {
slog.Error("Cannot get reply from LLM connector")
@ -225,17 +178,17 @@ func (b *Bot) summarizeHandler(bot *telego.Bot, update telego.Update) {
return
}
slog.Debug("Got completion. Going to send.", "llm-completion", llmReply)
slog.Debug("Got completion. Going to send.", llmReply)
message := tu.Message(
chatID,
b.escapeMarkdownV1Symbols(llmReply),
llmReply,
).WithParseMode("Markdown")
_, err = bot.SendMessage(b.reply(update.Message, message))
if err != nil {
slog.Error("Can't send reply message", "error", err)
slog.Error("Can't send reply message", err)
b.trySendReplyError(update.Message)
}
@ -253,12 +206,10 @@ func (b *Bot) helpHandler(bot *telego.Bot, update telego.Update) {
"Instructions:\r\n"+
"/hey <text> - Ask something from LLM\r\n"+
"/summarize <link> - Summarize text from the provided link\r\n"+
"/s <link> - Shorter version\r\n"+
"/help - Show this help\r\n\r\n"+
"Mention bot or reply to it's message to communicate with it",
"/help - Show this help",
)))
if err != nil {
slog.Error("Cannot send a message", "error", err)
slog.Error("Cannot send a message", err)
b.trySendReplyError(update.Message)
}
@ -277,7 +228,7 @@ func (b *Bot) startHandler(bot *telego.Bot, update telego.Update) {
"Check out /help to learn how to use this bot.",
)))
if err != nil {
slog.Error("Cannot send a message", "error", err)
slog.Error("Cannot send a message", err)
b.trySendReplyError(update.Message)
}
@ -298,12 +249,63 @@ func (b *Bot) statsHandler(bot *telego.Bot, update telego.Update) {
"```",
)).WithParseMode("Markdown"))
if err != nil {
slog.Error("Cannot send a message", "error", err)
slog.Error("Cannot send a message", err)
b.trySendReplyError(update.Message)
}
}
func (b *Bot) escapeMarkdownV1Symbols(input string) string {
return b.markdownV1Replacer.Replace(input)
func (b *Bot) createLlmRequestContext(update telego.Update) llm.RequestContext {
message := update.Message
rc := llm.RequestContext{}
if message == nil {
return rc
}
user := message.From
if user != nil {
rc.User = llm.UserContext{
Username: user.Username,
FirstName: user.FirstName,
LastName: user.LastName,
IsPremium: user.IsPremium,
}
}
chat := message.Chat
rc.Chat = llm.ChatContext{
Title: chat.Title,
Description: chat.Description,
Type: chat.Type,
}
return rc
}
func (b *Bot) reply(originalMessage *telego.Message, newMessage *telego.SendMessageParams) *telego.SendMessageParams {
return newMessage.WithReplyParameters(&telego.ReplyParameters{
MessageID: originalMessage.MessageID,
})
}
func (b *Bot) sendTyping(chatId telego.ChatID) {
slog.Debug("Setting 'typing' chat action")
err := b.api.SendChatAction(tu.ChatAction(chatId, "typing"))
if err != nil {
slog.Error("Cannot set chat action", err)
}
}
func (b *Bot) trySendReplyError(message *telego.Message) {
if message == nil {
return
}
_, _ = b.api.SendMessage(b.reply(message, tu.Message(
tu.ID(message.Chat.ID),
"Error occurred while trying to send reply.",
)))
}

93
bot/helpers.go
View file

@ -1,93 +0,0 @@
package bot
import (
"github.com/mymmrac/telego"
tu "github.com/mymmrac/telego/telegoutil"
"log/slog"
"net/url"
"slices"
"strings"
)
var (
allowedUrlSchemes = []string{"http", "https"}
)
func (b *Bot) reply(originalMessage *telego.Message, newMessage *telego.SendMessageParams) *telego.SendMessageParams {
return newMessage.WithReplyParameters(&telego.ReplyParameters{
MessageID: originalMessage.MessageID,
})
}
func (b *Bot) sendTyping(chatId telego.ChatID) {
slog.Debug("Setting 'typing' chat action")
err := b.api.SendChatAction(tu.ChatAction(chatId, "typing"))
if err != nil {
slog.Error("Cannot set chat action", "error", err)
}
}
func (b *Bot) trySendReplyError(message *telego.Message) {
if message == nil {
return
}
_, _ = b.api.SendMessage(b.reply(message, tu.Message(
tu.ID(message.Chat.ID),
"Error occurred while trying to send reply.",
)))
}
func (b *Bot) isMentionOfMe(update telego.Update) bool {
if update.Message == nil {
return false
}
return strings.Contains(update.Message.Text, "@"+b.profile.Username)
}
func (b *Bot) isReplyToMe(update telego.Update) bool {
message := update.Message
if message == nil {
return false
}
if message.ReplyToMessage == nil {
return false
}
if message.ReplyToMessage.From == nil {
return false
}
replyToMessage := message.ReplyToMessage
return replyToMessage != nil && replyToMessage.From.ID == b.profile.Id
}
func (b *Bot) isPrivateWithMe(update telego.Update) bool {
message := update.Message
if message == nil {
return false
}
return message.Chat.Type == telego.ChatTypePrivate
}
func isValidAndAllowedUrl(text string) bool {
u, err := url.ParseRequestURI(text)
if err != nil {
slog.Debug("Provided text is not an URL", "text", text)
return false
}
if !slices.Contains(allowedUrlSchemes, strings.ToLower(u.Scheme)) {
slog.Debug("Provided URL has disallowed scheme", "scheme", u.Scheme, "allowed-schemes", allowedUrlSchemes)
return false
}
return true
}

24
bot/logger.go
View file

@ -1,24 +0,0 @@
package bot
import (
"fmt"
"log/slog"
)
type Logger struct {
prefix string
}
func NewLogger(prefix string) Logger {
return Logger{
prefix: prefix,
}
}
func (l Logger) Debugf(format string, args ...any) {
slog.Debug(l.prefix + fmt.Sprint(format, args))
}
func (l Logger) Errorf(format string, args ...any) {
slog.Error(l.prefix + fmt.Sprintf(format, args))
}

93
bot/message_history.go
View file

@ -1,93 +0,0 @@
package bot
import (
"github.com/mymmrac/telego"
"log/slog"
)
const HistoryLength = 150
type Message struct {
Name string
Text string
IsMe bool
}
type MessageRingBuffer struct {
messages []Message
capacity int
}
func NewMessageBuffer(capacity int) *MessageRingBuffer {
return &MessageRingBuffer{
messages: make([]Message, 0, capacity),
capacity: capacity,
}
}
func (b *MessageRingBuffer) Push(element Message) {
if len(b.messages) >= b.capacity {
b.messages = b.messages[1:]
}
b.messages = append(b.messages, element)
}
func (b *MessageRingBuffer) GetAll() []Message {
return b.messages
}
func (b *Bot) saveChatMessageToHistory(message *telego.Message) {
chatId := message.Chat.ID
slog.Info(
"history-message-save",
"chat", chatId,
"from_id", message.From.ID,
"from_name", message.From.FirstName,
"text", message.Text,
)
_, ok := b.history[chatId]
if !ok {
b.history[chatId] = NewMessageBuffer(HistoryLength)
}
b.history[chatId].Push(Message{
Name: message.From.FirstName,
Text: message.Text,
IsMe: false,
})
}
func (b *Bot) saveBotReplyToHistory(message *telego.Message, reply string) {
chatId := message.Chat.ID
slog.Info(
"history-reply-save",
"chat", chatId,
"to_id", message.From.ID,
"to_name", message.From.FirstName,
"text", reply,
)
_, ok := b.history[chatId]
if !ok {
b.history[chatId] = NewMessageBuffer(HistoryLength)
}
b.history[chatId].Push(Message{
Name: b.profile.Username,
Text: reply,
IsMe: true,
})
}
func (b *Bot) getChatHistory(chatId int64) []Message {
_, ok := b.history[chatId]
if !ok {
return make([]Message, 0)
}
return b.history[chatId].GetAll()
}

27
bot/middleware.go
View file

@ -3,48 +3,21 @@ package bot
import (
"github.com/mymmrac/telego"
"github.com/mymmrac/telego/telegohandler"
"log/slog"
)
func (b *Bot) chatTypeStatsCounter(bot *telego.Bot, update telego.Update, next telegohandler.Handler) {
message := update.Message
if message == nil {
slog.Info("stats-middleware: update has no message. skipping.")
next(bot, update)
return
}
switch message.Chat.Type {
case telego.ChatTypeGroup, telego.ChatTypeSupergroup:
if b.isMentionOfMe(update) || b.isReplyToMe(update) {
slog.Info("stats-middleware: counting message chat type in stats", "type", message.Chat.Type)
b.stats.GroupRequest()
}
case telego.ChatTypePrivate:
slog.Info("stats-middleware: counting message chat type in stats", "type", message.Chat.Type)
b.stats.PrivateRequest()
}
next(bot, update)
}
func (b *Bot) chatHistory(bot *telego.Bot, update telego.Update, next telegohandler.Handler) {
message := update.Message
if message == nil {
slog.Info("chat-history-middleware: update has no message. skipping.")
next(bot, update)
return
}
slog.Info("chat-history-middleware: saving message to history for", "chat_id", message.Chat.ID)
b.saveChatMessageToHistory(message)
next(bot, update)
}

6
bot/models.go
View file

@ -1,6 +0,0 @@
package bot
type ModelSelection struct {
TextRequestModel string
SummarizeModel string
}

68
bot/request_context.go
View file

@ -1,68 +0,0 @@
package bot
import (
"github.com/mymmrac/telego"
"log/slog"
"telegram-ollama-reply-bot/llm"
)
func (b *Bot) createLlmRequestContextFromMessage(message *telego.Message) llm.RequestContext {
rc := llm.RequestContext{
Empty: true,
}
if message == nil {
slog.Debug("request context creation problem: no message provided. returning empty context.", "request-context", rc)
return rc
}
rc.Empty = false
user := message.From
if user != nil {
rc.User = llm.UserContext{
Username: user.Username,
FirstName: user.FirstName,
LastName: user.LastName,
IsPremium: user.IsPremium,
}
}
// TODO: implement retrieval of chat description
chat := message.Chat
history := b.getChatHistory(chat.ID)
rc.Chat = llm.ChatContext{
Title: chat.Title,
// TODO: fill when ChatFullInfo retrieved
//Description: chat.Description,
Type: chat.Type,
History: historyToLlmMessages(history),
}
slog.Debug("request context created", "request-context", rc)
return rc
}
func historyToLlmMessages(history []Message) []llm.ChatMessage {
length := len(history)
if length > 0 {
result := make([]llm.ChatMessage, 0, length)
for _, msg := range history {
result = append(result, llm.ChatMessage{
Name: msg.Name,
Text: msg.Text,
})
}
return result
}
return make([]llm.ChatMessage, 0)
}

7
extractor/extractor.go
View file

@ -3,7 +3,6 @@ package extractor
import (
"errors"
"github.com/advancedlogic/GoOse"
"log/slog"
)
var (
@ -29,18 +28,12 @@ type Article struct {
}
func (e *Extractor) GetArticleFromUrl(url string) (Article, error) {
slog.Info("extractor: requested extraction from URL ", "url", url)
article, err := e.goose.ExtractFromURL(url)
if err != nil {
slog.Error("extractor: failed extracting from URL", "url", url)
return Article{}, ErrExtractFailed
}
slog.Debug("extractor: article extracted", "article", article)
return Article{
Title: article.Title,
Text: article.CleanedText,

99
llm/llm.go
View file

@ -5,13 +5,13 @@ import (
"errors"
"github.com/sashabaranov/go-openai"
"log/slog"
"strconv"
"strings"
)
var (
ErrLlmBackendRequestFailed = errors.New("llm back-end request failed")
ErrNoChoices = errors.New("no choices in LLM response")
ModelMistralUncensored = "dolphin-mistral"
)
type LlmConnector struct {
@ -29,47 +29,20 @@ func NewConnector(baseUrl string, token string) *LlmConnector {
}
}
func (l *LlmConnector) HandleChatMessage(text string, model string, requestContext RequestContext) (string, error) {
systemPrompt := "You're a bot in the Telegram chat.\n" +
"You're using a free model called \"" + model + "\".\n\n" +
requestContext.Prompt()
historyLength := len(requestContext.Chat.History)
if historyLength > 0 {
systemPrompt += "\nYou have access to last " + strconv.Itoa(historyLength) + "messages in this chat."
}
func (l *LlmConnector) HandleSingleRequest(text string, model string, requestContext RequestContext) (string, error) {
req := openai.ChatCompletionRequest{
Model: model,
Messages: []openai.ChatCompletionMessage{
{
Role: openai.ChatMessageRoleSystem,
Content: systemPrompt,
Content: "You're a bot in the Telegram chat. " +
"You're using a free model called \"" + model + "\". " +
"You see only messages addressed to you using commands due to privacy settings. " +
requestContext.Prompt(),
},
},
}
if historyLength > 0 {
for _, msg := range requestContext.Chat.History {
var msgRole string
var msgText string
if msg.IsMe {
msgRole = openai.ChatMessageRoleAssistant
msgText = msg.Text
} else {
msgRole = openai.ChatMessageRoleSystem
msgText = "User " + msg.Name + " said:\n" + msg.Text
}
req.Messages = append(req.Messages, openai.ChatCompletionMessage{
Role: msgRole,
Content: msgText,
})
}
}
req.Messages = append(req.Messages, openai.ChatCompletionMessage{
Role: openai.ChatMessageRoleUser,
Content: text,
@ -77,15 +50,15 @@ func (l *LlmConnector) HandleChatMessage(text string, model string, requestConte
resp, err := l.client.CreateChatCompletion(context.Background(), req)
if err != nil {
slog.Error("llm: LLM back-end request failed", "error", err)
slog.Error("LLM back-end request failed", err)
return "", ErrLlmBackendRequestFailed
}
slog.Debug("llm: Received LLM back-end response", "response", resp)
slog.Debug("Received LLM back-end response", resp)
if len(resp.Choices) < 1 {
slog.Error("llm: LLM back-end reply has no choices")
slog.Error("LLM back-end reply has no choices")
return "", ErrNoChoices
}
@ -99,11 +72,9 @@ func (l *LlmConnector) Summarize(text string, model string) (string, error) {
Messages: []openai.ChatCompletionMessage{
{
Role: openai.ChatMessageRoleSystem,
Content: "You're a text shortener. Give a very brief summary of the main facts " +
"point by point. Format them as a list of bullet points each starting with \"-\". " +
"Avoid any commentaries and value judgement on the matter. " +
"If possible, respond in the same language as the original text." +
"Do not use any non-ASCII characters.",
Content: "You are a short digest editor. Summarize the text you received " +
"as a list of bullet points with most important facts from the text. " +
"If possible, use the same language as the original text.",
},
},
}
@ -115,56 +86,18 @@ func (l *LlmConnector) Summarize(text string, model string) (string, error) {
resp, err := l.client.CreateChatCompletion(context.Background(), req)
if err != nil {
slog.Error("llm: LLM back-end request failed", "error", err)
slog.Error("LLM back-end request failed", err)
return "", ErrLlmBackendRequestFailed
}
slog.Debug("llm: Received LLM back-end response", resp)
slog.Debug("Received LLM back-end response", resp)
if len(resp.Choices) < 1 {
slog.Error("llm: LLM back-end reply has no choices")
slog.Error("LLM back-end reply has no choices")
return "", ErrNoChoices
}
return resp.Choices[0].Message.Content, nil
}
func (l *LlmConnector) GetModels() []string {
var result []string
models, err := l.client.ListModels(context.Background())
if err != nil {
slog.Error("llm: Model list request failed", "error", err)
return result
}
slog.Info("Model list retrieved", "models", models)
for _, model := range models.Models {
result = append(result, model.ID)
}
return result
}
func (l *LlmConnector) HasModel(id string) bool {
model, err := l.client.GetModel(context.Background(), id)
if err != nil {
slog.Error("llm: Model request failed", "error", err)
}
slog.Debug("llm: Returned model", "model", model)
if model.ID != "" {
return true
}
return false
}
func quoteMessage(text string) string {
return "> " + strings.ReplaceAll(text, "\n", "\n> ")
}

37
llm/request_context.go
View file

@ -1,7 +1,6 @@
package llm
type RequestContext struct {
Empty bool
User UserContext
Chat ChatContext
}
@ -17,48 +16,28 @@ type ChatContext struct {
Title string
Description string
Type string
History []ChatMessage
}
type ChatMessage struct {
Name string
Text string
IsMe bool
}
func (c RequestContext) Prompt() string {
if c.Empty {
return ""
}
prompt := ""
prompt += "The type of chat you're in is \"" + c.Chat.Type + "\". "
if c.Chat.Type == "group" || c.Chat.Type == "supergroup" {
prompt += "Please consider that there are several users in this chat type who may discuss several unrelated " +
"topics. Try to respond only about the topic you were asked about and only to the user who asked you, " +
"but keep in mind another chat history. "
}
prompt := "The type of chat you're in is \"" + c.Chat.Type + "\". "
if c.Chat.Title != "" {
prompt += "\nChat is called \"" + c.Chat.Title + "\". "
prompt += "Chat is called \"" + c.Chat.Title + "\". "
}
if c.Chat.Description != "" {
prompt += "Chat description is \"" + c.Chat.Description + "\". "
}
prompt += "\nProfile of the user who mentioned you in the chat:" +
"First name: \"" + c.User.FirstName + "\"\n"
if c.User.Username != "" {
prompt += "Username: @" + c.User.Username + ".\n"
prompt += "The user who wrote you has username \"@" + c.User.Username + "\". "
}
prompt += "Their first name is \"" + c.User.FirstName + "\". "
if c.User.LastName != "" {
prompt += "Last name: \"" + c.User.LastName + "\"\n"
prompt += "Their last name is \"" + c.User.LastName + "\". "
}
if c.User.IsPremium {
prompt += "They have Telegram Premium subscription. "
}
//if c.User.IsPremium {
// prompt += "Telegram Premium subscription: active."
//}
return prompt
}

31
main.go
View file

@ -12,44 +12,25 @@ import (
)
func main() {
apiToken := os.Getenv("OPENAI_API_TOKEN")
apiBaseUrl := os.Getenv("OPENAI_API_BASE_URL")
models := bot.ModelSelection{
TextRequestModel: os.Getenv("MODEL_TEXT_REQUEST"),
SummarizeModel: os.Getenv("MODEL_SUMMARIZE_REQUEST"),
}
slog.Info("Selected", "models", models)
ollamaToken := os.Getenv("OLLAMA_TOKEN")
ollamaBaseUrl := os.Getenv("OLLAMA_BASE_URL")
telegramToken := os.Getenv("TELEGRAM_TOKEN")
llmc := llm.NewConnector(apiBaseUrl, apiToken)
slog.Info("Checking models availability")
for _, model := range []string{models.TextRequestModel, models.SummarizeModel} {
if !llmc.HasModel(model) {
slog.Error("Model not unavailable", "model", model)
os.Exit(1)
}
}
slog.Info("All needed models are available")
llmc := llm.NewConnector(ollamaBaseUrl, ollamaToken)
ext := extractor.NewExtractor()
telegramApi, err := tg.NewBot(telegramToken, tg.WithLogger(bot.NewLogger("telego: ")))
telegramApi, err := tg.NewBot(telegramToken, tg.WithDefaultLogger(false, true))
if err != nil {
fmt.Println(err)
os.Exit(1)
}
botService := bot.NewBot(telegramApi, llmc, ext, models)
botService := bot.NewBot(telegramApi, llmc, ext)
err = botService.Run()
if err != nil {
slog.Error("Running bot finished with an error", "error", err)
slog.Error("Running bot finished with an error", err)
os.Exit(1)
}
}

22
stats/stats.go
View file

@ -13,9 +13,8 @@ type Stats struct {
GroupRequests uint64
PrivateRequests uint64
InlineQueries uint64
Mentions uint64
HeyRequests uint64
SummarizeRequests uint64
}
@ -25,9 +24,8 @@ func NewStats() *Stats {
GroupRequests: 0,
PrivateRequests: 0,
InlineQueries: 0,
Mentions: 0,
HeyRequests: 0,
SummarizeRequests: 0,
}
}
@ -38,18 +36,16 @@ func (s *Stats) MarshalJSON() ([]byte, error) {
GroupRequests uint64 `json:"group_requests"`
PrivateRequests uint64 `json:"private_requests"`
InlineQueries uint64 `json:"inline_queries"`
Mentions uint64 `json:"mentions"`
HeyRequests uint64 `json:"hey_requests"`
SummarizeRequests uint64 `json:"summarize_requests"`
}{
Uptime: time.Now().Sub(s.RunningSince).String(),
GroupRequests: s.GroupRequests,
PrivateRequests: s.PrivateRequests,
InlineQueries: s.InlineQueries,
Mentions: s.Mentions,
HeyRequests: s.HeyRequests,
SummarizeRequests: s.SummarizeRequests,
})
}
@ -63,12 +59,6 @@ func (s *Stats) String() string {
return string(data)
}
func (s *Stats) InlineQuery() {
s.mu.Lock()
defer s.mu.Unlock()
s.InlineQueries++
}
func (s *Stats) GroupRequest() {
s.mu.Lock()
defer s.mu.Unlock()
@ -81,10 +71,10 @@ func (s *Stats) PrivateRequest() {
s.PrivateRequests++
}
func (s *Stats) Mention() {
func (s *Stats) HeyRequest() {
s.mu.Lock()
defer s.mu.Unlock()
s.Mentions++
s.HeyRequests++
}
func (s *Stats) SummarizeRequest() {