htm 0.0.30 → 0.0.32

data/examples/12_rails_app/app/controllers/chats_controller.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+class ChatsController < ApplicationController
+  def index
+    @chats = Chat.order(updated_at: :desc).limit(20)
+    @current_chat = Chat.find_by(id: session[:chat_id])
+  end
+
+  def show
+    @chat = Chat.find(params[:id])
+    @messages = @chat.messages.order(:created_at)
+    @available_providers = detect_available_providers
+    current_provider = @chat.model&.provider || 'ollama'
+    @available_models = fetch_models_for_provider(current_provider)
+    @htm_settings = htm_settings
+    session[:chat_id] = @chat.id
+  end
+
+  def create
+    @chat = Chat.new
+    @chat.assume_model_exists = true
+
+    # Use remembered model for default provider, or fall back to env default
+    default_provider = 'ollama'
+    remembered_model = provider_model_memory[default_provider]
+    default_model = remembered_model || ENV.fetch('CHAT_MODEL', 'gemma3:latest')
+
+    @chat.model = default_model
+    @chat.provider = default_provider
+    @chat.save!
+
+    # Remember this model for the provider
+    remember_model_for_provider(default_provider, default_model)
+
+    session[:chat_id] = @chat.id
+    redirect_to chat_path(@chat)
+  end
+
+  def update
+    @chat = Chat.find(params[:id])
+
+    # Handle provider change
+    if params[:provider].present?
+      new_provider = params[:provider]
+      models = fetch_models_for_provider(new_provider)
+
+      # Restore last-used model for this provider, or use first available
+      remembered_model = provider_model_memory[new_provider]
+      selected_model = if remembered_model && models.include?(remembered_model)
+                         remembered_model
+                       else
+                         models.first || "#{new_provider}-default"
+                       end
+
+      model = Model.find_or_create_by!(model_id: selected_model, provider: new_provider) do |m|
+        m.name = selected_model
+      end
+      @chat.update_column(:model_id, model.id)
+
+      # Remember this model for the provider
+      remember_model_for_provider(new_provider, selected_model)
+
+    # Handle model change
+    elsif params[:model_id].present?
+      current_provider = @chat.model&.provider || 'ollama'
+      model = Model.find_or_create_by!(model_id: params[:model_id], provider: current_provider) do |m|
+        m.name = params[:model_id]
+      end
+      @chat.update_column(:model_id, model.id)
+
+      # Remember this model for the provider
+      remember_model_for_provider(current_provider, params[:model_id])
+    end
+
+    redirect_to chat_path(@chat)
+  end
+
+  # API endpoint to get models for a provider (used by JavaScript)
+  def models
+    provider = params[:provider] || 'ollama'
+    models = fetch_models_for_provider(provider)
+    render json: models
+  end
+
+  def destroy
+    Chat.find(params[:id]).destroy
+    session.delete(:chat_id) if session[:chat_id] == params[:id].to_i
+    redirect_to app_root_path, notice: 'Chat deleted'
+  end
+
+  def update_htm_settings
+    @chat = Chat.find(params[:id])
+
+    # Update HTM settings in session
+    limit_param = params[:htm_limit]
+    limit_value = limit_param == 'all' ? 'all' : (limit_param || 5).to_i
+
+    session[:htm_settings] = {
+      strategy: params[:htm_strategy] || 'hybrid',
+      limit: limit_value,
+      propositions: params[:htm_propositions] == '1',
+      tags_only: params[:htm_tags_only] == '1',
+      tag_filter: params[:htm_tag_filter].presence
+    }
+
+    Rails.logger.info "Updated HTM settings: #{session[:htm_settings].inspect}"
+    redirect_to chat_path(@chat)
+  end
+
+  private
+
+  def detect_available_providers
+    providers = []
+
+    # Use RubyLLM's provider registry to dynamically detect available providers
+    RubyLLM.providers.each do |provider_class|
+      provider_id = provider_class.name.split('::').last.downcase
+      display_name = provider_display_name(provider_id)
+
+      if provider_class.local?
+        # Local providers: check if service is reachable
+        providers << { id: provider_id, name: "#{display_name} (Local)" } if local_provider_available?(provider_id)
+      else
+        # Cloud providers: check if required API key env var is set
+        providers << { id: provider_id, name: display_name } if cloud_provider_configured?(provider_class)
+      end
+    end
+
+    # Add custom local providers not in RubyLLM registry (use OpenAI-compatible API)
+    providers << { id: 'lmstudio', name: 'LM Studio (Local)' } if lmstudio_available?
+
+    providers
+  end
+
+  def provider_display_name(provider_id)
+    {
+      'openai' => 'OpenAI',
+      'anthropic' => 'Anthropic',
+      'gemini' => 'Google Gemini',
+      'deepseek' => 'DeepSeek',
+      'openrouter' => 'OpenRouter',
+      'ollama' => 'Ollama',
+      'gpustack' => 'GPUStack',
+      'bedrock' => 'AWS Bedrock',
+      'vertexai' => 'Google Vertex AI',
+      'mistral' => 'Mistral',
+      'perplexity' => 'Perplexity',
+      'xai' => 'xAI',
+      'lmstudio' => 'LM Studio'
+    }[provider_id] || provider_id.titleize
+  end
+
+  def cloud_provider_configured?(provider_class)
+    # Check if all required configuration keys have corresponding env vars set
+    provider_class.configuration_requirements.all? do |config_key|
+      # Convert config key like :anthropic_api_key to env var ANTHROPIC_API_KEY
+      env_var = config_key.to_s.upcase
+      ENV[env_var].present?
+    end
+  end
+
+  def local_provider_available?(provider_id)
+    case provider_id
+    when 'ollama'
+      ollama_available?
+    when 'gpustack'
+      gpustack_available?
+    else
+      false
+    end
+  end
+
+  def ollama_available?
+    ollama_url = ENV.fetch('OLLAMA_URL', 'http://localhost:11434')
+    uri = URI("#{ollama_url}/api/tags")
+    response = Net::HTTP.get_response(uri)
+    response.is_a?(Net::HTTPSuccess)
+  rescue StandardError
+    false
+  end
+
+  def gpustack_available?
+    gpustack_url = ENV.fetch('GPUSTACK_API_BASE', 'http://localhost:8080')
+    uri = URI("#{gpustack_url}/v1/models")
+    response = Net::HTTP.get_response(uri)
+    response.is_a?(Net::HTTPSuccess)
+  rescue StandardError
+    false
+  end
+
+  def lmstudio_available?
+    lmstudio_url = ENV.fetch('LMSTUDIO_URL', 'http://localhost:1234')
+    uri = URI("#{lmstudio_url}/v1/models")
+    response = Net::HTTP.get_response(uri)
+    response.is_a?(Net::HTTPSuccess)
+  rescue StandardError
+    false
+  end
+
+  def fetch_models_for_provider(provider)
+    case provider
+    when 'ollama'
+      fetch_ollama_models
+    when 'gpustack'
+      fetch_gpustack_models
+    when 'lmstudio'
+      fetch_lmstudio_models
+    else
+      fetch_models_from_registry(provider)
+    end
+  end
+
+  # Use RubyLLM's model registry for cloud providers
+  def fetch_models_from_registry(provider)
+    # Get chat models for this provider from RubyLLM registry
+    models = RubyLLM.models.by_provider(provider).chat_models
+    model_ids = models.map(&:id).sort
+
+    if model_ids.empty?
+      Rails.logger.warn "No models found in RubyLLM registry for provider: #{provider}"
+      # Return fallback models for common providers
+      fallback_models_for(provider)
+    else
+      model_ids
+    end
+  rescue StandardError => e
+    Rails.logger.warn "Failed to fetch models from registry for #{provider}: #{e.message}"
+    fallback_models_for(provider)
+  end
+
+  # Fallback models when registry is empty (e.g., not refreshed)
+  def fallback_models_for(provider)
+    case provider
+    when 'openai'
+      %w[gpt-4o gpt-4o-mini gpt-4-turbo gpt-4 gpt-3.5-turbo]
+    when 'anthropic'
+      %w[claude-sonnet-4-20250514 claude-3-5-sonnet-20241022 claude-3-5-haiku-20241022 claude-3-opus-20240229]
+    when 'gemini'
+      %w[gemini-2.0-flash gemini-1.5-pro gemini-1.5-flash]
+    when 'deepseek'
+      %w[deepseek-chat deepseek-coder]
+    when 'openrouter'
+      %w[openai/gpt-4o anthropic/claude-3.5-sonnet meta-llama/llama-3-70b-instruct]
+    else
+      []
+    end
+  end
+
+  def fetch_ollama_models
+    ollama_url = ENV.fetch('OLLAMA_URL', 'http://localhost:11434')
+    response = Net::HTTP.get(URI("#{ollama_url}/api/tags"))
+    data = JSON.parse(response)
+    data['models'].map { |m| m['name'] }.sort
+  rescue StandardError => e
+    Rails.logger.warn "Failed to fetch Ollama models: #{e.message}"
+    []
+  end
+
+  def fetch_gpustack_models
+    gpustack_url = ENV.fetch('GPUSTACK_API_BASE', 'http://localhost:8080')
+    response = Net::HTTP.get(URI("#{gpustack_url}/v1/models"))
+    data = JSON.parse(response)
+    data['data'].map { |m| m['id'] }.sort
+  rescue StandardError => e
+    Rails.logger.warn "Failed to fetch GPUStack models: #{e.message}"
+    []
+  end
+
+  def fetch_lmstudio_models
+    lmstudio_url = ENV.fetch('LMSTUDIO_URL', 'http://localhost:1234')
+    response = Net::HTTP.get(URI("#{lmstudio_url}/v1/models"))
+    data = JSON.parse(response)
+    data['data'].map { |m| m['id'] }.sort
+  rescue StandardError => e
+    Rails.logger.warn "Failed to fetch LM Studio models: #{e.message}"
+    []
+  end
+
+  # Per-provider model memory stored in session
+  def provider_model_memory
+    session[:provider_models] ||= {}
+  end
+
+  def remember_model_for_provider(provider, model_id)
+    session[:provider_models] ||= {}
+    session[:provider_models][provider] = model_id
+    Rails.logger.info "Remembered model '#{model_id}' for provider '#{provider}'"
+  end
+
+  # HTM context enhancement settings stored in session
+  def htm_settings
+    defaults = {
+      strategy: 'hybrid',
+      limit: 5,
+      propositions: false,
+      tags_only: false,
+      tag_filter: nil
+    }
+    stored = session[:htm_settings] || {}
+    defaults.merge(stored.symbolize_keys)
+  end
+end

data/examples/12_rails_app/app/controllers/dashboard_controller.rb

@@ -4,6 +4,9 @@ require 'ostruct'
 
 class DashboardController < ApplicationController
   def index
+    # Show current HTM database connection
+    @htm_database_url = HTM.db.opts[:orig_uri] || "#{HTM.db.opts[:adapter]}://#{HTM.db.opts[:user]}@#{HTM.db.opts[:host]}:#{HTM.db.opts[:port]}/#{HTM.db.opts[:database]}"
+
     # Note: HTM::Models::Node has a default_scope that excludes deleted nodes
     # so we don't need to call .active explicitly
     @stats = {

data/examples/12_rails_app/app/controllers/files_controller.rb

@@ -7,7 +7,12 @@ class FilesController < ApplicationController
 
   def show
     @file_source = HTM::Models::FileSource[params[:id]]
-    @chunks = @file_source.chunks.order(:id)
+    unless @file_source
+      flash[:alert] = 'File source not found'
+      redirect_to files_path
+      return
+    end
+    @chunks = @file_source.nodes_dataset.order(:chunk_position).all
   end
 
   def new
@@ -128,6 +133,11 @@ class FilesController < ApplicationController
 
   def sync
     @file_source = HTM::Models::FileSource[params[:id]]
+    unless @file_source
+      flash[:alert] = 'File source not found'
+      redirect_to files_path
+      return
+    end
 
     begin
       result = htm.load_file(@file_source.file_path, force: true)
@@ -136,11 +146,16 @@ class FilesController < ApplicationController
       flash[:alert] = "Error syncing file: #{e.message}"
     end
 
-    redirect_to file_path(@file_source)
+    redirect_to file_path(@file_source.id)
   end
 
   def destroy
     @file_source = HTM::Models::FileSource[params[:id]]
+    unless @file_source
+      flash[:alert] = 'File source not found'
+      redirect_to files_path
+      return
+    end
 
     begin
       htm.unload_file(@file_source.file_path)

data/examples/12_rails_app/app/controllers/home_controller.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class HomeController < ApplicationController
+  def index
+    @chat_count = Chat.count rescue 0
+    @memory_count = HTM::Models::Node.count rescue 0
+  end
+end

data/examples/12_rails_app/app/controllers/memories_controller.rb

@@ -17,7 +17,8 @@ class MemoriesController < ApplicationController
     end
 
     if params[:search].present?
-      @memories = @memories.where(Sequel.ilike(:content, "%#{params[:search]}%"))
+      search_pattern = "%#{Sequel.like_escape(params[:search])}%"
+      @memories = @memories.where(Sequel.ilike(:content, search_pattern))
     end
 
     # Simple pagination without Kaminari
@@ -67,13 +68,13 @@ class MemoriesController < ApplicationController
 
     if content.blank?
       flash[:alert] = 'Content is required'
-      redirect_to edit_memory_path(@memory)
+      redirect_to edit_memory_path(@memory.id)
       return
     end
 
     @memory.update(content: content)
     flash[:notice] = 'Memory updated successfully'
-    redirect_to memory_path(@memory)
+    redirect_to memory_path(@memory.id)
   end
 
   def destroy
@@ -91,7 +92,7 @@ class MemoriesController < ApplicationController
   def restore
     htm.restore(@memory.id)
     flash[:notice] = 'Memory restored successfully.'
-    redirect_to memory_path(@memory)
+    redirect_to memory_path(@memory.id)
   end
 
   def deleted
@@ -102,5 +103,9 @@ class MemoriesController < ApplicationController
 
   def set_memory
     @memory = HTM::Models::Node.with_deleted[params[:id].to_i]
+    return if @memory
+
+    flash[:alert] = 'Memory not found'
+    redirect_to memories_path
   end
 end

data/examples/12_rails_app/app/controllers/messages_controller.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+class MessagesController < ApplicationController
+  def create
+    @chat = Chat.find(params[:chat_id])
+    user_content = params[:content]
+    provider = @chat.model&.provider || 'ollama'
+
+    # Configure provider once at request start (clean slate)
+    configure_provider_cleanly(provider)
+
+    # Retrieve context from HTM (RAG)
+    context_results = fetch_htm_context(user_content)
+    context_text = format_context(context_results)
+    Rails.logger.info "Built context (#{context_text.length} chars): #{context_text[0..200]}..."
+
+    # Build system prompt with HTM context
+    system_prompt = build_system_prompt(context_text)
+
+    # Ensure chat has a valid Model record
+    ensure_model_record(@chat)
+
+    # Use acts_as_chat - the chat object handles its own LLM configuration
+    @chat.assume_model_exists = true
+    @chat.with_instructions(system_prompt, replace: true)
+
+    begin
+      @chat.ask(user_content)
+    rescue RubyLLM::Error => e
+      handle_llm_error(@chat, user_content, e)
+    end
+
+    redirect_to chat_path(@chat)
+  end
+
+  private
+
+  def fetch_htm_context(query)
+    settings = htm_settings
+
+    # If HTM is disabled, return empty context
+    if settings[:strategy] == 'off'
+      Rails.logger.info 'HTM context disabled (strategy: off)'
+      return []
+    end
+
+    # Build recall options from settings
+    recall_options = {
+      strategy: settings[:strategy].to_sym
+    }
+
+    # Handle limit - 'all' means no limit (use a large number)
+    if settings[:limit] == 'all'
+      recall_options[:limit] = 10_000
+    else
+      recall_options[:limit] = settings[:limit].to_i
+    end
+
+    # Add tag filter if specified
+    recall_options[:tags] = settings[:tag_filter] if settings[:tag_filter].present?
+
+    # Add metadata filter for propositions if enabled
+    if settings[:propositions]
+      # Include both regular nodes and proposition nodes
+      Rails.logger.info 'Including proposition nodes in HTM context'
+    elsif settings[:tags_only]
+      # Only search by tags, not content
+      Rails.logger.info 'Using tags-only search mode'
+    end
+
+    results = htm.recall(query, **recall_options)
+    limit_display = settings[:limit] == 'all' ? 'all' : settings[:limit]
+    Rails.logger.info "HTM recall (#{settings[:strategy]}, limit: #{limit_display}) returned #{results.size} results"
+    results
+  rescue StandardError => e
+    Rails.logger.warn "HTM recall failed: #{e.class}: #{e.message}"
+    []
+  end
+
+  def htm_settings
+    defaults = {
+      strategy: 'hybrid',
+      limit: 5,
+      propositions: false,
+      tags_only: false,
+      tag_filter: nil
+    }
+    stored = session[:htm_settings] || {}
+    defaults.merge(stored.symbolize_keys)
+  end
+
+  def format_context(results)
+    return 'No relevant context found.' if results.empty?
+
+    results.map.with_index do |r, i|
+      content = case r
+                when String then r
+                when Hash then r[:content] || r['content']
+                else r.respond_to?(:content) ? r.content : r.to_s
+                end
+      "[#{i + 1}] #{content&.truncate(500)}"
+    end.join("\n\n")
+  end
+
+  def build_system_prompt(context)
+    settings = htm_settings
+
+    if settings[:strategy] == 'off'
+      <<~PROMPT
+        You are a helpful assistant.
+        Answer questions based on your training knowledge.
+      PROMPT
+    else
+      <<~PROMPT
+        You are a helpful assistant with access to a knowledge base.
+
+        Use the following context from the knowledge base to answer questions.
+        If the context doesn't contain relevant information, acknowledge that
+        and provide your best answer based on your training.
+
+        === Knowledge Base Context ===
+        #{context}
+        === End Context ===
+      PROMPT
+    end
+  end
+
+  def ensure_model_record(chat)
+    stored_value = chat[:model_id]
+
+    # Already a valid Model record ID
+    if stored_value.to_s =~ /^\d+$/
+      return if Model.exists?(id: stored_value)
+    end
+
+    # Create Model record from string name
+    model_name = stored_value.presence || ENV.fetch('CHAT_MODEL', 'gemma3:latest')
+    model = Model.find_or_create_by!(model_id: model_name, provider: 'ollama') do |m|
+      m.name = model_name
+    end
+
+    chat.update_column(:model_id, model.id)
+    chat.reload
+  end
+
+  def handle_llm_error(chat, user_content, error)
+    chat.messages.create!(role: 'user', content: user_content)
+    chat.messages.create!(
+      role: 'assistant',
+      content: "**Error from #{chat.model&.provider || 'provider'}:** #{error.message}"
+    )
+    Rails.logger.error "LLM Error: #{error.class}: #{error.message}"
+    Rails.logger.error error.backtrace.first(5).join("\n")
+  end
+
+  # Configure provider with a clean slate - no residual config from previous requests
+  def configure_provider_cleanly(provider)
+    Rails.logger.info "=== Configuring provider: #{provider} ==="
+
+    # Reset OpenAI config to prevent cross-contamination between providers
+    # (LM Studio uses openai_api_base which affects other providers)
+    reset_openai_config unless provider == 'lmstudio'
+
+    case provider
+    when 'ollama'
+      configure_ollama
+    when 'lmstudio'
+      configure_lmstudio
+    when 'gpustack'
+      configure_gpustack
+    else
+      configure_cloud_provider(provider)
+    end
+  end
+
+  def reset_openai_config
+    RubyLLM.config.openai_api_base = nil
+    RubyLLM.config.openai_api_key = ENV['OPENAI_API_KEY']
+  end
+
+  def configure_ollama
+    base_url = ENV.fetch('OLLAMA_URL', 'http://localhost:11434')
+    base_url = "#{base_url}/v1" unless base_url.end_with?('/v1')
+    RubyLLM.config.ollama_api_base = base_url
+    Rails.logger.info "  Ollama API: #{base_url}"
+  end
+
+  def configure_lmstudio
+    base_url = ENV.fetch('LMSTUDIO_URL', 'http://localhost:1234')
+    base_url = "#{base_url}/v1" unless base_url.end_with?('/v1')
+    RubyLLM.config.openai_api_base = base_url
+    RubyLLM.config.openai_api_key = 'lm-studio'
+    Rails.logger.info "  LM Studio API: #{base_url}"
+  end
+
+  def configure_gpustack
+    base_url = ENV.fetch('GPUSTACK_API_BASE', 'http://localhost:8080')
+    RubyLLM.config.gpustack_api_base = base_url
+    Rails.logger.info "  GPUStack API: #{base_url}"
+  end
+
+  def configure_cloud_provider(provider)
+    provider_class = RubyLLM.providers.find { |p| p.name.split('::').last.downcase == provider }
+    return unless provider_class
+
+    provider_class.configuration_requirements.each do |config_key|
+      env_var = config_key.to_s.upcase
+      if ENV[env_var].present?
+        RubyLLM.config.send("#{config_key}=", ENV[env_var])
+        Rails.logger.info "  Set #{config_key} from #{env_var}"
+      end
+    end
+  end
+end

data/examples/12_rails_app/app/controllers/robots_controller.rb

@@ -7,6 +7,11 @@ class RobotsController < ApplicationController
 
   def show
     @robot = HTM::Models::Robot[params[:id]]
+    unless @robot
+      flash[:alert] = 'Robot not found'
+      redirect_to robots_path
+      return
+    end
     # Default scope already excludes deleted nodes, so no .active needed
     @memory_count = @robot.nodes_dataset.count
     @recent_memories = @robot.nodes_dataset.order(Sequel.desc(:created_at)).limit(10).all
@@ -37,8 +42,13 @@ class RobotsController < ApplicationController
 
   def switch
     robot = HTM::Models::Robot[params[:id]]
+    unless robot
+      flash[:alert] = 'Robot not found'
+      redirect_to robots_path
+      return
+    end
     self.current_robot_name = robot.name
     flash[:notice] = "Switched to robot '#{robot.name}'"
-    redirect_to root_path
+    redirect_to htm_root_path
   end
 end

data/examples/12_rails_app/app/controllers/tags_controller.rb

@@ -31,6 +31,19 @@ class TagsController < ApplicationController
 
   def show
     @tag = HTM::Models::Tag[params[:id]]
-    @memories = @tag.nodes_dataset.active.eager(:tags).order(Sequel.desc(:created_at)).all
+    unless @tag
+      flash[:alert] = 'Tag not found'
+      redirect_to tags_path
+      return
+    end
+    # Note: Node has a default scope that excludes deleted nodes, so we don't need .active
+    # We need to filter through node_tags that aren't deleted and join properly
+    @memories = HTM::Models::Node
+      .join(:node_tags, node_id: Sequel[:nodes][:id])
+      .where(Sequel[:node_tags][:tag_id] => @tag.id)
+      .where(Sequel[:node_tags][:deleted_at] => nil)
+      .eager(:tags)
+      .order(Sequel.desc(Sequel[:nodes][:created_at]))
+      .all
   end
 end

data/examples/12_rails_app/app/javascript/application.js

@@ -1,4 +1,4 @@
 // Configure your import map in config/importmap.rb
+// Turbo removed - causes issues with CDN-based setup, using vanilla JS instead
 
-import "@hotwired/turbo-rails"
 import "controllers"

data/examples/12_rails_app/app/models/application_record.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end