Fetch Langfuse prompt for assistant instructions

jjmata · jjmata · commit 099b937a7048 · 2025-10-01T20:04:59.000+02:00
diff --git a/app/models/assistant.rb b/app/models/assistant.rb
@@ -1,18 +1,24 @@
 class Assistant
   include Provided, Configurable, Broadcastable
 
-  attr_reader :chat, :instructions
+  attr_reader :chat, :instructions, :instructions_prompt
 
   class << self
     def for_chat(chat)
       config = config_for(chat)
-      new(chat, instructions: config[:instructions], functions: config[:functions])
+      new(
+        chat,
+        instructions: config[:instructions],
+        instructions_prompt: config[:instructions_prompt],
+        functions: config[:functions]
+      )
     end
   end
 
-  def initialize(chat, instructions: nil, functions: [])
+  def initialize(chat, instructions: nil, instructions_prompt: nil, functions: [])
     @chat = chat
     @instructions = instructions
+    @instructions_prompt = instructions_prompt
     @functions = functions
   end
 
@@ -26,6 +32,7 @@ def respond_to(message)
     responder = Assistant::Responder.new(
       message: message,
       instructions: instructions,
+      instructions_prompt: instructions_prompt,
       function_tool_caller: function_tool_caller,
       llm: get_model_provider(message.ai_model)
     )
diff --git a/app/models/assistant/configurable.rb b/app/models/assistant/configurable.rb
@@ -6,8 +6,11 @@ def config_for(chat)
       preferred_currency = Money::Currency.new(chat.user.family.currency)
       preferred_date_format = chat.user.family.date_format
 
+      instructions_config = default_instructions(preferred_currency, preferred_date_format)
+
       {
-        instructions: default_instructions(preferred_currency, preferred_date_format),
+        instructions: instructions_config[:content],
+        instructions_prompt: instructions_config[:prompt],
         functions: default_functions
       }
     end
@@ -23,6 +26,60 @@ def default_functions
       end
 
       def default_instructions(preferred_currency, preferred_date_format)
+        langfuse_instructions = langfuse_default_instructions(preferred_currency, preferred_date_format)
+
+        if langfuse_instructions.present?
+          {
+            content: langfuse_instructions[:content],
+            prompt: langfuse_instructions
+          }
+        else
+          {
+            content: fallback_default_instructions(preferred_currency, preferred_date_format),
+            prompt: nil
+          }
+        end
+      end
+
+      def langfuse_default_instructions(preferred_currency, preferred_date_format)
+        return unless langfuse_client
+
+        prompt = langfuse_client.get_prompt("default_instructions")
+
+        compiled_prompt = prompt.compile(
+          preferred_currency_symbol: preferred_currency.symbol,
+          preferred_currency_iso_code: preferred_currency.iso_code,
+          preferred_currency_default_precision: preferred_currency.default_precision,
+          preferred_currency_default_format: preferred_currency.default_format,
+          preferred_currency_separator: preferred_currency.separator,
+          preferred_currency_delimiter: preferred_currency.delimiter,
+          preferred_date_format: preferred_date_format,
+          current_date: Date.current
+        )
+
+        content = case compiled_prompt
+                  when String
+                    compiled_prompt
+                  when Array
+                    compiled_prompt.filter_map { |message| message[:content] }.join("\n\n")
+                  else
+                    nil
+                  end
+
+        return if content.blank?
+
+        {
+          name: prompt.name,
+          version: prompt.version,
+          template: prompt.prompt,
+          content: content
+        }
+      rescue => e
+        Rails.logger.warn("Langfuse prompt retrieval failed: #{e.message}")
+        nil
+      end
+
+      def fallback_default_instructions(preferred_currency, preferred_date_format)
         <<~PROMPT
           ## Your identity
 
@@ -78,5 +135,14 @@ def default_instructions(preferred_currency, preferred_date_format)
             the data you're presenting represents and what context it is in (i.e. date range, account, etc.)
         PROMPT
       end
+
+      def langfuse_client
+        return unless ENV["LANGFUSE_PUBLIC_KEY"].present? && ENV["LANGFUSE_SECRET_KEY"].present?
+
+        @langfuse_client ||= Langfuse.new
+      rescue => e
+        Rails.logger.warn("Langfuse client initialization failed: #{e.message}")
+        nil
+      end
   end
 end
diff --git a/app/models/assistant/responder.rb b/app/models/assistant/responder.rb
@@ -1,9 +1,10 @@
 class Assistant::Responder
-  def initialize(message:, instructions:, function_tool_caller:, llm:)
+  def initialize(message:, instructions:, function_tool_caller:, llm:, instructions_prompt: nil)
     @message = message
     @instructions = instructions
     @function_tool_caller = function_tool_caller
     @llm = llm
+    @instructions_prompt = instructions_prompt
   end
 
   def on(event_name, &block)
@@ -31,7 +32,7 @@ def respond(previous_response_id: nil)
   end
 
   private
-    attr_reader :message, :instructions, :function_tool_caller, :llm
+    attr_reader :message, :instructions, :function_tool_caller, :llm, :instructions_prompt
 
     def handle_follow_up_response(response)
       streamer = proc do |chunk|
@@ -64,6 +65,7 @@ def get_llm_response(streamer:, function_results: [], previous_response_id: nil)
         message.content,
         model: message.ai_model,
         instructions: instructions,
+        instructions_prompt: instructions_prompt,
         functions: function_tool_caller.function_definitions,
         function_results: function_results,
         streamer: streamer,
diff --git a/app/models/provider/llm_concept.rb b/app/models/provider/llm_concept.rb
@@ -22,6 +22,7 @@ def chat_response(
     prompt,
     model:,
     instructions: nil,
+    instructions_prompt: nil,
     functions: [],
     function_results: [],
     streamer: nil,
diff --git a/app/models/provider/openai.rb b/app/models/provider/openai.rb
@@ -62,6 +62,7 @@ def chat_response(
     prompt,
     model:,
     instructions: nil,
+    instructions_prompt: nil,
     functions: [],
     function_results: [],
     streamer: nil,
@@ -112,6 +113,7 @@ def chat_response(
           model: model,
           input: input_payload,
           output: response.messages.map(&:output_text).join("\n"),
+          prompt: instructions_prompt,
           session_id: session_id,
           user_identifier: user_identifier
         )
@@ -123,6 +125,7 @@ def chat_response(
           model: model,
           input: input_payload,
           output: parsed.messages.map(&:output_text).join("\n"),
+          prompt: instructions_prompt,
           usage: raw_response["usage"],
           session_id: session_id,
           user_identifier: user_identifier
@@ -141,26 +144,41 @@ def langfuse_client
       @langfuse_client = Langfuse.new
     end
 
-    def log_langfuse_generation(name:, model:, input:, output:, usage: nil, session_id: nil, user_identifier: nil)
-      return unless langfuse_client
-
-      trace = langfuse_client.trace(
-        name: "openai.#{name}",
-        input: input,
-        session_id: session_id,
-        user_id: user_identifier
-      )
-      trace.generation(
-        name: name,
-        model: model,
-        input: input,
-        output: output,
-        usage: usage,
-        session_id: session_id,
-        user_id: user_identifier
-      )
-      trace.update(output: output)
-    rescue => e
-      Rails.logger.warn("Langfuse logging failed: #{e.message}")
+  def log_langfuse_generation(name:, model:, input:, output:, usage: nil, session_id: nil, user_identifier: nil, prompt: nil)
+    return unless langfuse_client
+
+    trace = langfuse_client.trace(
+      name: "openai.#{name}",
+      input: input,
+      session_id: session_id,
+      user_id: user_identifier
+    )
+    generation_options = {
+      name: name,
+      model: model,
+      input: input,
+      output: output,
+      usage: usage,
+      session_id: session_id,
+      user_id: user_identifier
+    }
+
+    if prompt.present?
+      generation_options[:version] = prompt[:version] if prompt[:version]
+      metadata = {
+        prompt: {
+          name: prompt[:name],
+          version: prompt[:version],
+          content: prompt[:content],
+          template: prompt[:template]
+        }.compact
+      }
+      generation_options[:metadata] = metadata
     end
+
+    trace.generation(**generation_options)
+    trace.update(output: output)
+  rescue => e
+    Rails.logger.warn("Langfuse logging failed: #{e.message}")
+  end
 end
