dspy 0.34.2 → 0.34.3

data/lib/dspy/memory/memory_record.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-require 'securerandom'
-
-module DSPy
-  module Memory
-    # Represents a single memory entry with metadata and embeddings
-    class MemoryRecord
-      extend T::Sig
-
-      sig { returns(String) }
-      attr_reader :id
-
-      sig { returns(String) }
-      attr_accessor :content
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :user_id
-
-      sig { returns(T::Array[String]) }
-      attr_accessor :tags
-
-      sig { returns(T.nilable(T::Array[Float])) }
-      attr_accessor :embedding
-
-      sig { returns(Time) }
-      attr_reader :created_at
-
-      sig { returns(Time) }
-      attr_accessor :updated_at
-
-      sig { returns(Integer) }
-      attr_accessor :access_count
-
-      sig { returns(T.nilable(Time)) }
-      attr_accessor :last_accessed_at
-
-      sig { returns(T::Hash[String, T.untyped]) }
-      attr_accessor :metadata
-
-      sig do
-        params(
-          content: String,
-          user_id: T.nilable(String),
-          tags: T::Array[String],
-          embedding: T.nilable(T::Array[Float]),
-          id: T.nilable(String),
-          metadata: T::Hash[String, T.untyped]
-        ).void
-      end
-      def initialize(content:, user_id: nil, tags: [], embedding: nil, id: nil, metadata: {})
-        @id = id || SecureRandom.uuid
-        @content = content
-        @user_id = user_id
-        @tags = tags
-        @embedding = embedding
-        @created_at = Time.now
-        @updated_at = Time.now
-        @access_count = 0
-        @last_accessed_at = nil
-        @metadata = metadata
-      end
-
-      # Record an access to this memory
-      sig { void }
-      def record_access!
-        @access_count += 1
-        @last_accessed_at = Time.now
-      end
-
-      # Update the content and timestamp
-      sig { params(new_content: String).void }
-      def update_content!(new_content)
-        @content = new_content
-        @updated_at = Time.now
-      end
-
-      # Calculate age in seconds
-      sig { returns(Float) }
-      def age_in_seconds
-        Time.now - @created_at
-      end
-
-      # Calculate age in days
-      sig { returns(Float) }
-      def age_in_days
-        age_in_seconds / 86400.0
-      end
-
-      # Check if memory has been accessed recently (within last N seconds)
-      sig { params(seconds: Integer).returns(T::Boolean) }
-      def accessed_recently?(seconds = 3600)
-        return false if @last_accessed_at.nil?
-        (Time.now - @last_accessed_at) <= seconds
-      end
-
-      # Check if memory matches a tag
-      sig { params(tag: String).returns(T::Boolean) }
-      def has_tag?(tag)
-        @tags.include?(tag)
-      end
-
-      # Add a tag if not already present
-      sig { params(tag: String).void }
-      def add_tag(tag)
-        @tags << tag unless @tags.include?(tag)
-      end
-
-      # Remove a tag
-      sig { params(tag: String).void }
-      def remove_tag(tag)
-        @tags.delete(tag)
-      end
-
-      # Convert to hash for serialization
-      sig { returns(T::Hash[String, T.untyped]) }
-      def to_h
-        {
-          'id' => @id,
-          'content' => @content,
-          'user_id' => @user_id,
-          'tags' => @tags,
-          'embedding' => @embedding,
-          'created_at' => @created_at.iso8601,
-          'updated_at' => @updated_at.iso8601,
-          'access_count' => @access_count,
-          'last_accessed_at' => @last_accessed_at&.iso8601,
-          'metadata' => @metadata
-        }
-      end
-
-      # Create from hash (for deserialization)
-      sig { params(hash: T::Hash[String, T.untyped]).returns(MemoryRecord) }
-      def self.from_h(hash)
-        record = allocate
-        record.instance_variable_set(:@id, hash['id'])
-        record.instance_variable_set(:@content, hash['content'])
-        record.instance_variable_set(:@user_id, hash['user_id'])
-        record.instance_variable_set(:@tags, hash['tags'] || [])
-        record.instance_variable_set(:@embedding, hash['embedding'])
-        record.instance_variable_set(:@created_at, Time.parse(hash['created_at']))
-        record.instance_variable_set(:@updated_at, Time.parse(hash['updated_at']))
-        record.instance_variable_set(:@access_count, hash['access_count'] || 0)
-        record.instance_variable_set(:@last_accessed_at, 
-          hash['last_accessed_at'] ? Time.parse(hash['last_accessed_at']) : nil)
-        record.instance_variable_set(:@metadata, hash['metadata'] || {})
-        record
-      end
-
-      # String representation
-      sig { returns(String) }
-      def to_s
-        "#<MemoryRecord id=#{@id[0..7]}... content=\"#{@content[0..50]}...\" tags=#{@tags}>"
-      end
-
-      sig { returns(String) }
-      def inspect
-        to_s
-      end
-    end
-  end
-end

data/lib/dspy/memory/memory_store.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-
-module DSPy
-  module Memory
-    # Abstract base class for memory storage backends
-    class MemoryStore
-      extend T::Sig
-      extend T::Helpers
-      abstract!
-
-      # Store a memory record
-      sig { abstract.params(record: MemoryRecord).returns(T::Boolean) }
-      def store(record); end
-
-      # Retrieve a memory record by ID
-      sig { abstract.params(id: String).returns(T.nilable(MemoryRecord)) }
-      def retrieve(id); end
-
-      # Update an existing memory record
-      sig { abstract.params(record: MemoryRecord).returns(T::Boolean) }
-      def update(record); end
-
-      # Delete a memory record by ID
-      sig { abstract.params(id: String).returns(T::Boolean) }
-      def delete(id); end
-
-      # List all memory records for a user
-      sig { abstract.params(user_id: T.nilable(String), limit: T.nilable(Integer), offset: T.nilable(Integer)).returns(T::Array[MemoryRecord]) }
-      def list(user_id: nil, limit: nil, offset: nil); end
-
-      # Search memories by content (basic text search)
-      sig { abstract.params(query: String, user_id: T.nilable(String), limit: T.nilable(Integer)).returns(T::Array[MemoryRecord]) }
-      def search(query, user_id: nil, limit: nil); end
-
-      # Search memories by tags
-      sig { abstract.params(tags: T::Array[String], user_id: T.nilable(String), limit: T.nilable(Integer)).returns(T::Array[MemoryRecord]) }
-      def search_by_tags(tags, user_id: nil, limit: nil); end
-
-      # Vector similarity search (if supported by backend)
-      sig { abstract.params(embedding: T::Array[Float], user_id: T.nilable(String), limit: T.nilable(Integer), threshold: T.nilable(Float)).returns(T::Array[MemoryRecord]) }
-      def vector_search(embedding, user_id: nil, limit: nil, threshold: nil); end
-
-      # Count total memories
-      sig { abstract.params(user_id: T.nilable(String)).returns(Integer) }
-      def count(user_id: nil); end
-
-      # Clear all memories for a user (or all if user_id is nil)
-      sig { abstract.params(user_id: T.nilable(String)).returns(Integer) }
-      def clear(user_id: nil); end
-
-      # Check if the store supports vector search
-      sig { returns(T::Boolean) }
-      def supports_vector_search?
-        false
-      end
-
-      # Get store statistics
-      sig { returns(T::Hash[Symbol, T.untyped]) }
-      def stats
-        {
-          total_memories: count,
-          supports_vector_search: supports_vector_search?
-        }
-      end
-
-      # Batch operations
-      sig { params(records: T::Array[MemoryRecord]).returns(T::Array[T::Boolean]) }
-      def store_batch(records)
-        records.map { |record| store(record) }
-      end
-
-      sig { params(ids: T::Array[String]).returns(T::Array[T.nilable(MemoryRecord)]) }
-      def retrieve_batch(ids)
-        ids.map { |id| retrieve(id) }
-      end
-
-      sig { params(records: T::Array[MemoryRecord]).returns(T::Array[T::Boolean]) }
-      def update_batch(records)
-        records.map { |record| update(record) }
-      end
-
-      sig { params(ids: T::Array[String]).returns(T::Array[T::Boolean]) }
-      def delete_batch(ids)
-        ids.map { |id| delete(id) }
-      end
-    end
-  end
-end

data/lib/dspy/memory.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'memory/memory_record'
-require_relative 'memory/memory_store'
-require_relative 'memory/in_memory_store'
-require_relative 'memory/embedding_engine'
-require_relative 'memory/local_embedding_engine'
-require_relative 'memory/memory_compactor'
-require_relative 'memory/memory_manager'
-
-module DSPy
-  # Memory system for persistent, searchable agent memory
-  module Memory
-    class << self
-      extend T::Sig
-
-      # Configure the memory system
-      sig { returns(MemoryManager) }
-      def manager
-        @manager ||= MemoryManager.new
-      end
-
-      # Reset the memory system (useful for testing)
-      sig { void }
-      def reset!
-        @manager = nil
-      end
-    end
-  end
-end

data/lib/dspy/tools/memory_toolset.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-require_relative 'toolset'
-
-module DSPy
-  module Tools
-    # Example implementation of a memory toolset for agents
-    # Provides tools for storing, retrieving, and managing memory
-    class MemoryToolset < Toolset
-      extend T::Sig
-
-      toolset_name "memory"
-
-      # Expose methods as tools with descriptions
-      tool :store, description: "Store a key-value pair in memory with optional tags"
-      tool :retrieve, description: "Retrieve a value by key from memory"
-      tool :search, description: "Search memories by pattern in keys and/or values"
-      tool :list_keys, tool_name: "memory_list", description: "List all stored memory keys"
-      tool :update, description: "Update an existing memory value"
-      tool :delete, description: "Delete a memory by key"
-      tool :clear, description: "Clear all stored memories"
-      tool :count, description: "Get the count of stored memories"
-      tool :get_metadata, description: "Get metadata for a specific memory"
-
-      sig { void }
-      def initialize
-        @memory = T.let({}, T::Hash[String, T::Hash[Symbol, T.untyped]])
-      end
-
-      sig { params(key: String, value: String, tags: T.nilable(T::Array[String])).returns(String) }
-      def store(key:, value:, tags: nil)
-        @memory[key] = {
-          value: value,
-          tags: tags || [],
-          created_at: Time.now,
-          updated_at: Time.now,
-          access_count: 0
-        }
-        "Stored memory '#{key}' successfully"
-      end
-
-      sig { params(key: String).returns(T.nilable(String)) }
-      def retrieve(key:)
-        entry = @memory[key]
-        return nil unless entry
-
-        # Track access
-        entry[:access_count] += 1
-        entry[:last_accessed_at] = Time.now
-        entry[:value]
-      end
-
-      sig { params(pattern: String, in_keys: T::Boolean, in_values: T::Boolean).returns(T::Array[T::Hash[Symbol, String]]) }
-      def search(pattern:, in_keys: true, in_values: true)
-        results = []
-        regex = Regexp.new(pattern, Regexp::IGNORECASE)
-
-        @memory.each do |key, entry|
-          match = (in_keys && key.match?(regex)) || (in_values && entry[:value].match?(regex))
-          results << { key: key, value: entry[:value] } if match
-        end
-
-        results
-      end
-
-      sig { returns(T::Array[String]) }
-      def list_keys
-        @memory.keys.sort
-      end
-
-      sig { params(key: String, value: String).returns(String) }
-      def update(key:, value:)
-        return "Memory '#{key}' not found" unless @memory.key?(key)
-
-        @memory[key][:value] = value
-        @memory[key][:updated_at] = Time.now
-        "Updated memory '#{key}' successfully"
-      end
-
-      sig { params(key: String).returns(String) }
-      def delete(key:)
-        return "Memory '#{key}' not found" unless @memory.key?(key)
-
-        @memory.delete(key)
-        "Deleted memory '#{key}' successfully"
-      end
-
-      sig { returns(String) }
-      def clear
-        count = @memory.size
-        @memory.clear
-        "Cleared #{count} memories"
-      end
-
-      sig { returns(Integer) }
-      def count
-        @memory.size
-      end
-
-      sig { params(key: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
-      def get_metadata(key:)
-        entry = @memory[key]
-        return nil unless entry
-
-        {
-          created_at: entry[:created_at],
-          updated_at: entry[:updated_at],
-          access_count: entry[:access_count],
-          last_accessed_at: entry[:last_accessed_at],
-          tags: entry[:tags],
-          value_length: entry[:value].length
-        }
-      end
-    end
-  end
-end