llmemory 0.1.10 → 0.1.11

data/lib/llmemory/mcp/tools/memory_search.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module MCP
+    module Tools
+      class MemorySearch < ::MCP::Tool
+        description "Search through user's memory for relevant information. Returns facts, observations, and context matching the query."
+
+        input_schema(
+          properties: {
+            query: { type: "string", description: "Search query to find relevant memories" },
+            user_id: { type: "string", description: "User identifier" },
+            search_type: {
+              type: "string",
+              enum: ["all", "short_term", "long_term"],
+              description: "Where to search: all (default), short_term, or long_term"
+            },
+            max_results: { type: "integer", description: "Maximum results (default: 10)" }
+          },
+          required: ["query", "user_id"]
+        )
+
+        class << self
+          def call(query:, user_id:, search_type: "all", max_results: 10, server_context: nil)
+            results = []
+            search_type = (search_type || "all").downcase
+            max_results = max_results || 10
+
+            if search_type == "all" || search_type == "short_term"
+              results.concat(search_short_term(user_id, query, max_results))
+            end
+
+            if search_type == "all" || search_type == "long_term"
+              results.concat(search_long_term(user_id, query, max_results))
+            end
+
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: format_results(results.first(max_results))
+            }])
+          rescue => e
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: "Error searching memory: #{e.message}"
+            }], error: true)
+          end
+
+          private
+
+          def search_short_term(user_id, query, limit)
+            store = build_short_term_store
+            sessions = store.list_sessions(user_id: user_id)
+            results = []
+            query_lower = query.downcase
+
+            sessions.each do |session_id|
+              state = store.load(user_id, session_id)
+              next unless state.is_a?(Hash)
+              messages = state[:messages] || state["messages"] || []
+              messages.each do |m|
+                content = (m[:content] || m["content"]).to_s
+                if content.downcase.include?(query_lower)
+                  results << {
+                    type: "short_term",
+                    session_id: session_id,
+                    role: m[:role] || m["role"],
+                    content: content
+                  }
+                end
+              end
+            end
+
+            results.first(limit)
+          end
+
+          def search_long_term(user_id, query, limit)
+            storage = build_long_term_storage
+            results = []
+
+            items = storage.search_items(user_id, query)
+            items.first(limit).each do |item|
+              results << {
+                type: "long_term_fact",
+                category: item[:category] || item["category"],
+                content: item[:content] || item["content"],
+                created_at: item[:created_at] || item["created_at"]
+              }
+            end
+
+            results
+          end
+
+          def build_short_term_store
+            case Llmemory.configuration.short_term_store.to_sym
+            when :memory then ShortTerm::Stores::MemoryStore.new
+            when :redis then ShortTerm::Stores::RedisStore.new
+            when :postgres then ShortTerm::Stores::PostgresStore.new
+            when :active_record, :activerecord
+              require_relative "../../short_term/stores/active_record_store"
+              ShortTerm::Stores::ActiveRecordStore.new
+            else
+              ShortTerm::Stores::MemoryStore.new
+            end
+          end
+
+          def build_long_term_storage
+            LongTerm::FileBased::Storages.build
+          end
+
+          def format_results(results)
+            return "No memories found matching the query." if results.empty?
+
+            output = ["Found #{results.size} memories:\n"]
+            results.each_with_index do |r, i|
+              case r[:type]
+              when "short_term"
+                output << "#{i + 1}. [Session: #{r[:session_id]}] [#{r[:role]}] #{truncate(r[:content], 200)}"
+              when "long_term_fact"
+                cat_info = r[:category] ? "[#{r[:category]}]" : ""
+                output << "#{i + 1}. #{cat_info} #{truncate(r[:content], 200)}"
+              end
+            end
+            output.join("\n")
+          end
+
+          def truncate(text, max_length)
+            return text if text.length <= max_length
+            "#{text[0, max_length]}..."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/mcp/tools/memory_stats.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module MCP
+    module Tools
+      class MemoryStats < ::MCP::Tool
+        description "Get memory statistics for a user including message counts, fact counts, and categories."
+
+        input_schema(
+          properties: {
+            user_id: { type: "string", description: "User identifier" }
+          },
+          required: ["user_id"]
+        )
+
+        class << self
+          def call(user_id:, server_context: nil)
+            stats = {
+              user_id: user_id,
+              short_term: {},
+              long_term: {}
+            }
+
+            # Short-term stats
+            store = build_short_term_store
+            sessions = store.list_sessions(user_id: user_id)
+            total_messages = 0
+            sessions.each do |session_id|
+              state = store.load(user_id, session_id)
+              next unless state.is_a?(Hash)
+              messages = state[:messages] || state["messages"] || []
+              total_messages += messages.size
+            end
+            stats[:short_term] = {
+              sessions: sessions.size,
+              total_messages: total_messages
+            }
+
+            # Long-term stats
+            storage = build_long_term_storage
+            begin
+              item_count = storage.count_items(user_id: user_id)
+              categories = storage.list_categories(user_id)
+              resources = storage.list_resources(user_id: user_id)
+              stats[:long_term] = {
+                facts: item_count,
+                categories: categories.size,
+                category_names: categories,
+                resources: resources.size
+              }
+            rescue => e
+              stats[:long_term] = { error: e.message }
+            end
+
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: format_stats(stats)
+            }])
+          rescue => e
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: "Error getting stats: #{e.message}"
+            }], error: true)
+          end
+
+          private
+
+          def build_short_term_store
+            case Llmemory.configuration.short_term_store.to_sym
+            when :memory then ShortTerm::Stores::MemoryStore.new
+            when :redis then ShortTerm::Stores::RedisStore.new
+            when :postgres then ShortTerm::Stores::PostgresStore.new
+            when :active_record, :activerecord
+              require_relative "../../short_term/stores/active_record_store"
+              ShortTerm::Stores::ActiveRecordStore.new
+            else
+              ShortTerm::Stores::MemoryStore.new
+            end
+          end
+
+          def build_long_term_storage
+            LongTerm::FileBased::Storages.build
+          end
+
+          def format_stats(stats)
+            output = ["Memory Statistics for user '#{stats[:user_id]}':\n"]
+
+            output << "SHORT-TERM MEMORY:"
+            output << "  Sessions: #{stats[:short_term][:sessions]}"
+            output << "  Total messages: #{stats[:short_term][:total_messages]}"
+            output << ""
+
+            output << "LONG-TERM MEMORY:"
+            if stats[:long_term][:error]
+              output << "  Error: #{stats[:long_term][:error]}"
+            else
+              output << "  Facts stored: #{stats[:long_term][:facts]}"
+              output << "  Categories: #{stats[:long_term][:categories]}"
+              if stats[:long_term][:category_names]&.any?
+                output << "  Category names: #{stats[:long_term][:category_names].join(', ')}"
+              end
+              output << "  Resources: #{stats[:long_term][:resources]}"
+            end
+
+            output.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/mcp/tools/memory_timeline.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module MCP
+    module Tools
+      class MemoryTimeline < ::MCP::Tool
+        description "Get chronological timeline of recent memories and interactions for a user."
+
+        input_schema(
+          properties: {
+            user_id: { type: "string", description: "User identifier" },
+            hours: { type: "integer", description: "Hours to look back (default: 24)" },
+            include_messages: { type: "boolean", description: "Include short-term messages (default: true)" }
+          },
+          required: ["user_id"]
+        )
+
+        class << self
+          def call(user_id:, hours: nil, include_messages: nil, server_context: nil)
+            hours = hours || 24
+            include_msgs = include_messages.nil? ? true : include_messages
+
+            timeline = []
+
+            # Get recent items from long-term memory
+            storage = build_long_term_storage
+            begin
+              items = storage.get_items_since(user_id, hours: hours)
+              items.each do |item|
+                timeline << {
+                  type: "fact",
+                  timestamp: item[:created_at] || item["created_at"],
+                  category: item[:category] || item["category"],
+                  content: item[:content] || item["content"]
+                }
+              end
+            rescue NotImplementedError
+              # Some storages may not implement get_items_since
+            end
+
+            # Get recent messages from short-term
+            if include_msgs
+              store = build_short_term_store
+              sessions = store.list_sessions(user_id: user_id)
+              sessions.each do |session_id|
+                state = store.load(user_id, session_id)
+                next unless state.is_a?(Hash)
+                messages = state[:messages] || state["messages"] || []
+                messages.each_with_index do |m, idx|
+                  timeline << {
+                    type: "message",
+                    timestamp: state[:updated_at] || Time.now,
+                    session_id: session_id,
+                    role: m[:role] || m["role"],
+                    content: m[:content] || m["content"],
+                    order: idx
+                  }
+                end
+              end
+            end
+
+            # Sort by timestamp (most recent first)
+            timeline.sort_by! { |t| t[:timestamp].to_s }.reverse!
+
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: format_timeline(timeline, hours)
+            }])
+          rescue => e
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: "Error getting timeline: #{e.message}"
+            }], error: true)
+          end
+
+          private
+
+          def build_short_term_store
+            case Llmemory.configuration.short_term_store.to_sym
+            when :memory then ShortTerm::Stores::MemoryStore.new
+            when :redis then ShortTerm::Stores::RedisStore.new
+            when :postgres then ShortTerm::Stores::PostgresStore.new
+            when :active_record, :activerecord
+              require_relative "../../short_term/stores/active_record_store"
+              ShortTerm::Stores::ActiveRecordStore.new
+            else
+              ShortTerm::Stores::MemoryStore.new
+            end
+          end
+
+          def build_long_term_storage
+            LongTerm::FileBased::Storages.build
+          end
+
+          def format_timeline(timeline, hours)
+            return "No activity in the last #{hours} hours." if timeline.empty?
+
+            output = ["Timeline (last #{hours} hours):\n"]
+            timeline.first(20).each do |entry|
+              case entry[:type]
+              when "fact"
+                cat_info = entry[:category] ? "[#{entry[:category]}]" : ""
+                output << "- [FACT] #{cat_info} #{truncate(entry[:content], 150)}"
+              when "message"
+                output << "- [MSG #{entry[:session_id]}] [#{entry[:role]}] #{truncate(entry[:content], 150)}"
+              end
+            end
+            output << "\n(Showing #{[timeline.size, 20].min} of #{timeline.size} entries)"
+            output.join("\n")
+          end
+
+          def truncate(text, max_length)
+            return text.to_s if text.to_s.length <= max_length
+            "#{text.to_s[0, max_length]}..."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/mcp/tools/memory_timeline_context.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module MCP
+    module Tools
+      class MemoryTimelineContext < ::MCP::Tool
+        description "Get temporal context around a specific memory. Shows N events before and after a given item or timestamp."
+
+        input_schema(
+          properties: {
+            user_id: { type: "string", description: "User identifier" },
+            item_id: { type: "string", description: "ID of the item to get context for (e.g., from search results)" },
+            timestamp: { type: "string", description: "ISO timestamp to get context around (alternative to item_id)" },
+            before: { type: "integer", description: "Number of items before the target (default: 5)" },
+            after: { type: "integer", description: "Number of items after the target (default: 5)" }
+          },
+          required: ["user_id"]
+        )
+
+        class << self
+          def call(user_id:, item_id: nil, timestamp: nil, before: nil, after: nil, server_context: nil)
+            before_count = before || 5
+            after_count = after || 5
+
+            reference = item_id || timestamp
+            unless reference
+              return ::MCP::Tool::Response.new([{
+                type: "text",
+                text: "Error: Either item_id or timestamp must be provided"
+              }], error: true)
+            end
+
+            storage = build_storage
+            result = storage.get_items_around(user_id, reference, before: before_count, after: after_count)
+
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: format_context(result, reference)
+            }])
+          rescue => e
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: "Error getting timeline context: #{e.message}"
+            }], error: true)
+          end
+
+          private
+
+          def build_storage
+            if Llmemory.configuration.long_term_type.to_s == "graph_based"
+              LongTerm::GraphBased::Storages.build
+            else
+              LongTerm::FileBased::Storages.build
+            end
+          end
+
+          def format_context(result, reference)
+            output = []
+            output << "Timeline Context around '#{reference}':\n"
+
+            if result[:before].empty? && result[:target].nil? && result[:after].empty?
+              return "No memories found around reference '#{reference}'"
+            end
+
+            # Before section
+            output << "BEFORE (#{result[:before].size} items):"
+            if result[:before].empty?
+              output << "  (no earlier items)"
+            else
+              result[:before].each do |item|
+                output << format_item(item)
+              end
+            end
+
+            # Target section
+            output << "\nTARGET:"
+            if result[:target]
+              output << format_item(result[:target], highlight: true)
+            else
+              output << "  (target not found)"
+            end
+
+            # After section
+            output << "\nAFTER (#{result[:after].size} items):"
+            if result[:after].empty?
+              output << "  (no later items)"
+            else
+              result[:after].each do |item|
+                output << format_item(item)
+              end
+            end
+
+            output.join("\n")
+          end
+
+          def format_item(item, highlight: false)
+            prefix = highlight ? ">>> " : "  - "
+            timestamp = format_timestamp(item)
+            content = extract_content(item)
+            category = extract_category(item)
+
+            cat_info = category ? "[#{category}] " : ""
+            "#{prefix}[#{timestamp}] #{cat_info}#{truncate(content, 120)}"
+          end
+
+          def format_timestamp(item)
+            ts = item[:created_at] || item["created_at"] || item.created_at rescue nil
+            return "unknown" unless ts
+            ts.respond_to?(:strftime) ? ts.strftime("%Y-%m-%d %H:%M") : ts.to_s[0, 16]
+          end
+
+          def extract_content(item)
+            # Handle both hash and object representations
+            if item.respond_to?(:content)
+              item.content
+            elsif item.respond_to?(:predicate)
+              # Graph-based edge
+              "#{item.subject_id} -> #{item.predicate} -> #{item.target_id}"
+            else
+              item[:content] || item["content"] || item.to_s
+            end
+          end
+
+          def extract_category(item)
+            if item.respond_to?(:category)
+              item.category
+            else
+              item[:category] || item["category"]
+            end
+          end
+
+          def truncate(text, max_length)
+            return text.to_s if text.to_s.length <= max_length
+            "#{text.to_s[0, max_length]}..."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/mcp.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "mcp/server"
+
+module Llmemory
+  module MCP
+  end
+end

data/lib/llmemory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Llmemory
-  VERSION = "0.1.10"
+  VERSION = "0.1.11"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llmemory
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - llmemory
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -71,6 +85,7 @@ email:
 - ''
 executables:
 - llmemory
+- llmemory-mcp
 extensions: []
 extra_rdoc_files: []
 files:
@@ -94,6 +109,7 @@ files:
 - app/views/llmemory/dashboard/users/show.html.erb
 - config/routes.rb
 - exe/llmemory
+- exe/llmemory-mcp
 - lib/generators/llmemory/install/install_generator.rb
 - lib/generators/llmemory/install/templates/create_llmemory_tables.rb
 - lib/llmemory.rb
@@ -106,6 +122,7 @@ files:
 - lib/llmemory/cli/commands/long_term/graph.rb
 - lib/llmemory/cli/commands/long_term/nodes.rb
 - lib/llmemory/cli/commands/long_term/resources.rb
+- lib/llmemory/cli/commands/mcp.rb
 - lib/llmemory/cli/commands/search.rb
 - lib/llmemory/cli/commands/short_term.rb
 - lib/llmemory/cli/commands/stats.rb
@@ -150,6 +167,18 @@ files:
 - lib/llmemory/maintenance/reindexer.rb
 - lib/llmemory/maintenance/runner.rb
 - lib/llmemory/maintenance/summarizer.rb
+- lib/llmemory/mcp.rb
+- lib/llmemory/mcp/authentication.rb
+- lib/llmemory/mcp/server.rb
+- lib/llmemory/mcp/tools/memory_add_message.rb
+- lib/llmemory/mcp/tools/memory_consolidate.rb
+- lib/llmemory/mcp/tools/memory_info.rb
+- lib/llmemory/mcp/tools/memory_retrieve.rb
+- lib/llmemory/mcp/tools/memory_save.rb
+- lib/llmemory/mcp/tools/memory_search.rb
+- lib/llmemory/mcp/tools/memory_stats.rb
+- lib/llmemory/mcp/tools/memory_timeline.rb
+- lib/llmemory/mcp/tools/memory_timeline_context.rb
 - lib/llmemory/memory.rb
 - lib/llmemory/retrieval.rb
 - lib/llmemory/retrieval/context_assembler.rb