Merge pull request 'Raising the limit of history container size' (#31) from skobkin-patch-1-history-limit into main

Reviewed-on: #31

.drone.yml

@@ -4,7 +4,7 @@ name: build
 
 steps:
   - name: build
-    image: 'golang:alpine'
+    image: 'golang:1-alpine'
     commands:
       - go build -x .
 

Dockerfile

@@ -13,4 +13,11 @@ 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"]

README.md

@@ -8,8 +8,10 @@
 
 ```shell
 docker run \
-  -e OLLAMA_TOKEN=123 \
+  -e OPENAI_API_TOKEN=123 \
-  -e OLLAMA_BASE_URL=http://ollama.tld:11434 \
+  -e OPENAI_API_BASE_URL=http://ollama.localhost:11434/v1 \
   -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
 ```

bot/bot.go

@@ -6,10 +6,10 @@ 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"
+	"telegram-ollama-reply-bot/stats"
 )
 
 var (
@@ -18,47 +18,75 @@ var (
 	ErrHandlerInit    = errors.New("cannot initialize handler")
 )
 
-const contextUserKey = "user"
+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) *Bot {
+func NewBot(
+	api *telego.Bot,
+	llm *llm.LlmConnector,
+	extractor *extractor.Extractor,
+	models ModelSelection,
+) *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", err)
+		slog.Error("Cannot retrieve api user", "error", err)
 
 		return ErrGetMe
 	}
 
-	slog.Info("Running api as", map[string]any{
+	slog.Info("Running api as", "id", botUser.ID, "username", botUser.Username, "name", botUser.FirstName, "is_bot", botUser.IsBot)
-		"id":       botUser.ID,
+
-		"username": botUser.Username,
+	b.profile = BotInfo{
-		"name":     botUser.FirstName,
+		Id:       botUser.ID,
-		"is_bot":   botUser.IsBot,
+		Username: botUser.Username,
-	})
+		Name:     botUser.FirstName,
+	}
 
 	updates, err := b.api.UpdatesViaLongPolling(nil)
 	if err != nil {
-		slog.Error("Cannot get update channel", err)
+		slog.Error("Cannot get update channel", "error", err)
 
 		return ErrUpdatesChannel
 	}
 
 	bh, err := th.NewBotHandler(b.api, updates)
 	if err != nil {
-		slog.Error("Cannot initialize bot handler", err)
+		slog.Error("Cannot initialize bot handler", "error", err)
 
 		return ErrHandlerInit
 	}
@@ -66,28 +94,61 @@ func (b *Bot) Run() error {
 	defer bh.Stop()
 	defer b.api.StopLongPolling()
 
+	// Middlewares
+	bh.Use(b.chatHistory)
+	bh.Use(b.chatTypeStatsCounter)
+
+	// Command handlers
 	bh.Handle(b.startHandler, th.CommandEqual("start"))
-	bh.Handle(b.heyHandler, th.CommandEqual("hey"))
+	bh.Handle(b.summarizeHandler, th.Or(th.CommandEqual("summarize"), th.CommandEqual("s")))
-	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) heyHandler(bot *telego.Bot, update telego.Update) {
+func (b *Bot) textMessageHandler(bot *telego.Bot, update telego.Update) {
-	slog.Info("/hey")
+	slog.Debug("/any-message")
 
-	chatID := tu.ID(update.Message.Chat.ID)
+	message := update.Message
+
+	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.")
+	}
+}
+
+func (b *Bot) processMention(message *telego.Message) {
+	b.stats.Mention()
+
+	slog.Info("/mention", "chat", message.Chat.ID)
+
+	chatID := tu.ID(message.Chat.ID)
 
 	b.sendTyping(chatID)
 
-	llmReply, err := b.llm.HandleSingleRequest(update.Message.Text, llm.ModelMistralUncensored)
+	requestContext := b.createLlmRequestContextFromMessage(message)
+
+	llmReply, err := b.llm.HandleChatMessage(message.Text, b.models.TextRequestModel, requestContext)
 	if err != nil {
 		slog.Error("Cannot get reply from LLM connector")
 
-		_, _ = b.api.SendMessage(b.reply(update.Message, tu.Message(
+		_, _ = b.api.SendMessage(b.reply(message, tu.Message(
 			chatID,
 			"LLM request error. Try again later.",
 		)))
@@ -95,28 +156,35 @@ func (b *Bot) heyHandler(bot *telego.Bot, update telego.Update) {
 		return
 	}
 
-	slog.Debug("Got completion. Going to send.", llmReply)
+	slog.Debug("Got completion. Going to send.", "llm-completion", llmReply)
 
-	message := tu.Message(
+	reply := tu.Message(
 		chatID,
-		llmReply,
+		b.escapeMarkdownV1Symbols(llmReply),
 	).WithParseMode("Markdown")
 
-	_, err = bot.SendMessage(b.reply(update.Message, message))
+	_, err = b.api.SendMessage(b.reply(message, reply))
-
 	if err != nil {
-		slog.Error("Can't send reply message", err)
+		slog.Error("Can't send reply message", "error", err)
+
+		b.trySendReplyError(message)
+
+		return
 	}
+
+	b.saveBotReplyToHistory(message, llmReply)
 }
 
 func (b *Bot) summarizeHandler(bot *telego.Bot, update telego.Update) {
-	slog.Info("/summarize", update.Message.Text)
+	slog.Info("/summarize", "message-text", update.Message.Text)
+
+	b.stats.SummarizeRequest()
 
 	chatID := tu.ID(update.Message.Chat.ID)
 
 	b.sendTyping(chatID)
 
-	args := strings.Split(update.Message.Text, " ")
+	args := strings.SplitN(update.Message.Text, " ", 2)
 
 	if len(args) < 2 {
 		_, _ = bot.SendMessage(tu.Message(
@@ -129,9 +197,8 @@ func (b *Bot) summarizeHandler(bot *telego.Bot, update telego.Update) {
 		return
 	}
 
-	_, err := url.ParseRequestURI(args[1])
+	if !isValidAndAllowedUrl(args[1]) {
-	if err != nil {
+		slog.Error("Provided text is not a valid URL", "text", args[1])
-		slog.Error("Provided URL is not valid", args[1])
 
 		_, _ = b.api.SendMessage(b.reply(update.Message, tu.Message(
 			chatID,
@@ -143,10 +210,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", err)
+		slog.Error("Cannot retrieve an article using extractor", "error", err)
 	}
 
-	llmReply, err := b.llm.Summarize(article.Text, llm.ModelMistralUncensored)
+	llmReply, err := b.llm.Summarize(article.Text, b.models.SummarizeModel)
 	if err != nil {
 		slog.Error("Cannot get reply from LLM connector")
 
@@ -158,17 +225,19 @@ func (b *Bot) summarizeHandler(bot *telego.Bot, update telego.Update) {
 		return
 	}
 
-	slog.Debug("Got completion. Going to send.", llmReply)
+	slog.Debug("Got completion. Going to send.", "llm-completion", llmReply)
 
 	message := tu.Message(
 		chatID,
-		llmReply,
+		b.escapeMarkdownV1Symbols(llmReply),
 	).WithParseMode("Markdown")
 
 	_, err = bot.SendMessage(b.reply(update.Message, message))
 
 	if err != nil {
-		slog.Error("Can't send reply message", err)
+		slog.Error("Can't send reply message", "error", err)
+
+		b.trySendReplyError(update.Message)
 	}
 }
 
@@ -184,10 +253,14 @@ 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"+
-			"/help - Show this help",
+			"/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",
 	)))
 	if err != nil {
-		slog.Error("Cannot send a message", err)
+		slog.Error("Cannot send a message", "error", err)
+
+		b.trySendReplyError(update.Message)
 	}
 }
 
@@ -204,21 +277,33 @@ 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", err)
+		slog.Error("Cannot send a message", "error", err)
+
+		b.trySendReplyError(update.Message)
 	}
 }
 
-func (b *Bot) reply(originalMessage *telego.Message, newMessage *telego.SendMessageParams) *telego.SendMessageParams {
+func (b *Bot) statsHandler(bot *telego.Bot, update telego.Update) {
-	return newMessage.WithReplyParameters(&telego.ReplyParameters{
+	slog.Info("/stats")
-		MessageID: originalMessage.MessageID,
-	})
-}
 
-func (b *Bot) sendTyping(chatId telego.ChatID) {
+	chatID := tu.ID(update.Message.Chat.ID)
-	slog.Info("Setting 'typing' chat action")
 
-	err := b.api.SendChatAction(tu.ChatAction(chatId, "typing"))
+	b.sendTyping(chatID)
+
+	_, err := bot.SendMessage(b.reply(update.Message, tu.Message(
+		chatID,
+		"Current bot stats:\r\n"+
+			"```json\r\n"+
+			b.stats.String()+"\r\n"+
+			"```",
+	)).WithParseMode("Markdown"))
 	if err != nil {
-		slog.Error("Cannot set chat action", err)
+		slog.Error("Cannot send a message", "error", err)
+
+		b.trySendReplyError(update.Message)
 	}
 }
+
+func (b *Bot) escapeMarkdownV1Symbols(input string) string {
+	return b.markdownV1Replacer.Replace(input)
+}

bot/helpers.go

@@ -0,0 +1,93 @@
+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
+}

bot/logger.go

@@ -0,0 +1,24 @@
+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))
+}

bot/message_history.go

@@ -0,0 +1,93 @@
+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()
+}

bot/middleware.go

@@ -0,0 +1,50 @@
+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)
+}

bot/models.go

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

bot/request_context.go

@@ -0,0 +1,68 @@
+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)
+}

extractor/extractor.go

@@ -3,6 +3,7 @@ package extractor
 import (
 	"errors"
 	"github.com/advancedlogic/GoOse"
+	"log/slog"
 )
 
 var (
@@ -28,12 +29,18 @@ 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,

llm/llm.go

@@ -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,17 +29,47 @@ func NewConnector(baseUrl string, token string) *LlmConnector {
 	}
 }
 
-func (l *LlmConnector) HandleSingleRequest(text string, model string) (string, error) {
+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."
+	}
+
 	req := openai.ChatCompletionRequest{
 		Model: model,
 		Messages: []openai.ChatCompletionMessage{
 			{
 				Role:    openai.ChatMessageRoleSystem,
-				Content: "You're a bot in the Telegram chat. You are replying to questions directed to you.",
+				Content: systemPrompt,
 			},
 		},
 	}
 
+	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,
@@ -47,15 +77,15 @@ func (l *LlmConnector) HandleSingleRequest(text string, model string) (string, e
 
 	resp, err := l.client.CreateChatCompletion(context.Background(), req)
 	if err != nil {
-		slog.Error("LLM back-end request failed", err)
+		slog.Error("llm: LLM back-end request failed", "error", err)
 
 		return "", ErrLlmBackendRequestFailed
 	}
 
-	slog.Debug("Received LLM back-end response", resp)
+	slog.Debug("llm: Received LLM back-end response", "response", resp)
 
 	if len(resp.Choices) < 1 {
-		slog.Error("LLM back-end reply has no choices")
+		slog.Error("llm: LLM back-end reply has no choices")
 
 		return "", ErrNoChoices
 	}
@@ -69,9 +99,11 @@ func (l *LlmConnector) Summarize(text string, model string) (string, error) {
 		Messages: []openai.ChatCompletionMessage{
 			{
 				Role: openai.ChatMessageRoleSystem,
-				Content: "You are a short digest editor. Summarize the text you received " +
+				Content: "You're a text shortener. Give a very brief summary of the main facts " +
-					"as a list of bullet points with most important facts from the text. " +
+					"point by point.  Format them as a list of bullet points each starting with \"-\". " +
-					"If possible, use the same language as the original text.",
+					"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.",
 			},
 		},
 	}
@@ -83,18 +115,56 @@ func (l *LlmConnector) Summarize(text string, model string) (string, error) {
 
 	resp, err := l.client.CreateChatCompletion(context.Background(), req)
 	if err != nil {
-		slog.Error("LLM back-end request failed", err)
+		slog.Error("llm: LLM back-end request failed", "error", err)
 
 		return "", ErrLlmBackendRequestFailed
 	}
 
-	slog.Debug("Received LLM back-end response", resp)
+	slog.Debug("llm: Received LLM back-end response", resp)
 
 	if len(resp.Choices) < 1 {
-		slog.Error("LLM back-end reply has no choices")
+		slog.Error("llm: 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> ")
+}

llm/request_context.go

@@ -0,0 +1,64 @@
+package llm
+
+type RequestContext struct {
+	Empty bool
+	User  UserContext
+	Chat  ChatContext
+}
+
+type UserContext struct {
+	Username  string
+	FirstName string
+	LastName  string
+	IsPremium bool
+}
+
+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. "
+	}
+
+	if c.Chat.Title != "" {
+		prompt += "\nChat 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"
+	}
+	if c.User.LastName != "" {
+		prompt += "Last name: \"" + c.User.LastName + "\"\n"
+	}
+	//if c.User.IsPremium {
+	//	prompt += "Telegram Premium subscription: active."
+	//}
+
+	return prompt
+}

main.go

@@ -12,25 +12,44 @@ import (
 )
 
 func main() {
-	ollamaToken := os.Getenv("OLLAMA_TOKEN")
+	apiToken := os.Getenv("OPENAI_API_TOKEN")
-	ollamaBaseUrl := os.Getenv("OLLAMA_BASE_URL")
+	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)
 
 	telegramToken := os.Getenv("TELEGRAM_TOKEN")
 
-	llmc := llm.NewConnector(ollamaBaseUrl, ollamaToken)
+	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")
+
 	ext := extractor.NewExtractor()
 
-	telegramApi, err := tg.NewBot(telegramToken, tg.WithDefaultLogger(false, true))
+	telegramApi, err := tg.NewBot(telegramToken, tg.WithLogger(bot.NewLogger("telego: ")))
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 
-	botService := bot.NewBot(telegramApi, llmc, ext)
+	botService := bot.NewBot(telegramApi, llmc, ext, models)
 
 	err = botService.Run()
 	if err != nil {
-		slog.Error("Running bot finished with an error", err)
+		slog.Error("Running bot finished with an error", "error", err)
 		os.Exit(1)
 	}
 }

stats/stats.go

@@ -0,0 +1,94 @@
+package stats
+
+import (
+	"encoding/json"
+	"sync"
+	"time"
+)
+
+type Stats struct {
+	mu sync.Mutex
+
+	RunningSince time.Time
+
+	GroupRequests   uint64
+	PrivateRequests uint64
+	InlineQueries   uint64
+
+	Mentions          uint64
+	SummarizeRequests uint64
+}
+
+func NewStats() *Stats {
+	return &Stats{
+		RunningSince: time.Now(),
+
+		GroupRequests:   0,
+		PrivateRequests: 0,
+		InlineQueries:   0,
+
+		Mentions:          0,
+		SummarizeRequests: 0,
+	}
+}
+
+func (s *Stats) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Uptime string `json:"uptime"`
+
+		GroupRequests   uint64 `json:"group_requests"`
+		PrivateRequests uint64 `json:"private_requests"`
+		InlineQueries   uint64 `json:"inline_queries"`
+
+		Mentions          uint64 `json:"mentions"`
+		SummarizeRequests uint64 `json:"summarize_requests"`
+	}{
+		Uptime: time.Now().Sub(s.RunningSince).String(),
+
+		GroupRequests:   s.GroupRequests,
+		PrivateRequests: s.PrivateRequests,
+		InlineQueries:   s.InlineQueries,
+
+		Mentions:          s.Mentions,
+		SummarizeRequests: s.SummarizeRequests,
+	})
+}
+
+func (s *Stats) String() string {
+	data, err := json.MarshalIndent(s, "", "  ")
+	if err != nil {
+		return "{\"error\": \"cannot serialize stats\"}"
+	}
+
+	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()
+	s.GroupRequests++
+}
+
+func (s *Stats) PrivateRequest() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.PrivateRequests++
+}
+
+func (s *Stats) Mention() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.Mentions++
+}
+
+func (s *Stats) SummarizeRequest() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.SummarizeRequests++
+}