smart_brain 0.1.2 → 0.2.0

data/lib/smart_brain/model_provider/openai.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require_relative 'base'
+
+module SmartBrain
+  module ModelProvider
+    # 通用 OpenAI 兼容 provider（覆盖 silicon_flow 等任意 /v1/chat/completions 端点）。
+    class OpenAI < Base
+      include Rerankable
+
+      def initialize(model:, base_url:, api_key:, rerank_model: nil, temperature: 0.2, timeout_seconds: 30, **_)
+        @model = model
+        @rerank_model = rerank_model || model
+        @temperature = temperature
+        @timeout_seconds = timeout_seconds
+        @api_key = api_key
+        @base_url = base_url.to_s.chomp('/')
+      end
+
+      def llm?
+        true
+      end
+
+      def enabled?
+        !@api_key.to_s.empty?
+      end
+
+      def complete(prompt:, system: nil, temperature: nil, max_tokens: nil)
+        messages = []
+        messages << { 'role' => 'system', 'content' => system } if system && !system.empty?
+        messages << { 'role' => 'user', 'content' => prompt }
+
+        body = { 'model' => @model, 'messages' => messages, 'temperature' => temperature || @temperature }
+        body['max_tokens'] = max_tokens if max_tokens
+
+        response = connection.post('/v1/chat/completions') do |req|
+          req.headers['Authorization'] = "Bearer #{@api_key}" unless @api_key.to_s.empty?
+          req.body = JSON.generate(body)
+        end
+        raise "openai HTTP #{response.status}: #{response.body[0, 200]}" unless response.status.between?(200, 299)
+
+        { text: strip_think(JSON.parse(response.body).dig('choices', 0, 'message', 'content').to_s) }
+      rescue StandardError => e
+        { text: '', error: "#{e.class}: #{e.message}" }
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: @base_url) do |f|
+          f.options.timeout = @timeout_seconds
+          f.options.open_timeout = @timeout_seconds
+          f.headers['Content-Type'] = 'application/json'
+        end
+      end
+    end
+  end
+end

data/lib/smart_brain/model_provider/stub.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module SmartBrain
+  module ModelProvider
+    # 确定性、零网络的默认 provider。不是真实 LLM：summary 走模板、merger 走词法。
+    class Stub < Base
+      def llm?
+        false
+      end
+
+      def enabled?
+        true
+      end
+
+      def complete(prompt:, system: nil, temperature: nil, max_tokens: nil)
+        { text: '' }
+      end
+
+      def rerank(query:, documents:)
+        documents.each_with_index.map { |_, i| { index: i, score: 1.0 - (i * 0.001) } }
+      end
+    end
+  end
+end

data/lib/smart_brain/model_provider.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'model_provider/base'
+require_relative 'model_provider/stub'
+require_relative 'model_provider/ollama'
+require_relative 'model_provider/openai'
+require_relative 'model_provider/factory'

data/lib/smart_brain/observability/tracker.rb

@@ -16,22 +16,60 @@ module SmartBrain
         commit_logs << payload
       end
 
+      def log_scope_promotion(payload)
+        scope_promotion_logs << payload
+      end
+
+      def log_scope_validation_failure(error)
+        scope_validation_failures << { error: error.message, created_at: Time.now.utc.iso8601 }
+      end
+
       def snapshot
         {
           compose_logs: compose_logs,
           commit_logs: commit_logs,
+          scope_promotion_logs: scope_promotion_logs,
+          scope_validation_failures: scope_validation_failures,
           metrics: {
             compose_p95_ms: p95(compose_logs.map { |l| l[:took_ms] }),
             memory_resource_ratio: memory_resource_ratio,
-            token_over_budget_rate: token_over_budget_rate
+            token_over_budget_rate: token_over_budget_rate,
+            scope_writes: scope_writes,
+            scope_recalls: scope_recalls,
+            shadowed_count: compose_logs.sum { |log| log[:shadowed_count].to_i },
+            scope_promotions: scope_promotion_logs.size,
+            scope_validation_failures: scope_validation_failures.size,
+            scope_filter_failures: compose_logs.sum { |log| Array(log[:scope_filter_warnings]).size }
           }
         }
       end
 
       private
 
+      def scope_promotion_logs
+        @scope_promotion_logs ||= []
+      end
+
+      def scope_validation_failures
+        @scope_validation_failures ||= []
+      end
+
       attr_reader :compose_logs, :commit_logs
 
+      def scope_writes
+        commit_logs.flat_map { |log| Array(log[:memory_items]) }.each_with_object(Hash.new(0)) do |item, counts|
+          ref = item[:scope]
+          counts[ref ? ref[:type] : 'unknown'] += 1
+        end
+      end
+
+      def scope_recalls
+        compose_logs.flat_map { |log| Array(log[:selected_evidence]) }.each_with_object(Hash.new(0)) do |item, counts|
+          ref = item[:scope]
+          counts[ref ? ref[:type] : 'unscoped'] += 1
+        end
+      end
+
       def p95(values)
         values = values.compact.sort
         return 0 if values.empty?

data/lib/smart_brain/retrievers/exact_retriever.rb

@@ -19,6 +19,12 @@ module SmartBrain
             snippet: item[:value_json].to_s,
             mode: 'exact',
             score: score + (item[:confidence] || 0.5),
+            tier: item[:tier] || 'evidence',
+            memory_type: item[:type],
+            memory_key: item[:key],
+            scope: item[:scope],
+            scope_id: item[:scope_id],
+            source_session_id: item[:source_session_id] || item[:session_id],
             ref: { memory_item_id: item[:id] }
           }
         end

data/lib/smart_brain/retrievers/memory_retriever.rb

@@ -12,19 +12,73 @@ module SmartBrain
         @relational = RelationalRetriever.new(config: config)
       end
 
-      def retrieve(query:, memory_items:, recent_turns:, entities:, refs:)
-        limit = config.composition.fetch(:evidence_max_items, 12)
-        exact_hits = exact.retrieve(query: query, memory_items: memory_items, recent_turns: recent_turns, limit: limit)
+      # Memory evidence is resolved by the store itself:
+      #   - MemoryStore::Postgres#search_memory → ts_rank-ranked FTS
+      #   - MemoryStore::InMemory#search_memory → ExactRetriever over active items
+      # Turn matching stays in-memory over the recent window (small), and
+      # relational matching (entities/refs) stays in-memory as before.
+      def retrieve(query:, memory_store:, session_id:, recent_turns:, entities:, refs:, scope_ids: nil, limit: nil)
+        limit ||= config.composition.fetch(:evidence_max_items, 12)
+        ids = Array(scope_ids).compact
+        memory_hits = if ids.empty?
+                        memory_store.search_memory(query: query, session_id: session_id, limit: limit)
+                      else
+                        ids.flat_map do |scope_id|
+                          memory_store.search_memory(query: query, scope_ids: [scope_id], limit: limit)
+                        end
+                      end
+        turn_hits = exact.retrieve(query: query, memory_items: [], recent_turns: recent_turns, limit: limit)
         relational_hits = relational.retrieve(query: query, entities: entities, refs: refs, limit: limit)
+        graph_hits = graph_evidence(
+          query: query, entities: entities, memory_store: memory_store, session_id: session_id, scope_ids: scope_ids
+        )
 
-        (exact_hits + relational_hits)
+        (memory_hits + turn_hits + relational_hits + graph_hits)
           .sort_by { |h| -h.fetch(:score, 0.0) }
-          .first(limit)
       end
 
       private
 
       attr_reader :config, :exact, :relational
+
+      # When an entity is mentioned in the query, pull its KG edges and surface
+      # the related objects as relational evidence (mode: 'graph'). Gated by
+      # config.kg.expand_retrieval (default true); no-op if the store has no
+      # kg_edges support.
+      def graph_evidence(query:, entities:, memory_store:, session_id:, scope_ids: nil)
+        return [] unless expand_retrieval?(memory_store)
+
+        terms = query.to_s.downcase
+        matched = entities.select { |e| terms.include?(e[:canonical].to_s.downcase) || terms.include?(e[:name].to_s.downcase) }
+        return [] if matched.empty?
+
+        matched.flat_map do |entity|
+          edges = memory_store.query_edges(session_id: session_id, scope_ids: scope_ids, subject: entity[:canonical])
+          edges.map do |edge|
+            {
+              id: "edge-#{edge[:id]}",
+              source: 'memory',
+              source_uri: "smartbrain://kg/#{edge[:id]}",
+              title: "#{edge[:subject]} #{edge[:predicate]} #{edge[:object]}",
+              snippet: "#{edge[:subject]} #{edge[:predicate]} #{edge[:object]}",
+              mode: 'graph',
+              score: (edge[:confidence] || 0.5) * 0.6,
+              tier: 'evidence',
+              scope: edge[:scope],
+              scope_id: edge[:scope_id],
+              source_session_id: edge[:source_session_id],
+              ref: { edge_id: edge[:id], subject_entity_id: edge[:subject_entity_id], object_entity_id: edge[:object_entity_id] }
+            }
+          end
+        end
+      rescue StandardError
+        []
+      end
+
+      def expand_retrieval?(memory_store)
+        memory_store.respond_to?(:query_edges) &&
+          (config.kg.fetch(:expand_retrieval, true) rescue true)
+      end
     end
   end
 end