smart_brain 0.1.2 → 0.2.0

data/lib/smart_brain/memory_store/postgres.rb

@@ -0,0 +1,500 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'time'
+require_relative '../governance/tiers'
+
+module SmartBrain
+  module MemoryStore
+    # Postgres-backed MemoryStore. Drop-in replacement for MemoryStore::InMemory
+    # that additionally:
+    #   - persists memory_items to Postgres (durable across restarts),
+    #   - writes memory_chunks with a `simple`-config TSVECTOR so FTS works,
+    #   - serves #search_memory via ts_rank-ranked full-text search,
+    #   - persists working summaries to the summaries table.
+    class Postgres
+      OVERWRITE_TYPES = %w[preferences goals tasks].freeze
+      # ts_rank is unbounded and typically tiny (~0.06); scale so FTS scores
+      # land in the same band as ExactRetriever's overlap+confidence scores.
+      RANK_SCALE = 8.0
+      # Match an ASCII word OR a single CJK character. The word class is ASCII-
+      # only on purpose: Ruby's [[:alnum:]] is Unicode-aware and would greedy-
+      # match a whole CJK run (默认存储) as one token, defeating per-character
+      # indexing. Splitting CJK into unigrams lets the 'simple' text-search
+      # config (whitespace-only splitter) match at character granularity:
+      # indexing 默认存储 as 默 认 存 储 lets a query for 存储 (存 储) hit.
+      TOKEN_RE = /[A-Za-z0-9_\-]+|[\p{Han}\p{Hiragana}\p{Katakana}\p{Hangul}]/.freeze
+
+      def initialize(db:, config:)
+        @db = db
+        @config = config
+      end
+
+      def upsert(extracted)
+        session_id = extracted.fetch(:session_id)
+        items = extracted.fetch(:items, [])
+        written = []
+        conflicts = []
+
+        db.transaction do
+          items.each do |item|
+            scope_id = item[:scope_id] || legacy_scope_id(session_id)
+            existing = active_item(scope_id: scope_id, type: item[:type], key: item[:key])
+
+            if existing && item[:status] == 'retracted'
+              db[:memory_items].where(id: existing[:id]).update(status: 'retracted', updated_at: Sequel::CURRENT_TIMESTAMP)
+              conflicts << { type: 'retract', key: item[:key], previous_memory_item_id: existing[:id] }
+              next
+            end
+
+            if existing && OVERWRITE_TYPES.include?(item[:type])
+              db[:memory_items].where(id: existing[:id]).update(status: 'superseded', updated_at: Sequel::CURRENT_TIMESTAMP)
+              conflicts << { type: 'overwrite', key: item[:key], previous_memory_item_id: existing[:id] }
+            end
+
+            record = persist_item(session_id: session_id, item: item.merge(scope_id: scope_id))
+            written << record.slice(:id, :type, :key, :status, :confidence, :scope_id, :scope, :source_session_id)
+          end
+        end
+
+        { count: written.size, items: written, conflicts: conflicts }
+      end
+
+      def active_items(session_id: nil, scope_ids: nil)
+        dataset = db[:memory_items]
+          .where(status: 'active', lifecycle_status: Governance::Tiers::CONTEXT_LIFECYCLE)
+          .order(:updated_at)
+        dataset = scope_filter(dataset, session_id, scope_ids)
+        dataset.map { |row| item_from_row(row) }
+      end
+
+      def entities(session_id: nil, scope_ids: nil)
+        dataset = scope_filter(db[:memory_items].where(type: 'entities', status: 'active'), session_id, scope_ids)
+        dataset.map do |row|
+          value = symbolize(row[:value_json])
+          canonical = value[:canonical] || value[:name]
+          scope = scope_ref(row[:scope_id])
+          {
+            id: row[:id],
+            name: value[:name] || canonical,
+            kind: value[:kind] || 'other',
+            canonical: canonical,
+            memory_item_id: row[:id],
+            scope_id: row[:scope_id],
+            scope: scope,
+            source_session_id: row[:source_session_id] || row[:session_id]
+          }
+        end
+      end
+
+      # Full-text search over memory_chunks (joined to active memory_items),
+      # ranked by ts_rank. Returns evidence hashes shaped like ExactRetriever's
+      # output so the fusion layer is unchanged.
+      #
+      # Query terms are OR'd (not AND'd): a CJK query like "数据库 持久化"
+      # tokenizes to 数 据 库 持 久 化, and we want any-matching docs recalled
+      # (ts_rank then favours docs matching more terms). AND semantics would
+      # drop a persistence decision just because it lacks the literal 数据库.
+      def search_memory(query:, session_id: nil, scope_ids: nil, limit:)
+        or_expr = or_tsquery_expression(query)
+        return [] if or_expr.empty?
+
+        fts = fts_config
+        ids = Array(scope_ids).compact
+        scope_clause = if ids.empty?
+                         'm.session_id = ?'
+                       else
+                         "m.scope_id IN (#{Array.new(ids.length, '?').join(', ')})"
+                       end
+        sql = <<~SQL
+          SELECT c.text, m.id AS item_id, m.type AS memory_type, m.key, m.value_json, m.confidence, m.tier,
+                 m.scope_id, m.source_session_id, ms.scope_type, ms.external_id,
+                 ts_rank(c.tsv, to_tsquery(?, ?)) AS rank
+          FROM memory_chunks c
+          JOIN memory_items m ON m.id = c.memory_item_id
+          JOIN memory_scopes ms ON ms.id = m.scope_id
+          WHERE #{scope_clause} AND m.status = 'active'
+            AND m.lifecycle_status IN ('raw', 'promoted')
+            AND c.tsv @@ to_tsquery(?, ?)
+          ORDER BY rank DESC
+          LIMIT ?
+        SQL
+
+        filter_values = ids.empty? ? [session_id] : ids
+        db.fetch(sql, fts, or_expr, *filter_values, fts, or_expr, limit).map do |row|
+          value = symbolize(row[:value_json])
+          confidence = row[:confidence].to_f
+          {
+            id: row[:item_id],
+            source: 'memory',
+            source_uri: "smartbrain://memory/#{row[:item_id]}",
+            title: row[:key],
+            snippet: flatten_value(value),
+            mode: 'fts',
+            score: (row[:rank].to_f * RANK_SCALE) + confidence,
+            tier: row[:tier] || 'evidence',
+            memory_type: row[:memory_type],
+            memory_key: row[:key],
+            scope_id: row[:scope_id],
+            scope: { type: row[:scope_type], id: row[:external_id] },
+            source_session_id: row[:source_session_id],
+            ref: { memory_item_id: row[:item_id] }
+          }
+        end
+      end
+
+      def save_summary(session_id:, summary:)
+        db[:summaries].insert_conflict(
+          target: :session_id,
+          update: {
+            summary_text: summary[:text].to_s,
+            summary_version: summary[:summary_version],
+            summary_source_turn_range: Sequel.pg_jsonb(symbolizable(summary[:summary_source_turn_range] || {})),
+            summary_generated_at: time_from(summary[:summary_generated_at])
+          }
+        ).insert(
+          session_id: session_id,
+          summary_text: summary[:text].to_s,
+          summary_version: summary[:summary_version],
+          summary_source_turn_range: Sequel.pg_jsonb(symbolizable(summary[:summary_source_turn_range] || {})),
+          summary_generated_at: time_from(summary[:summary_generated_at])
+        )
+        summary
+      end
+
+      def latest_summary(session_id:)
+        row = db[:summaries].where(session_id: session_id).first
+        return nil unless row
+
+        row_to_summary(row)
+      end
+
+      def all_summaries
+        db[:summaries].all.each_with_object({}) do |row, h|
+          h[row[:session_id]] = row_to_summary(row)
+        end
+      end
+
+      # --- knowledge lifecycle -------------------------------------------------
+      def create_item(session_id:, item:, scope_id: nil, scope: nil)
+        persist_item(session_id: session_id, item: item.merge(scope_id: scope_id, scope: scope).compact)
+      end
+
+      def find_item(id:)
+        row = db[:memory_items].where(id: id).first
+        row ? item_from_row(row) : nil
+      end
+
+      def set_lifecycle(id:, lifecycle_status:, merge_value: nil)
+        row = db[:memory_items].where(id: id).first
+        return nil unless row
+
+        updates = { lifecycle_status: lifecycle_status, updated_at: Time.now.utc }
+        if merge_value
+          merged = symbolize(row[:value_json]).merge(merge_value)
+          updates[:value_json] = Sequel.pg_jsonb(symbolizable(merged))
+        end
+        db[:memory_items].where(id: id).update(updates)
+        find_item(id: id)
+      end
+
+      def set_status(id:, status:, merge_value: nil)
+        row = db[:memory_items].where(id: id).first
+        return nil unless row
+
+        updates = { status: status, updated_at: Time.now.utc }
+        updates[:value_json] = Sequel.pg_jsonb(symbolizable(symbolize(row[:value_json]).merge(merge_value))) if merge_value
+        db[:memory_items].where(id: id).update(updates)
+        find_item(id: id)
+      end
+
+      def record_event(memory_item_id:, event_type:, from_lifecycle: nil, to_lifecycle: nil,
+                       reason: nil, reason_type: nil, reviewer: nil, evidence_refs: [])
+        id = SecureRandom.uuid
+        db[:knowledge_events].insert(
+          id: id,
+          memory_item_id: memory_item_id,
+          event_type: event_type,
+          from_lifecycle: from_lifecycle,
+          to_lifecycle: to_lifecycle,
+          reason: reason,
+          reason_type: reason_type,
+          reviewer: reviewer,
+          evidence_refs: Sequel.pg_jsonb(Array(evidence_refs)),
+          created_at: Time.now.utc
+        )
+        events_for(memory_item_id: memory_item_id).last
+      end
+
+      def events_for(memory_item_id:)
+        db[:knowledge_events].where(memory_item_id: memory_item_id).order(:created_at).map do |row|
+          {
+            id: row[:id],
+            memory_item_id: row[:memory_item_id],
+            event_type: row[:event_type],
+            from_lifecycle: row[:from_lifecycle],
+            to_lifecycle: row[:to_lifecycle],
+            reason: row[:reason],
+            reason_type: row[:reason_type],
+            reviewer: row[:reviewer],
+            evidence_refs: symbolize(row[:evidence_refs]),
+            created_at: iso8601(row[:created_at])
+          }
+        end
+      end
+
+      # --- knowledge graph -----------------------------------------------------
+      def add_edge(session_id:, edge:, scope_id: nil, scope: nil, source_session_id: nil)
+        resolved_scope_id = scope_id || edge[:scope_id] || legacy_scope_id(session_id)
+        id = SecureRandom.uuid
+        db[:kg_edges].insert(
+          id: id,
+          session_id: session_id,
+          source_session_id: source_session_id || edge[:source_session_id] || session_id,
+          scope_id: resolved_scope_id,
+          subject: edge[:subject].to_s,
+          predicate: edge[:predicate].to_s,
+          object: edge[:object].to_s,
+          subject_entity_id: resolve_entity_id(nil, edge[:subject], scope_ids: [resolved_scope_id]),
+          object_entity_id: resolve_entity_id(nil, edge[:object], scope_ids: [resolved_scope_id]),
+          valid_from: edge[:valid_from] ? time_from(edge[:valid_from]) : Time.now.utc,
+          valid_to: edge[:valid_to] ? time_from(edge[:valid_to]) : nil,
+          source_turn_id: edge[:source_turn_id],
+          source_memory_item_id: edge[:source_memory_item_id],
+          confidence: edge[:confidence] || 0.6,
+          status: edge[:status] || 'active',
+          meta_json: Sequel.pg_jsonb(symbolizable(edge[:meta] || {})),
+          created_at: Time.now.utc
+        )
+        find_edge(id: id)
+      end
+
+      def query_edges(session_id: nil, scope_ids: nil, subject: nil, predicate: nil, object: nil, include_invalid: false)
+        ds = scope_filter(db[:kg_edges], session_id, scope_ids)
+        ds = ds.where(status: 'active') unless include_invalid
+        ds = ds.where(Sequel.ilike(:subject, subject.to_s)) if subject
+        ds = ds.where(Sequel.ilike(:predicate, predicate.to_s)) if predicate
+        ds = ds.where(Sequel.ilike(:object, object.to_s)) if object
+        ds.order(:valid_from).map { |row| edge_from_row(row) }
+      end
+
+      def edges_for_subject(session_id: nil, scope_ids: nil, subject:)
+        scope_filter(db[:kg_edges], session_id, scope_ids)
+          .where(Sequel.ilike(:subject, subject.to_s))
+          .order(:valid_from).map { |row| edge_from_row(row) }
+      end
+
+      def invalidate_edge(id:, reason: nil)
+        edge = find_edge(id: id)
+        return nil unless edge
+
+        meta = (edge[:meta] || {}).merge(invalidated_reason: reason)
+        db[:kg_edges].where(id: id).update(
+          valid_to: Time.now.utc,
+          status: 'invalidated',
+          meta_json: Sequel.pg_jsonb(symbolizable(meta))
+        )
+        find_edge(id: id)
+      end
+
+      def edge_stats(session_id: nil, scope_ids: nil)
+        scoped = scope_filter(db[:kg_edges], session_id, scope_ids)
+        {
+          total: scoped.count,
+          active: scoped.where(status: 'active').count,
+          invalidated: scoped.where(status: 'invalidated').count
+        }
+      end
+
+      def find_edge(id:)
+        row = db[:kg_edges].where(id: id).first
+        row ? edge_from_row(row) : nil
+      end
+
+      def resolve_entity_id(session_id, name, scope_ids: nil)
+        return nil if name.nil? || name.to_s.empty?
+
+        match = entities(session_id: session_id, scope_ids: scope_ids).find do |e|
+          e[:canonical].to_s.downcase == name.to_s.downcase ||
+            e[:name].to_s.downcase == name.to_s.downcase
+        end
+        match && match[:id]
+      end
+
+      def edge_from_row(row)
+        {
+          id: row[:id],
+          session_id: row[:session_id],
+          source_session_id: row[:source_session_id] || row[:session_id],
+          scope_id: row[:scope_id],
+          scope: scope_ref(row[:scope_id]),
+          subject: row[:subject],
+          predicate: row[:predicate],
+          object: row[:object],
+          subject_entity_id: row[:subject_entity_id],
+          object_entity_id: row[:object_entity_id],
+          valid_from: iso8601(row[:valid_from]),
+          valid_to: row[:valid_to] ? iso8601(row[:valid_to]) : nil,
+          source_turn_id: row[:source_turn_id],
+          source_memory_item_id: row[:source_memory_item_id],
+          confidence: row[:confidence].to_f,
+          status: row[:status],
+          meta: symbolize(row[:meta_json]),
+          created_at: iso8601(row[:created_at])
+        }
+      end
+
+      private
+
+      attr_reader :db, :config
+
+      def active_item(scope_id:, type:, key:)
+        db[:memory_items].where(scope_id: scope_id, type: type, key: key, status: 'active').first
+      end
+
+      def persist_item(session_id:, item:)
+        id = SecureRandom.uuid
+        value_json = item[:value_json] || {}
+        now = Time.now.utc
+        resolved_scope_id = item[:scope_id] || legacy_scope_id(session_id)
+        db[:memory_items].insert(
+          id: id,
+          session_id: session_id,
+          source_session_id: item[:source_session_id] || session_id,
+          scope_id: resolved_scope_id,
+          type: item[:type],
+          key: item[:key],
+          value_json: Sequel.pg_jsonb(symbolizable(value_json)),
+          confidence: item[:confidence] || 0.6,
+          status: item[:status] || 'active',
+          tier: item[:tier] || Governance::Tiers.tier_for(item[:type]),
+          lifecycle_status: item[:lifecycle_status] || 'raw',
+          source_turn_id: item[:source_turn_id],
+          source_message_id: item[:source_message_id],
+          evidence_refs: Sequel.pg_jsonb([]),
+          updated_at: now
+        )
+        write_chunks(id, item[:key], value_json)
+        item.merge(id: id, session_id: session_id, source_session_id: item[:source_session_id] || session_id,
+                   scope_id: resolved_scope_id, scope: item[:scope] || scope_ref(resolved_scope_id),
+                   status: item[:status] || 'active', confidence: item[:confidence] || 0.6,
+                   tier: item[:tier] || Governance::Tiers.tier_for(item[:type]), lifecycle_status: item[:lifecycle_status] || 'raw')
+      end
+
+      def write_chunks(item_id, key, value_json)
+        raw = "#{key} #{flatten_value(value_json)}".strip
+        tokenized = tokenize_for_fts(raw)
+        chunk_text = tokenized.empty? ? raw : "#{tokenized}\n#{raw}"
+        fts = fts_config
+        db[:memory_chunks].insert(
+          id: SecureRandom.uuid,
+          memory_item_id: item_id,
+          text: chunk_text,
+          tsv: Sequel.lit("to_tsvector(?, ?)", fts, chunk_text),
+          meta_json: Sequel.pg_jsonb({})
+        )
+      end
+
+      def item_from_row(row)
+        {
+          id: row[:id],
+          session_id: row[:session_id],
+          source_session_id: row[:source_session_id] || row[:session_id],
+          scope_id: row[:scope_id],
+          scope: scope_ref(row[:scope_id]),
+          type: row[:type],
+          key: row[:key],
+          value_json: symbolize(row[:value_json]),
+          confidence: row[:confidence].to_f,
+          status: row[:status],
+          tier: row[:tier] || 'evidence',
+          lifecycle_status: row[:lifecycle_status] || 'raw',
+          source_turn_id: row[:source_turn_id],
+          source_message_id: row[:source_message_id],
+          evidence_refs: [],
+          updated_at: iso8601(row[:updated_at])
+        }
+      end
+
+      def scope_filter(dataset, session_id, scope_ids)
+        ids = Array(scope_ids).compact
+        ids.empty? ? dataset.where(session_id: session_id) : dataset.where(scope_id: ids)
+      end
+
+      def scope_ref(scope_id)
+        row = db[:memory_scopes].where(id: scope_id).first
+        row ? { type: row[:scope_type], id: row[:external_id] } : nil
+      end
+
+      def legacy_scope_id(session_id)
+        session = db[:sessions].where(id: session_id.to_s).first
+        row = session && db[:memory_scopes].where(
+          domain_id: session[:domain_id], scope_type: 'session', external_id: session_id.to_s
+        ).first
+        raise ArgumentError, "session scope not registered: #{session_id}" unless row
+
+        row[:id]
+      end
+
+      def fts_config
+        cfg = config&.fts_config || 'simple'
+        cfg = 'simple' unless cfg.to_s =~ /\A[a-z_]+\z/
+        cfg
+      end
+
+      def row_to_summary(row)
+        {
+          summary_version: row[:summary_version],
+          summary_source_turn_range: symbolize(row[:summary_source_turn_range]),
+          summary_generated_at: iso8601(row[:summary_generated_at]),
+          text: row[:summary_text],
+          triggered: true,
+          trigger_reason: 'persisted'
+        }
+      end
+
+      # Space-joined tokens so CJK matches under the 'simple' text-search config
+      # (which only splits on whitespace). Same regex as ExactRetriever#tokenize.
+      def tokenize_for_fts(text)
+        text.to_s.downcase.scan(TOKEN_RE).uniq.join(' ')
+      end
+
+      # Build an OR tsquery expression ("a | b | c") from query tokens, with each
+      # token stripped to tsquery-safe characters. Empty if no usable tokens.
+      def or_tsquery_expression(query)
+        query.to_s.downcase.scan(TOKEN_RE).uniq.map do |token|
+          token.gsub(/[^A-Za-z0-9_\p{Han}]/, '')
+        end.reject(&:empty?).join(' | ')
+      end
+
+      def flatten_value(value)
+        case value
+        when Hash then value.values.map { |v| flatten_value(v) }.join(' ')
+        when Array then value.map { |v| flatten_value(v) }.join(' ')
+        else value.to_s
+        end
+      end
+
+      def time_from(value)
+        case value
+        when Time then value
+        when String then Time.parse(value)
+        else Time.now.utc
+        end
+      end
+
+      def iso8601(value)
+        time = value.is_a?(Time) ? value : (value.nil? ? Time.now.utc : Time.parse(value.to_s))
+        time.iso8601
+      end
+
+      def symbolizable(obj)
+        SmartBrain::DB.stringify_keys(obj)
+      end
+
+      def symbolize(obj)
+        SmartBrain::DB.symbolize_jsonb(obj)
+      end
+    end
+  end
+end

data/lib/smart_brain/model_provider/base.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module SmartBrain
+  # ModelProvider 兑现 smartbrain_design.md §9：planner/extractor/summary/rerank 的本地模型调用。
+  # 默认 Stub（确定性、零网络）；可切 Ollama / OpenAI 兼容 provider 走真实 LLM。
+  module ModelProvider
+    class Base
+      # 真实 LLM 能力（决定 summary 是否走真摘要、merger 是否走 LLM rerank）。
+      def llm?
+        raise NotImplementedError
+      end
+
+      # provider 可用（Stub 永远可用，只是非 LLM）。
+      def enabled?
+        raise NotImplementedError
+      end
+
+      # => { text: String, error?: String }
+      def complete(prompt:, system: nil, temperature: nil, max_tokens: nil)
+        raise NotImplementedError
+      end
+
+      # => [{ index: Integer, score: Float }] 与 documents 等长、按相关性降序
+      def rerank(query:, documents:)
+        raise NotImplementedError
+      end
+
+      private
+
+      # Strip reasoning blocks emitted by chain-of-thought models (qwen3,
+      # deepseek-r1, ...). Keeps downstream parsing (rerank JSON) and summary
+      # text clean. Handles both closed <think>...</think> and an unterminated
+      # trailing <think> (truncated mid-thought).
+      def strip_think(text)
+        cleaned = text.to_s.gsub(/<think>.*?<\/think>/m, '')
+        cleaned = cleaned.sub(/<think>.*/m, '') if cleaned.include?('<think>')
+        cleaned.strip
+      end
+    end
+
+    # LLM-as-judge rerank：让 complete 模型对候选批量排序。混入有 #complete 的 provider。
+    module Rerankable
+      def rerank(query:, documents:)
+        return documents.each_with_index.map { |_, i| { index: i, score: 1.0 } } if documents.empty?
+
+        list = documents.each_with_index.map { |d, i| "[#{i}] #{truncate(d)}" }.join("\n")
+        prompt = "Rank the following passages by relevance to the query. " \
+                 "Reply with ONLY a JSON array of integer indices, most relevant first, no prose.\n" \
+                 "Query: #{query}\nPassages:\n#{list}"
+        result = complete(prompt: prompt, temperature: 0.0, max_tokens: 240)
+        order = parse_ranking(result[:text], documents.size)
+        n = [documents.size, 1].max
+        order.map.with_index { |idx, pos| { index: idx, score: (n - pos).to_f / n } }
+      rescue StandardError
+        documents.each_with_index.map { |_, i| { index: i, score: 1.0 } }
+      end
+
+      private
+
+      def truncate(text, limit = 300)
+        t = text.to_s.gsub(/\s+/, ' ').strip
+        t.length > limit ? "#{t[0, limit]}..." : t
+      end
+
+      # 从模型输出里抽出索引顺序：优先 JSON 数组，退而求其次抓所有整数。
+      def parse_ranking(text, size)
+        if (match = text.to_s.match(/\[[\d\s,]+\]/))
+          arr = JSON.parse(match[0])
+          return sanitize_order(arr.map(&:to_i), size)
+        end
+
+        sanitize_order(text.to_s.scan(/-?\d+/).map(&:to_i), size)
+      rescue JSON::ParserError
+        sanitize_order(text.to_s.scan(/-?\d+/).map(&:to_i), size)
+      end
+
+      def sanitize_order(indices, size)
+        seen = []
+        indices.each { |i| seen << i if i.between?(0, size - 1) && !seen.include?(i) }
+        (0...size).each { |i| seen << i unless seen.include?(i) }
+        seen
+      end
+    end
+  end
+end

data/lib/smart_brain/model_provider/factory.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'stub'
+require_relative 'ollama'
+require_relative 'openai'
+
+module SmartBrain
+  module ModelProvider
+    module Factory
+      module_function
+
+      # 按 config.llm_provider（stub|ollama|openai）构造 provider。
+      def build(config)
+        cfg = config.respond_to?(:llm) ? config.llm : (config.fetch(:model_provider, {}))
+        provider = (config.respond_to?(:llm_provider) ? config.llm_provider : cfg.fetch(:provider, 'stub')).to_s
+
+        case provider
+        when 'ollama'
+          Ollama.new(
+            model: cfg[:model] || 'qwen3',
+            base_url: ENV.fetch('SMARTBRAIN_LLM_BASE_URL', cfg[:base_url] || 'http://localhost:11434'),
+            rerank_model: cfg[:rerank_model],
+            temperature: cfg[:temperature] || 0.2,
+            timeout_seconds: cfg[:timeout_seconds] || 30,
+            think: cfg.fetch(:think, false)
+          )
+        when 'openai'
+          OpenAI.new(
+            model: cfg[:model] || 'qwen3',
+            base_url: ENV.fetch('SMARTBRAIN_LLM_BASE_URL', cfg[:base_url] || 'http://localhost:11434'),
+            api_key: ENV.fetch('SMARTBRAIN_LLM_API_KEY', cfg[:api_key] || ''),
+            rerank_model: cfg[:rerank_model],
+            temperature: cfg[:temperature] || 0.2,
+            timeout_seconds: cfg[:timeout_seconds] || 30
+          )
+        else
+          Stub.new
+        end
+      end
+    end
+
+    module_function
+
+    def build(config)
+      Factory.build(config)
+    end
+  end
+end

data/lib/smart_brain/model_provider/ollama.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require_relative 'base'
+
+module SmartBrain
+  module ModelProvider
+    # Ollama 本地 provider（OpenAI 兼容）。complete 走 /api/chat；rerank 走 LLM-as-judge。
+    class Ollama < Base
+      include Rerankable
+
+      def initialize(model:, base_url:, rerank_model: nil, temperature: 0.2, timeout_seconds: 30, think: false, **_)
+        @model = model
+        @rerank_model = rerank_model || model
+        @temperature = temperature
+        @timeout_seconds = timeout_seconds
+        @think = think
+        @base_url = base_url.to_s.chomp('/')
+      end
+
+      def llm?
+        true
+      end
+
+      def enabled?
+        true
+      end
+
+      def complete(prompt:, system: nil, temperature: nil, max_tokens: nil, think: nil)
+        messages = []
+        messages << { 'role' => 'system', 'content' => system } if system && !system.empty?
+        messages << { 'role' => 'user', 'content' => prompt }
+
+        body = { 'model' => @model, 'messages' => messages, 'stream' => false }
+        body['think'] = think.nil? ? @think : think
+        options = { 'temperature' => temperature || @temperature }
+        options['num_predict'] = max_tokens if max_tokens
+        body['options'] = options
+
+        response = connection.post('/api/chat', JSON.generate(body))
+        raise "ollama HTTP #{response.status}" unless response.status.between?(200, 299)
+
+        { text: strip_think(JSON.parse(response.body).dig('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