WIP: Use personas for summarization

Author: romanrizzi

app/models/ai_persona.rb

@@ -46,10 +46,10 @@ def self.persona_cache
 
   scope :ordered, -> { order("priority DESC, lower(name) ASC") }
 
-  def self.all_personas
+  def self.all_personas(only_enabled: true)
     persona_cache[:value] ||= AiPersona
       .ordered
-      .where(enabled: true)
+      .where(enabled: only_enabled)
       .all
       .limit(MAX_PERSONAS_PER_SITE)
       .map(&:class_instance)

config/locales/server.en.yml

@@ -303,6 +303,9 @@ en:
         web_artifact_creator:
           name: "Web Artifact Creator"
           description: "AI Bot specialized in creating interactive web artifacts"
+        summarization:
+          name: "Summarization"
+          description: "Default persona used to power AI summaries."
       topic_not_found: "Summary unavailable, topic not found!"
       summarizing: "Summarizing topic"
       searching: "Searching for: '%{query}'"

config/settings.yml

@@ -240,6 +240,11 @@ discourse_ai:
     type: enum
     enum: "DiscourseAi::Configuration::LlmEnumerator"
     validator: "DiscourseAi::Configuration::LlmValidator"
+  ai_summarization_persona:
+    default: "-11"
+    type: enum
+    enum: "DiscourseAi::Configuration::PersonaEnumerator"
+
   ai_pm_summarization_allowed_groups:
     type: group_list
     list_type: compact
@@ -248,6 +253,7 @@ discourse_ai:
     type: group_list
     list_type: compact
     default: "3|13" # 3: @staff, 13: @trust_level_3
+    hidden: true
   ai_summary_gists_enabled:
     default: false
     hidden: true

db/fixtures/personas/603_ai_personas.rb

@@ -8,10 +8,19 @@
     if persona_class == DiscourseAi::Personas::WebArtifactCreator
       # this is somewhat sensitive, so we default it to staff
       persona.allowed_group_ids = [Group::AUTO_GROUPS[:staff]]
+    elsif persona_class == DiscourseAi::Personas::Summarization
+      persona.allowed_group_ids =
+        DB
+          .query_single(
+            "SELECT value FROM site_settings WHERE name = :setting_name",
+            setting_name: "ai_custom_summarization_allowed_groups",
+          )
+          .first
+          &.split("|") || [Group::AUTO_GROUPS[:staff], Group::AUTO_GROUPS[:trust_level_3]]
     else
       persona.allowed_group_ids = [Group::AUTO_GROUPS[:trust_level_0]]
     end
-    persona.enabled = true
+    persona.enabled = persona_class != DiscourseAi::Personas::Summarization
     persona.priority = true if persona_class == DiscourseAi::Personas::General
   end
 
@@ -22,16 +31,16 @@
     persona_class.name + SecureRandom.hex,
   ]
   persona.name = DB.query_single(<<~SQL, names, id).first
-        SELECT guess_name
-        FROM (
-          SELECT unnest(Array[?]) AS guess_name
-          FROM (SELECT 1) as t
-        ) x
-        LEFT JOIN ai_personas ON ai_personas.name = x.guess_name AND ai_personas.id <> ?
-        WHERE ai_personas.id IS NULL
-        ORDER BY x.guess_name ASC
-        LIMIT 1
-      SQL
+          SELECT guess_name
+          FROM (
+            SELECT unnest(Array[?]) AS guess_name
+            FROM (SELECT 1) as t
+          ) x
+          LEFT JOIN ai_personas ON ai_personas.name = x.guess_name AND ai_personas.id <> ?
+          WHERE ai_personas.id IS NULL
+          ORDER BY x.guess_name ASC
+          LIMIT 1
+        SQL
 
   persona.description = persona_class.description
 

lib/configuration/persona_enumerator.rb

@@ -10,7 +10,9 @@ def self.valid_value?(val)
       end
 
       def self.values
-        AiPersona.all_personas.map { |persona| { name: persona.name, value: persona.id } }
+        AiPersona
+          .all_personas(only_enabled: false)
+          .map { |persona| { name: persona.name, value: persona.id } }
       end
     end
   end

lib/personas/bot.rb

@@ -67,6 +67,7 @@ def reply(context, &update_blk)
         llm_kwargs = { user: user }
         llm_kwargs[:temperature] = persona.temperature if persona.temperature
         llm_kwargs[:top_p] = persona.top_p if persona.top_p
+        llm_kwargs[:max_tokens] = context[:max_tokens] if context[:max_tokens].present?
 
         needs_newlines = false
         tools_ran = 0
@@ -84,7 +85,7 @@ def reply(context, &update_blk)
           result =
             current_llm.generate(
               prompt,
-              feature_name: "bot",
+              feature_name: context[:feature_name] || "bot",
               partial_tool_calls: allow_partial_tool_calls,
               output_thinking: true,
               **llm_kwargs,

lib/personas/persona.rb

@@ -44,6 +44,7 @@ def system_personas
             DiscourseHelper => -8,
             GithubHelper => -9,
             WebArtifactCreator => -10,
+            Summarization => -11,
           }
         end
 

lib/personas/summarization.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DiscourseAi
+  module Personas
+    class Summarization < Persona
+      def system_prompt
+        <<~PROMPT.strip
+          You are an advanced summarization bot that generates concise, coherent summaries of provided text.
+          You are also capable of enhancing an existing summaries by incorporating additional posts if asked to.
+
+          - Only include the summary, without any additional commentary.
+          - You understand and generate Discourse forum Markdown; including links, _italics_, **bold**.
+          - Maintain the original language of the text being summarized.
+          - Aim for summaries to be 400 words or less.
+          - Each post is formatted as "<POST_NUMBER>) <USERNAME> <MESSAGE>"
+          - Use the provided <BASE_TOPIC_URL> when building links.
+          - Cite specific noteworthy posts using the format [DESCRIPTION]({topic_url}/POST_NUMBER)
+          - Example: links to the 3rd and 6th posts by sam: sam ([#3]({topic_url}/3), [#6]({topic_url}/6))
+          - Example: link to the 6th post by jane: [agreed with]({topic_url}/6)
+          - Example: link to the 13th post by joe: [joe]({topic_url}/13)
+          - When formatting usernames either use @USERNMAE OR [USERNAME]({topic_url}/POST_NUMBER)
+        PROMPT
+      end
+    end
+  end
+end

lib/summarization.rb

@@ -3,14 +3,22 @@
 module DiscourseAi
   module Summarization
     def self.topic_summary(topic)
-      if SiteSetting.ai_summarization_model.present? && SiteSetting.ai_summarization_enabled
-        DiscourseAi::Summarization::FoldContent.new(
-          DiscourseAi::Completions::Llm.proxy(SiteSetting.ai_summarization_model),
-          DiscourseAi::Summarization::Strategies::TopicSummary.new(topic),
-        )
-      else
-        nil
+      return nil if (model = SiteSetting.ai_summarization_model).blank?
+      if (ai_persona = AiPersona.find_by(id: SiteSetting.ai_summarization_persona)).blank?
+        return nil
       end
+      return nil if !SiteSetting.ai_summarization_enabled
+
+      persona_class = ai_persona.class_instance
+      persona = persona_class.new
+      user = User.find_by(id: persona_class.user_id) || Discourse.system_user
+
+      bot = DiscourseAi::Personas::Bot.as(user, persona: persona, model: model)
+
+      DiscourseAi::Summarization::FoldContent.new(
+        bot,
+        DiscourseAi::Summarization::Strategies::TopicSummary.new(topic),
+      )
     end
 
     def self.topic_gist(topic)
@@ -25,15 +33,17 @@ def self.topic_gist(topic)
     end
 
     def self.chat_channel_summary(channel, time_window_in_hours)
-      if SiteSetting.ai_summarization_model.present? && SiteSetting.ai_summarization_enabled
-        DiscourseAi::Summarization::FoldContent.new(
-          DiscourseAi::Completions::Llm.proxy(SiteSetting.ai_summarization_model),
-          DiscourseAi::Summarization::Strategies::ChatMessages.new(channel, time_window_in_hours),
-          persist_summaries: false,
-        )
-      else
-        nil
-      end
+      return nil if model = SiteSetting.ai_summarization_model.present?
+      return nil if persona = AiPersona.find_by(id: SiteSetting.ai_summarization_persona)
+      return nil if !SiteSetting.ai_summarization_enabled
+
+      bot = DiscourseAi::Personas::Bot.as(Discourse.system_user, persona: persona, model: model)
+
+      DiscourseAi::Summarization::FoldContent.new(
+        bot,
+        DiscourseAi::Summarization::Strategies::ChatMessages.new(channel, time_window_in_hours),
+        persist_summaries: false,
+      )
     end
   end
 end

lib/summarization/fold_content.rb

@@ -9,13 +9,13 @@ module Summarization
     # into a final version.
     #
     class FoldContent
-      def initialize(llm, strategy, persist_summaries: true)
-        @llm = llm
+      def initialize(bot, strategy, persist_summaries: true)
+        @bot = bot
         @strategy = strategy
         @persist_summaries = persist_summaries
       end
 
-      attr_reader :llm, :strategy
+      attr_reader :bot, :strategy
 
       # @param user { User } - User object used for auditing usage.
       # @param &on_partial_blk { Block - Optional } - The passed block will get called with the LLM partial response alongside a cancel function.
@@ -76,7 +76,7 @@ def delete_cached_summaries!
       attr_reader :persist_summaries
 
       def llm_model
-        llm.llm_model
+        bot.llm.llm_model
       end
 
       def content_to_summarize
@@ -118,20 +118,29 @@ def fold(items, summary, cursor, user, &on_partial_blk)
           end
         end
 
-        prompt =
-          (
-            if summary.blank?
-              strategy.first_summary_prompt(iteration_content)
-            else
-              strategy.summary_extension_prompt(summary, iteration_content)
-            end
-          )
+        context = {
+          target_url: "#{Discourse.base_path}/t/-/#{strategy.target.id}",
+          skip_tool_details: true,
+          user: user,
+          feature_name: strategy.feature,
+        }
+        context[:conversation_context] = (
+          if summary.blank?
+            strategy.first_summary_messages(iteration_content)
+          else
+            strategy.summary_extension_messages(summary, iteration_content)
+          end
+        )
 
         if cursor == items.length
-          llm.generate(prompt, user: user, feature_name: strategy.feature, &on_partial_blk)
+          bot.reply(context, &text_only_update(&on_partial_blk))
         else
-          latest_summary =
-            llm.generate(prompt, user: user, max_tokens: 600, feature_name: strategy.feature)
+          context[:max_tokens] = 600
+
+          latest_summary = +""
+          update_blk = text_only_update(Proc.new { |partial, cancel| latest_summary << partial })
+          bot.reply(context, &update_blk)
+
           fold(items, latest_summary, cursor, user, &on_partial_blk)
         end
       end
@@ -159,6 +168,12 @@ def truncate(item)
 
         item
       end
+
+      def text_only_update(&on_partial_blk)
+        Proc.new do |partial, cancel, placeholder, type|
+          on_partial_blk.call(partial, cancel) if type.blank?
+        end
+      end
     end
   end
 end