claude_memory 0.7.1 → 0.9.0

data/lib/claude_memory/commands/stats_command.rb

@@ -13,15 +13,21 @@ module ClaudeMemory
       SCOPE_PROJECT = "project"
 
       def call(args)
-        opts = parse_options(args, {scope: SCOPE_ALL}) do |o|
+        opts = parse_options(args, {scope: SCOPE_ALL, tools: false, since_days: nil}) do |o|
           OptionParser.new do |parser|
             parser.banner = "Usage: claude-memory stats [options]"
             parser.on("--scope SCOPE", ["all", "global", "project"],
               "Show stats for: all (default), global, or project") { |v| o[:scope] = v }
+            parser.on("--tools", "Show MCP tool-call usage stats") { o[:tools] = true }
+            parser.on("--since DAYS", Integer, "Limit --tools to last N days") { |v| o[:since_days] = v }
           end
         end
         return 1 if opts.nil?
 
+        if opts[:tools]
+          return print_mcp_tool_call_stats(opts[:since_days])
+        end
+
         manager = ClaudeMemory::Store::StoreManager.new
 
         stdout.puts "ClaudeMemory Statistics"
@@ -42,6 +48,10 @@ module ClaudeMemory
 
       private
 
+      def open_readonly(db_path)
+        Sequel.connect("extralite://#{db_path}")
+      end
+
       def print_database_stats(label, db_path)
         stdout.puts "## #{label} DATABASE"
         stdout.puts
@@ -53,7 +63,7 @@ module ClaudeMemory
         end
 
         begin
-          db = Sequel.sqlite(db_path, readonly: true)
+          db = open_readonly(db_path)
 
           # Facts statistics
           print_fact_stats(db)
@@ -245,6 +255,92 @@ module ClaudeMemory
         # Format number with comma separators (e.g., 1234567 => "1,234,567")
         num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
       end
+
+      def print_mcp_tool_call_stats(since_days)
+        manager = ClaudeMemory::Store::StoreManager.new
+        db_path = manager.project_db_path
+
+        stdout.puts "MCP Tool Call Statistics"
+        stdout.puts "=" * 50
+
+        unless File.exist?(db_path)
+          stdout.puts "Project database does not exist: #{db_path}"
+          manager.close
+          return 0
+        end
+
+        db = open_readonly(db_path)
+
+        unless db.table_exists?(:mcp_tool_calls)
+          stdout.puts "No telemetry recorded yet (run MCP server first)."
+          db.disconnect
+          manager.close
+          return 0
+        end
+
+        dataset = db[:mcp_tool_calls]
+        if since_days
+          cutoff = (Time.now - since_days * 86400).utc.iso8601
+          dataset = dataset.where { called_at >= cutoff }
+          stdout.puts "Window: last #{since_days} day#{"s" unless since_days == 1}"
+        else
+          stdout.puts "Window: all time"
+        end
+        stdout.puts
+
+        total = dataset.count
+        if total.zero?
+          stdout.puts "No tool calls recorded in window."
+          db.disconnect
+          manager.close
+          return 0
+        end
+
+        errors = dataset.exclude(error_class: nil).count
+        error_rate = (errors * 100.0 / total).round(1)
+        stdout.puts "Total calls: #{format_number(total)}"
+        stdout.puts "Errors: #{format_number(errors)} (#{error_rate}%)"
+        stdout.puts
+
+        print_per_tool_breakdown(dataset)
+
+        db.disconnect
+        manager.close
+        0
+      rescue Sequel::DatabaseError, Extralite::Error => e
+        stderr.puts "Error reading telemetry: #{e.message}"
+        1
+      end
+
+      def print_per_tool_breakdown(dataset)
+        stdout.puts "Per-tool breakdown:"
+        stdout.puts "  #{"Tool".ljust(28)} #{"Calls".rjust(7)}  #{"Avg ms".rjust(8)}  #{"P95 ms".rjust(8)}  #{"Err %".rjust(6)}"
+
+        rows = dataset
+          .group_and_count(:tool_name)
+          .order(Sequel.desc(:count))
+          .all
+
+        rows.each do |row|
+          tool = row[:tool_name]
+          calls = row[:count]
+          durations = dataset.where(tool_name: tool).select_map(:duration_ms).sort
+          avg = (durations.sum.to_f / calls).round(1)
+          p95 = percentile(durations, 0.95)
+          tool_errors = dataset.where(tool_name: tool).exclude(error_class: nil).count
+          tool_err_rate = (tool_errors * 100.0 / calls).round(1)
+
+          stdout.puts "  #{tool.to_s.ljust(28)} #{calls.to_s.rjust(7)}  #{avg.to_s.rjust(8)}  #{p95.to_s.rjust(8)}  #{tool_err_rate.to_s.rjust(6)}"
+        end
+      end
+
+      def percentile(sorted, pct)
+        return 0 if sorted.empty?
+        idx = (sorted.size * pct).ceil - 1
+        idx = 0 if idx < 0
+        idx = sorted.size - 1 if idx >= sorted.size
+        sorted[idx]
+      end
     end
   end
 end

data/lib/claude_memory/configuration.rb

@@ -8,31 +8,44 @@ module ClaudeMemory
   class Configuration
     attr_reader :env
 
+    # @param env [Hash] environment variables (default: ENV)
     def initialize(env = ENV)
       @env = env
     end
 
+    # @return [String] user home directory
     def home_dir
       env["HOME"] || File.expand_path("~")
     end
 
+    # @return [String] project root directory (resolves git worktrees)
     def project_dir
       env["CLAUDE_PROJECT_DIR"] || resolve_project_dir
     end
 
+    # @return [String] Claude config directory (default: ~/.claude)
+    def claude_config_dir
+      env["CLAUDE_CONFIG_DIR"] || File.join(home_dir, ".claude")
+    end
+
+    # @return [String] path to global memory database
     def global_db_path
-      File.join(home_dir, ".claude", "memory.sqlite3")
+      File.join(claude_config_dir, "memory.sqlite3")
     end
 
+    # @param project_path [String, nil] override project root (defaults to project_dir)
+    # @return [String] path to project memory database
     def project_db_path(project_path = nil)
       path = project_path || project_dir
       File.join(path, ".claude", "memory.sqlite3")
     end
 
+    # @return [String, nil] current Claude session ID from CLAUDE_SESSION_ID
     def session_id
       env["CLAUDE_SESSION_ID"]
     end
 
+    # @return [String, nil] path to current transcript from CLAUDE_TRANSCRIPT_PATH
     def transcript_path
       env["CLAUDE_TRANSCRIPT_PATH"]
     end

data/lib/claude_memory/core/fact_ranker.rb

@@ -88,8 +88,8 @@ module ClaudeMemory
       # @param text_results [Array<Hash>] Results from text search with :fact and :similarity
       # @param limit [Integer] Maximum results to return
       # @return [Array<Hash>] Merged results sorted by RRF score descending
-      def self.merge_search_results(vector_results, text_results, limit)
-        RRFusion.fuse(vector_results, text_results, limit)
+      def self.merge_search_results(vector_results, text_results, limit, explain: false)
+        RRFusion.fuse(vector_results, text_results, limit, explain: explain)
       end
     end
   end

data/lib/claude_memory/core/rr_fusion.rb

@@ -22,16 +22,23 @@ module ClaudeMemory
       # @param vector_weight [Float] Weight multiplier for vector rankings (default 1.0)
       # @param text_weight [Float] Weight multiplier for text rankings (default 1.0)
       # @return [Array<Hash>] Fused results sorted by RRF score, with :similarity set to RRF score
-      def self.fuse(vector_results, text_results, limit, vector_weight: 1.0, text_weight: 1.0)
+      def self.fuse(vector_results, text_results, limit, vector_weight: 1.0, text_weight: 1.0, explain: false)
         scores = {}
+        traces = {} if explain
         fact_data = {}
 
         # Score vector results by rank position
         vector_results.each_with_index do |result, idx|
           fact_id = result[:fact][:id]
           rank = idx + 1 # 1-based rank
-          scores[fact_id] = (scores[fact_id] || 0.0) + (vector_weight / (K + rank))
-          scores[fact_id] += TOP_BONUS.fetch(rank, 0.0)
+          contribution = (vector_weight / (K + rank)) + TOP_BONUS.fetch(rank, 0.0)
+          scores[fact_id] = (scores[fact_id] || 0.0) + contribution
+          if explain
+            traces[fact_id] ||= {vec_rank: nil, vec_score: nil, fts_rank: nil, fts_score: nil, vec_rrf: nil, fts_rrf: nil}
+            traces[fact_id][:vec_rank] = rank
+            traces[fact_id][:vec_score] = result[:similarity]
+            traces[fact_id][:vec_rrf] = contribution.round(6)
+          end
           # Prefer vector result data (has real similarity score)
           fact_data[fact_id] = result
         end
@@ -40,8 +47,14 @@ module ClaudeMemory
         text_results.each_with_index do |result, idx|
           fact_id = result[:fact][:id]
           rank = idx + 1
-          scores[fact_id] = (scores[fact_id] || 0.0) + (text_weight / (K + rank))
-          scores[fact_id] += TOP_BONUS.fetch(rank, 0.0)
+          contribution = (text_weight / (K + rank)) + TOP_BONUS.fetch(rank, 0.0)
+          scores[fact_id] = (scores[fact_id] || 0.0) + contribution
+          if explain
+            traces[fact_id] ||= {vec_rank: nil, vec_score: nil, fts_rank: nil, fts_score: nil, vec_rrf: nil, fts_rrf: nil}
+            traces[fact_id][:fts_rank] = rank
+            traces[fact_id][:fts_score] = result[:similarity]
+            traces[fact_id][:fts_rrf] = contribution.round(6)
+          end
           # Only use text data if not already present from vector
           fact_data[fact_id] ||= result
         end
@@ -50,7 +63,11 @@ module ClaudeMemory
         scores
           .sort_by { |_id, score| -score }
           .take(limit)
-          .map { |fact_id, score| fact_data[fact_id].merge(similarity: score) }
+          .map do |fact_id, score|
+            merged = fact_data[fact_id].merge(similarity: score)
+            merged[:score_trace] = traces[fact_id].merge(rrf_final: score.round(6)) if explain
+            merged
+          end
       end
     end
   end

data/lib/claude_memory/core/snippet_extractor.rb

@@ -32,8 +32,7 @@ module ClaudeMemory
 
         lines = parsed[:lines]
         best_line_idx = parsed[:best_line_idx]
-        start_idx = [best_line_idx - CONTEXT_BEFORE, 0].max
-        end_idx = [best_line_idx + CONTEXT_AFTER, lines.size - 1].min
+        start_idx, end_idx = snippet_range(lines, best_line_idx)
 
         {
           snippet: build_snippet(lines, best_line_idx),
@@ -81,10 +80,15 @@ module ClaudeMemory
       end
 
       # @api private
-      def self.build_snippet(lines, center_idx)
+      def self.snippet_range(lines, center_idx)
         start_idx = [center_idx - CONTEXT_BEFORE, 0].max
         end_idx = [center_idx + CONTEXT_AFTER, lines.size - 1].min
+        [start_idx, end_idx]
+      end
 
+      # @api private
+      def self.build_snippet(lines, center_idx)
+        start_idx, end_idx = snippet_range(lines, center_idx)
         snippet = lines[start_idx..end_idx].join("\n")
         truncate(snippet)
       end

data/lib/claude_memory/core/text_builder.rb

@@ -18,6 +18,17 @@ module ClaudeMemory
         parts.join(" ").strip
       end
 
+      # Truncate text to a maximum length with a suffix
+      # @param text [String, nil] Text to truncate
+      # @param max_length [Integer] Maximum length before truncation
+      # @param suffix [String] Suffix to append when truncated
+      # @return [String] Truncated text or original if within limit
+      def self.truncate(text, max_length, suffix: "...")
+        return "" if text.nil?
+        return text if text.length <= max_length
+        text[0, max_length] + suffix
+      end
+
       # Transform hash keys from strings to symbols
       # @param hash [Hash] Hash with string or symbol keys
       # @return [Hash] Hash with symbolized keys

data/lib/claude_memory/distill/json_schema.md

@@ -66,13 +66,17 @@ This document defines the schema for extracted knowledge from transcripts.
 - **conflict**: `{kind: "conflict", value: true}` - indicates contradictory information detected
 - **time_boundary**: `{kind: "time_boundary", value: "2024-01-15"}` - temporal boundary marker
 
-## Predicate Types (MVP)
+## Predicate Types
+
+Canonical vocabulary defined in `lib/claude_memory/resolve/predicate_policy.rb`.
 
 | Predicate | Cardinality | Exclusive |
 |-----------|-------------|-----------|
 | convention | multi | no |
-| decision | multi (by scope) | no |
-| auth_method | single | yes |
+| decision | multi | no |
+| architecture | multi | no |
+| uses_framework | multi | no |
+| uses_language | multi | no |
 | uses_database | single | yes |
-| uses_framework | single | yes |
 | deployment_platform | single | yes |
+| auth_method | single | yes |

data/lib/claude_memory/distill/null_distiller.rb

@@ -73,6 +73,8 @@ module ClaudeMemory
             facts << build_fact("uses_framework", entity[:name], text, scope_hint)
           when "platform"
             facts << build_fact("deployment_platform", entity[:name], text, scope_hint)
+          when "language"
+            facts << build_fact("uses_language", entity[:name], text, scope_hint)
           end
         end
 

data/lib/claude_memory/domain/entity.rb

@@ -2,10 +2,18 @@
 
 module ClaudeMemory
   module Domain
-    # Domain model representing an entity (database, framework, person, etc.)
+    # Domain model representing an entity (database, framework, person, etc.).
+    # Instances are immutable (frozen).
     class Entity
       attr_reader :id, :type, :canonical_name, :slug, :created_at
 
+      # @param attributes [Hash] entity attributes
+      # @option attributes [Integer] :id database primary key
+      # @option attributes [String] :type entity category (required, e.g. "database", "framework", "person")
+      # @option attributes [String] :canonical_name display name (required)
+      # @option attributes [String] :slug URL-safe identifier (required)
+      # @option attributes [String] :created_at ISO 8601 creation timestamp
+      # @raise [ArgumentError] if type, canonical_name, or slug is blank
       def initialize(attributes)
         @id = attributes[:id]
         @type = attributes[:type]
@@ -17,18 +25,22 @@ module ClaudeMemory
         freeze
       end
 
+      # @return [Boolean] true when type is "database"
       def database?
         type == "database"
       end
 
+      # @return [Boolean] true when type is "framework"
       def framework?
         type == "framework"
       end
 
+      # @return [Boolean] true when type is "person"
       def person?
         type == "person"
       end
 
+      # @return [Hash] all attributes as a plain hash
       def to_h
         {
           id: id,

data/lib/claude_memory/domain/fact.rb

@@ -2,13 +2,27 @@
 
 module ClaudeMemory
   module Domain
-    # Domain model representing a fact in the memory system
-    # Encapsulates business logic and validation
+    # Domain model representing a fact in the memory system.
+    # Encapsulates business logic and validation. Instances are immutable (frozen).
     class Fact
       attr_reader :id, :docid, :subject_name, :predicate, :object_literal,
         :status, :confidence, :scope, :project_path,
         :valid_from, :valid_to, :created_at
 
+      # @param attributes [Hash] fact attributes
+      # @option attributes [Integer] :id database primary key
+      # @option attributes [Integer] :docid FTS document id
+      # @option attributes [String] :subject_name entity name of the subject
+      # @option attributes [String] :predicate relationship type (required)
+      # @option attributes [String] :object_literal literal value (required)
+      # @option attributes [String] :status one of "active", "superseded", "rejected", "disputed"
+      # @option attributes [Float] :confidence score between 0 and 1 (default: 1.0)
+      # @option attributes [String] :scope "project" or "global" (default: "project")
+      # @option attributes [String] :project_path path for project-scoped facts
+      # @option attributes [String] :valid_from ISO 8601 start of validity
+      # @option attributes [String] :valid_to ISO 8601 end of validity (nil if current)
+      # @option attributes [String] :created_at ISO 8601 creation timestamp
+      # @raise [ArgumentError] if predicate, object_literal, or confidence is invalid
       def initialize(attributes)
         @id = attributes[:id]
         @docid = attributes[:docid]
@@ -27,22 +41,32 @@ module ClaudeMemory
         freeze
       end
 
+      # @return [Boolean] true when status is "active"
       def active?
         status == "active"
       end
 
+      # @return [Boolean] true when status is "superseded"
       def superseded?
         status == "superseded"
       end
 
+      # @return [Boolean] true when status is "rejected"
+      def rejected?
+        status == "rejected"
+      end
+
+      # @return [Boolean] true when scope is "global"
       def global?
         scope == "global"
       end
 
+      # @return [Boolean] true when scope is "project"
       def project?
         scope == "project"
       end
 
+      # @return [Hash] all attributes as a plain hash
       def to_h
         {
           id: id,

data/lib/claude_memory/domain/provenance.rb

@@ -41,7 +41,6 @@ module ClaudeMemory
 
       def validate!
         raise ArgumentError, "fact_id required" if fact_id.nil?
-        raise ArgumentError, "content_item_id required" if content_item_id.nil?
       end
     end
   end

data/lib/claude_memory/embeddings/api_adapter.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module ClaudeMemory
+  module Embeddings
+    # Adapter for any OpenAI-compatible /v1/embeddings endpoint.
+    # Works with OpenAI, Voyage, Ollama, LiteLLM, etc.
+    #
+    # Required ENV:
+    #   CLAUDE_MEMORY_EMBEDDING_API_KEY or OPENAI_API_KEY
+    #
+    # Optional ENV:
+    #   CLAUDE_MEMORY_EMBEDDING_API_URL (default: https://api.openai.com/v1/embeddings)
+    #   CLAUDE_MEMORY_EMBEDDING_MODEL   (default: text-embedding-3-small)
+    #
+    class ApiAdapter
+      class ApiError < StandardError; end
+
+      DEFAULT_API_URL = "https://api.openai.com/v1/embeddings"
+      DEFAULT_MODEL = "text-embedding-3-small"
+
+      def initialize(model: nil, env: ENV)
+        @api_key = env["CLAUDE_MEMORY_EMBEDDING_API_KEY"] || env["OPENAI_API_KEY"]
+        @api_url = env["CLAUDE_MEMORY_EMBEDDING_API_URL"] || DEFAULT_API_URL
+        @model = model || env["CLAUDE_MEMORY_EMBEDDING_MODEL"] || DEFAULT_MODEL
+        @known_dimensions = ModelRegistry.dimensions_for(@model)
+
+        raise ArgumentError, "Set CLAUDE_MEMORY_EMBEDDING_API_KEY or OPENAI_API_KEY" unless @api_key
+      end
+
+      def name = "api"
+
+      # Dimensions resolved from registry if known, otherwise lazy from first API response.
+      def dimensions
+        @dimensions ||= @known_dimensions || fetch_dimensions
+      end
+
+      # Generate embedding for a query text.
+      # @param text [String] input text to embed
+      # @return [Array<Float>] embedding vector
+      def generate(text)
+        return zero_vector if text.nil? || text.empty?
+
+        response = call_api(text)
+        embedding = response.dig("data", 0, "embedding")
+
+        raise ApiError, "No embedding returned in API response" unless embedding
+
+        @dimensions ||= embedding.size
+        embedding
+      end
+
+      # Alias for passage encoding — API providers don't distinguish query vs passage
+      alias_method :generate_passage, :generate
+
+      private
+
+      def fetch_dimensions
+        # Make a minimal API call to discover dimensions
+        embedding = generate("dimension probe")
+        embedding.size
+      end
+
+      def call_api(text)
+        uri = URI(@api_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 10
+        http.read_timeout = 30
+
+        request = Net::HTTP::Post.new(uri.path)
+        request["Authorization"] = "Bearer #{@api_key}"
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate({input: text, model: @model})
+
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise ApiError, "HTTP #{response.code}: #{response.body}"
+        end
+
+        JSON.parse(response.body)
+      end
+
+      def zero_vector
+        # If dimensions haven't been discovered yet, we can't return a properly-sized zero vector.
+        # Return empty array; callers handle nil/empty gracefully.
+        return [] unless @dimensions
+
+        Array.new(@dimensions, 0.0)
+      end
+    end
+  end
+end

data/lib/claude_memory/embeddings/dimension_check.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Embeddings
+    # Value object that detects embedding dimension mismatches.
+    # Returns a Result so the caller decides how to handle mismatches —
+    # no hidden side effects like dropping tables.
+    class DimensionCheck
+      Result = Data.define(:status, :stored, :current)
+
+      # @param store [Store::SQLiteStore] database to check meta against
+      # @param provider [#dimensions] embedding provider
+      # @return [Result] status is :fresh, :match, or :mismatch
+      def self.call(store, provider)
+        stored = store.get_meta("embedding_dimensions")&.to_i
+        return Result.new(status: :fresh, stored: nil, current: provider.dimensions) unless stored
+        return Result.new(status: :match, stored: stored, current: provider.dimensions) if stored == provider.dimensions
+
+        Result.new(status: :mismatch, stored: stored, current: provider.dimensions)
+      end
+    end
+  end
+end

data/lib/claude_memory/embeddings/fastembed_adapter.rb

@@ -2,33 +2,50 @@
 
 module ClaudeMemory
   module Embeddings
-    # Adapter wrapping fastembed-rb for high-quality local embeddings
-    # Uses BAAI/bge-small-en-v1.5 by default (384-dim, ~67MB ONNX model)
+    # Adapter wrapping fastembed-rb for high-quality local embeddings.
+    # Supports any model available in fastembed-rb's SUPPORTED_MODELS.
     #
-    # Implements the same generate(text) interface as Generator for DI compatibility.
-    # Supports asymmetric query/passage encoding for better retrieval accuracy.
+    # Model selection (in priority order):
+    #   1. Explicit model_name parameter
+    #   2. CLAUDE_MEMORY_EMBEDDING_MODEL env var
+    #   3. Default: BAAI/bge-small-en-v1.5 (384-dim, ~67MB ONNX)
+    #
+    # Dimensions are resolved from the ModelRegistry for known models,
+    # or probed from fastembed's ModelInfo for unknown models.
     #
     # Usage:
     #   adapter = FastembedAdapter.new
     #   query_vec = adapter.generate("What database?")         # query encoding
     #   passage_vec = adapter.generate_passage("Uses PostgreSQL") # passage encoding
     #
+    #   # Use a larger model:
+    #   adapter = FastembedAdapter.new(model_name: "BAAI/bge-base-en-v1.5")
+    #   adapter.dimensions  # => 768
+    #
     class FastembedAdapter
-      EMBEDDING_DIM = 384
       DEFAULT_MODEL = "BAAI/bge-small-en-v1.5"
 
-      def initialize(model_name: DEFAULT_MODEL)
+      attr_reader :model_name, :dimensions
+
+      def name = "fastembed"
+
+      def initialize(model_name: nil, env: ENV)
+        @model_name = model_name || env["CLAUDE_MEMORY_EMBEDDING_MODEL"] || DEFAULT_MODEL
+        @dimensions = resolve_dimensions(@model_name)
+
         require "fastembed"
-        @model = Fastembed::TextEmbedding.new(model_name: model_name)
+        @model = Fastembed::TextEmbedding.new(model_name: @model_name)
+
+        # If dimensions weren't known from registry, probe from fastembed
+        @dimensions ||= probe_dimensions_from_fastembed
       rescue LoadError
         raise LoadError,
           "fastembed gem is required for FastembedAdapter. Add `gem 'fastembed'` to your Gemfile."
       end
 
       # Generate query embedding (optimized for search queries)
-      # Compatible with Recall's embedding_generator interface
       # @param text [String] query text to embed
-      # @return [Array<Float>] normalized 384-dimensional vector
+      # @return [Array<Float>] normalized embedding vector
       def generate(text)
         return zero_vector if text.nil? || text.empty?
 
@@ -36,9 +53,8 @@ module ClaudeMemory
       end
 
       # Generate passage embedding (optimized for document/fact indexing)
-      # Use this when storing embeddings for facts
       # @param text [String] passage text to embed
-      # @return [Array<Float>] normalized 384-dimensional vector
+      # @return [Array<Float>] normalized embedding vector
       def generate_passage(text)
         return zero_vector if text.nil? || text.empty?
 
@@ -47,8 +63,26 @@ module ClaudeMemory
 
       private
 
+      # Resolve dimensions from the model registry (fast, no I/O).
+      # Returns nil if the model isn't in the registry.
+      def resolve_dimensions(model)
+        ModelRegistry.dimensions_for(model)
+      end
+
+      # Fallback: probe fastembed's SUPPORTED_MODELS for dimension info.
+      # This handles models added to fastembed-rb but not yet in our registry.
+      def probe_dimensions_from_fastembed
+        if defined?(Fastembed::SUPPORTED_MODELS)
+          info = Fastembed::SUPPORTED_MODELS[@model_name]
+          return info.dim if info
+        end
+
+        # Last resort: generate a test embedding and measure its size
+        @model.query_embed("dimension probe").first.size
+      end
+
       def zero_vector
-        Array.new(EMBEDDING_DIM, 0.0)
+        Array.new(@dimensions, 0.0)
       end
     end
   end

data/lib/claude_memory/embeddings/generator.rb

@@ -12,6 +12,10 @@ module ClaudeMemory
     class Generator
       EMBEDDING_DIM = 384
 
+      def name = "tfidf"
+
+      def dimensions = EMBEDDING_DIM
+
       # Common technical terms and programming concepts for vocabulary
       VOCABULARY = %w[
         database framework library module class function method