rails_ai_kit 0.1.6 → 0.1.8

data/lib/rails_ai_kit/llm_providers/anthropic.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RailsAiKit
+  module LlmProviders
+    class Anthropic < Base
+      DEFAULT_MODEL = "claude-sonnet-4-20250514"
+      BASE_URL = "https://api.anthropic.com/v1"
+
+      def initialize(api_key:, base_url: nil)
+        super(api_key: api_key, base_url: base_url)
+      end
+
+      def generate(messages, model: nil, max_tokens: 1024)
+        model ||= DEFAULT_MODEL
+        url = "#{base_url}/messages"
+        system_msg = messages.find { |m| (m["role"] || m[:role]).to_s == "system" }
+        chat_msgs = messages.reject { |m| (m["role"] || m[:role]).to_s == "system" }
+        body = {
+          model: model,
+          max_tokens: max_tokens,
+          messages: chat_msgs.map { |m| { role: (m["role"] || m[:role]).to_s, content: m["content"] || m[:content] } }
+        }
+        body[:system] = system_msg["content"] || system_msg[:content] if system_msg
+        resp = client.post(url) do |req|
+          req.body = body.to_json
+          req.headers["Content-Type"] = "application/json"
+          req.headers["x-api-key"] = @api_key
+          req.headers["anthropic-version"] = "2023-06-01"
+        end
+        parse_response(resp, model)
+      end
+
+      private
+
+      def base_url
+        @base_url || BASE_URL
+      end
+
+      def client
+        @client ||= Faraday.new(url: base_url) do |f|
+          f.response :json
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def parse_response(resp, model)
+        raise RailsAiKit::Error, "Anthropic API error: #{resp.body}" unless resp.success?
+        data = resp.body
+        content = data["content"]&.find { |c| c["type"] == "text" }&.dig("text").to_s
+        usage = data["usage"] || {}
+        {
+          content: content,
+          model: data["model"] || model,
+          usage: { prompt_tokens: usage["input_tokens"] || 0, completion_tokens: usage["output_tokens"] || 0 },
+          raw: data
+        }
+      end
+    end
+  end
+end

data/lib/rails_ai_kit/llm_providers/base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RailsAiKit
+  module LlmProviders
+    class Base
+      class NotImplementedError < RailsAiKit::Error; end
+
+      # @param api_key [String]
+      # @param base_url [String, nil] Optional override (e.g. for custom)
+      def initialize(api_key:, base_url: nil)
+        @api_key = api_key
+        @base_url = base_url
+      end
+
+      # @param messages [Array<Hash>] [{ role: "user"|"assistant"|"system", content: "..." }]
+      # @param model [String, nil] Model name override
+      # @param max_tokens [Integer]
+      # @return [Hash] { content: String, model: String, usage: { prompt_tokens:, completion_tokens: }, raw: Hash }
+      def generate(messages, model: nil, max_tokens: 1024)
+        raise NotImplementedError, "#{self.class}#generate must be implemented"
+      end
+
+      protected
+
+      def extract_text(content)
+        return content if content.is_a?(String)
+        return content["text"] if content.is_a?(Hash) && content["text"]
+        content.dig("content", 0, "text") if content.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/rails_ai_kit/llm_providers/custom.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RailsAiKit
+  module LlmProviders
+    # Custom provider: any OpenAI-compatible endpoint (URL + API key).
+    # Use for local models, other hosts, or proxy endpoints.
+    class Custom < Base
+      def initialize(api_key:, base_url:)
+        raise ArgumentError, "base_url is required for custom provider" if base_url.blank?
+        super(api_key: api_key, base_url: base_url.to_s.sub(%r{/$}, ""))
+      end
+
+      def generate(messages, model: nil, max_tokens: 1024)
+        model ||= "default"
+        url = "#{@base_url}/chat/completions"
+        body = {
+          model: model,
+          messages: normalize_messages(messages),
+          max_tokens: max_tokens
+        }
+        resp = client.post(url) do |req|
+          req.body = body.to_json
+          req.headers["Content-Type"] = "application/json"
+          req.headers["Authorization"] = "Bearer #{@api_key}" if @api_key.present?
+        end
+        parse_response(resp, model)
+      end
+
+      private
+
+      def client
+        @client ||= Faraday.new do |f|
+          f.response :json
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def normalize_messages(messages)
+        messages.map do |m|
+          { role: m["role"] || m[:role], content: m["content"] || m[:content] }
+        end
+      end
+
+      def parse_response(resp, model)
+        raise RailsAiKit::Error, "Custom LLM API error: #{resp.body}" unless resp.success?
+        data = resp.body.is_a?(Hash) ? resp.body : JSON.parse(resp.body)
+        choice = data["choices"]&.first
+        content = choice.dig("message", "content").to_s
+        usage = data["usage"] || {}
+        {
+          content: content,
+          model: data["model"] || model,
+          usage: { prompt_tokens: usage["prompt_tokens"] || 0, completion_tokens: usage["completion_tokens"] || 0 },
+          raw: data
+        }
+      end
+    end
+  end
+end

data/lib/rails_ai_kit/llm_providers/google.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RailsAiKit
+  module LlmProviders
+    class Google < Base
+      DEFAULT_MODEL = "gemini-1.5-flash"
+      BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
+
+      def initialize(api_key:, base_url: nil)
+        super(api_key: api_key, base_url: base_url)
+      end
+
+      def generate(messages, model: nil, max_tokens: 1024)
+        model ||= DEFAULT_MODEL
+        url = "#{base_url}/models/#{model}:generateContent?key=#{@api_key}"
+        system_instruction = messages.find { |m| (m["role"] || m[:role]).to_s == "system" }
+        parts = messages.reject { |m| (m["role"] || m[:role]).to_s == "system" }
+                       .map { |m| (m["content"] || m[:content]).to_s }
+                       .join("\n\n")
+        body = {
+          contents: [{ parts: [{ text: parts }] }],
+          generationConfig: { maxOutputTokens: max_tokens }
+        }
+        body[:systemInstruction] = { parts: [{ text: system_instruction["content"] || system_instruction[:content] }] } if system_instruction
+        resp = client.post(url) do |req|
+          req.body = body.to_json
+          req.headers["Content-Type"] = "application/json"
+        end
+        parse_response(resp, model)
+      end
+
+      private
+
+      def base_url
+        @base_url || BASE_URL
+      end
+
+      def client
+        @client ||= Faraday.new(url: base_url) do |f|
+          f.response :json
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def parse_response(resp, model)
+        raise RailsAiKit::Error, "Google Gemini API error: #{resp.body}" unless resp.success?
+        data = resp.body
+        text = data.dig("candidates", 0, "content", "parts", 0, "text").to_s
+        usage = data.dig("usageMetadata") || {}
+        {
+          content: text,
+          model: model,
+          usage: { prompt_tokens: usage["promptTokenCount"] || 0, completion_tokens: usage["candidatesTokenCount"] || 0 },
+          raw: data
+        }
+      end
+    end
+  end
+end

data/lib/rails_ai_kit/llm_providers/groq.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RailsAiKit
+  module LlmProviders
+    # Groq uses OpenAI-compatible API at https://api.groq.com/openai/v1
+    class Groq < Base
+      DEFAULT_MODEL = "llama-3.1-70b-versatile"
+      BASE_URL = "https://api.groq.com/openai/v1"
+
+      def initialize(api_key:, base_url: nil)
+        super(api_key: api_key, base_url: base_url)
+      end
+
+      def generate(messages, model: nil, max_tokens: 1024)
+        model ||= DEFAULT_MODEL
+        url = "#{base_url}/chat/completions"
+        body = {
+          model: model,
+          messages: normalize_messages(messages),
+          max_tokens: max_tokens
+        }
+        resp = client.post(url) do |req|
+          req.body = body.to_json
+          req.headers["Content-Type"] = "application/json"
+          req.headers["Authorization"] = "Bearer #{@api_key}"
+        end
+        parse_response(resp, model)
+      end
+
+      private
+
+      def base_url
+        @base_url || BASE_URL
+      end
+
+      def client
+        @client ||= Faraday.new(url: base_url) do |f|
+          f.response :json
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def normalize_messages(messages)
+        messages.map do |m|
+          { role: m["role"] || m[:role], content: m["content"] || m[:content] }
+        end
+      end
+
+      def parse_response(resp, model)
+        raise RailsAiKit::Error, "Groq API error: #{resp.body}" unless resp.success?
+        data = resp.body
+        choice = data["choices"]&.first
+        content = choice.dig("message", "content").to_s
+        usage = data["usage"] || {}
+        {
+          content: content,
+          model: data["model"] || model,
+          usage: { prompt_tokens: usage["prompt_tokens"] || 0, completion_tokens: usage["completion_tokens"] || 0 },
+          raw: data
+        }
+      end
+    end
+  end
+end

data/lib/rails_ai_kit/llm_providers/openai.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RailsAiKit
+  module LlmProviders
+    class Openai < Base
+      DEFAULT_MODEL = "gpt-4o-mini"
+      BASE_URL = "https://api.openai.com/v1"
+
+      def initialize(api_key:, base_url: nil)
+        super(api_key: api_key, base_url: base_url)
+      end
+
+      def generate(messages, model: nil, max_tokens: 1024)
+        model ||= DEFAULT_MODEL
+        url = "#{base_url}/chat/completions"
+        body = {
+          model: model,
+          messages: normalize_messages(messages),
+          max_tokens: max_tokens
+        }
+        resp = client.post(url) do |req|
+          req.body = body.to_json
+          req.headers["Content-Type"] = "application/json"
+          req.headers["Authorization"] = "Bearer #{@api_key}"
+        end
+        parse_response(resp, model)
+      end
+
+      private
+
+      def base_url
+        @base_url || BASE_URL
+      end
+
+      def client
+        @client ||= Faraday.new(url: base_url) do |f|
+          f.response :json
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def normalize_messages(messages)
+        messages.map do |m|
+          { role: m["role"] || m[:role], content: m["content"] || m[:content] }
+        end
+      end
+
+      def parse_response(resp, model)
+        raise RailsAiKit::Error, "OpenAI API error: #{resp.body}" unless resp.success?
+        data = resp.body
+        choice = data["choices"]&.first
+        content = choice.dig("message", "content").to_s
+        usage = data["usage"] || {}
+        {
+          content: content,
+          model: data["model"] || model,
+          usage: { prompt_tokens: usage["prompt_tokens"] || 0, completion_tokens: usage["completion_tokens"] || 0 },
+          raw: data
+        }
+      end
+    end
+  end
+end

data/lib/rails_ai_kit/trace.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RailsAiKit
+  class Trace < ActiveRecord::Base
+    self.table_name = "rails_ai_traces"
+
+    scope :recent, -> { order(created_at: :desc) }
+    scope :blocked, -> { where(action: "block") }
+    scope :by_model, ->(model) { where(model: model) }
+
+    class << self
+      def record(prompt:, response:, model:, usage: nil, guard_scores: nil, latency_ms: nil, action: :allow)
+        create(
+          prompt: prompt.is_a?(String) ? prompt : prompt.to_json,
+          response: response,
+          model: model,
+          prompt_tokens: usage&.dig("prompt_tokens") || usage&.dig(:prompt_tokens),
+          completion_tokens: usage&.dig("completion_tokens") || usage&.dig(:completion_tokens),
+          guard_scores: guard_scores.is_a?(Hash) ? guard_scores : (guard_scores.present? ? JSON.parse(guard_scores.to_s) : {}),
+          latency_ms: latency_ms,
+          action: action.to_s
+        )
+      end
+    end
+  end
+end

data/lib/rails_ai_kit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAiKit
-  VERSION = "0.1.6"
+  VERSION = "0.1.8"
 end

data/lib/rails_ai_kit.rb

@@ -4,7 +4,7 @@ require_relative "rails_ai_kit/version"
 require_relative "rails_ai_kit/configuration"
 
 module RailsAiKit
-  class Error < StandardError; end 
+  class Error < StandardError; end
 end
 
 require_relative "rails_ai_kit/embedding_providers/base"
@@ -12,13 +12,28 @@ require_relative "rails_ai_kit/embedding_providers/openai"
 require_relative "rails_ai_kit/embedding_providers/cohere"
 require_relative "rails_ai_kit/embedding_service"
 
+# LLM and Guardrails (no ActiveRecord dependency for client/guardrails)
+require_relative "rails_ai_kit/llm_providers/base"
+require_relative "rails_ai_kit/llm_providers/openai"
+require_relative "rails_ai_kit/llm_providers/anthropic"
+require_relative "rails_ai_kit/llm_providers/google"
+require_relative "rails_ai_kit/llm_providers/groq"
+require_relative "rails_ai_kit/llm_providers/custom"
+require_relative "rails_ai_kit/llm_client"
+require_relative "rails_ai_kit/guards/base"
+require_relative "rails_ai_kit/guards/toxicity"
+require_relative "rails_ai_kit/guards/pii"
+require_relative "rails_ai_kit/guards/hallucination"
+require_relative "rails_ai_kit/guards/prompt_injection"
+require_relative "rails_ai_kit/guard_result"
+require_relative "rails_ai_kit/guardrails"
+require_relative "rails_ai_kit/ai_generate"
+require_relative "rails_ai_kit/eval"
+
 # Load models and AR integration only after ActiveRecord is ready.
-# Neighbor 0.6+ adds has_neighbors in its own on_load(:active_record).
-# Gemfile order can make our hook run before Neighbor's (or before neighbor is required).
-# So we ensure the neighbor gem is loaded and has_neighbors is on Base before our models.
 ActiveSupport.on_load(:active_record) do
   unless ActiveRecord::Base.respond_to?(:has_neighbors)
-    require "neighbor" # load gem so Neighbor and its lib are available
+    require "neighbor"
     require "neighbor/attribute"
     require "neighbor/model"
     require "neighbor/normalized_attribute"
@@ -28,17 +43,34 @@ ActiveSupport.on_load(:active_record) do
   require_relative "rails_ai_kit/label_record"
   require_relative "rails_ai_kit/classifier"
   require_relative "rails_ai_kit/vector_classify"
+  require_relative "rails_ai_kit/trace"
   ActiveRecord::Base.include RailsAiKit::VectorClassify
+  ActiveRecord::Base.include RailsAiKit::AiGenerate
 end
 
 module RailsAiKit
-  # Top-level classifier using default classifier name. For custom name use Classifier.new(classifier_name: "MyClassifier").
   def self.classifier(classifier_name = nil)
     Classifier.new(classifier_name: classifier_name)
   end
 
-  # Convenience: embed a single text. Same as RailsAiKit.embedding.embed(text).
   def self.embed(text)
     embedding.embed(text)
   end
+
+  def self.llm
+    @llm_client ||= LlmClient.new
+  end
+
+  # Run guardrails: generate response and evaluate with LLM-as-judge.
+  # @return [RailsAiKit::GuardResult]
+  def self.guard(prompt: nil, messages: nil, model: nil, checks: %i[toxicity hallucination], threshold: 0.8, system_prompt: nil)
+    Guardrails.new.guard(prompt: prompt, messages: messages, model: model, checks: checks, threshold: threshold, system_prompt: system_prompt)
+  end
+
+  # Run evaluation on a dataset.
+  # @param dataset [String, Array] Path to JSON or array of { prompt:, expected: (optional) }
+  # @return [Hash] { total:, accuracy:, hallucination_rate:, toxicity_failures:, details: }
+  def self.eval(dataset:, model: nil, checks: %i[toxicity hallucination])
+    Eval.new(dataset: dataset, model: model, checks: checks).run
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_ai_kit
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Rails AI Kit Contributors
@@ -76,19 +76,41 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - README.md
+- lib/generators/rails_ai_kit/dashboard/templates/index.html.erb
+- lib/generators/rails_ai_kit/dashboard/templates/traces_controller.rb
+- lib/generators/rails_ai_kit/dashboard_generator.rb
 - lib/generators/rails_ai_kit/install/templates/create_rails_ai_kit_labels.rb
+- lib/generators/rails_ai_kit/install/templates/create_rails_ai_kit_tables.rb
+- lib/generators/rails_ai_kit/install/templates/create_rails_ai_traces.rb
 - lib/generators/rails_ai_kit/install/templates/rails_ai_kit.rb
 - lib/generators/rails_ai_kit/install_generator.rb
 - lib/generators/rails_ai_kit/vector_columns/templates/add_vector_columns.rb
 - lib/generators/rails_ai_kit/vector_columns_generator.rb
 - lib/rails_ai_kit.rb
+- lib/rails_ai_kit/ai_generate.rb
 - lib/rails_ai_kit/classifier.rb
 - lib/rails_ai_kit/configuration.rb
 - lib/rails_ai_kit/embedding_providers/base.rb
 - lib/rails_ai_kit/embedding_providers/cohere.rb
 - lib/rails_ai_kit/embedding_providers/openai.rb
 - lib/rails_ai_kit/embedding_service.rb
+- lib/rails_ai_kit/eval.rb
+- lib/rails_ai_kit/guard_result.rb
+- lib/rails_ai_kit/guardrails.rb
+- lib/rails_ai_kit/guards/base.rb
+- lib/rails_ai_kit/guards/hallucination.rb
+- lib/rails_ai_kit/guards/pii.rb
+- lib/rails_ai_kit/guards/prompt_injection.rb
+- lib/rails_ai_kit/guards/toxicity.rb
 - lib/rails_ai_kit/label_record.rb
+- lib/rails_ai_kit/llm_client.rb
+- lib/rails_ai_kit/llm_providers/anthropic.rb
+- lib/rails_ai_kit/llm_providers/base.rb
+- lib/rails_ai_kit/llm_providers/custom.rb
+- lib/rails_ai_kit/llm_providers/google.rb
+- lib/rails_ai_kit/llm_providers/groq.rb
+- lib/rails_ai_kit/llm_providers/openai.rb
+- lib/rails_ai_kit/trace.rb
 - lib/rails_ai_kit/vector_classify.rb
 - lib/rails_ai_kit/version.rb
 homepage: https://github.com/imrrohitt/rails_ai_kit