AI-first toolkit for Rails — two core features today, more on the way.

Source code · RubyGems

Rails AI Kit currently provides two independent feature sets. Use one, both, or add more as the gem evolves.

More features (evals, tool use, etc.) are planned — the gem is actively developed.

Guardrails wrap LLM calls with safety checks. You get a generated response plus scores; you decide allow/block by threshold. Checks run on both the model output and the user prompt (so toxic or injection-style inputs are detected even if the model refuses to comply).

• RailsAiKit.guard(prompt:, model:, checks:, threshold:) — One call: generate + run checks. Returns GuardResult with output, safe?, scores, action (:allow / :block).
• Guards: toxicity, PII, hallucination, prompt injection (each uses an LLM-as-judge or keyword rules).
• Prompt + output: Toxicity and prompt-injection also evaluate the user prompt; final toxicity = max(prompt_toxicity, output_toxicity). Keyword safety net for obvious offensive language.
• Rails macro: ai_generate :summary, from: :content, guards: [...] → article.ai_summary (generate then guard).
• Eval: RailsAiKit.eval(dataset: "eval.json", model:) → accuracy, hallucination rate, toxicity failures.
• AI Traces: Optional rails_ai_traces table + /ai_traces dashboard to inspect prompts, responses, scores, and latency.

One config, same API: OpenAI, Anthropic (Claude), Google (Gemini), Groq, or custom (any OpenAI-compatible endpoint via llm_url + llm_key).

result = RailsAiKit.guard(
  prompt: "What is the capital of France?",
  model: "gpt-4o-mini",
  checks: [:toxicity, :hallucination],
  threshold: 0.8
)

result.output   # => "The capital of France is Paris."
result.safe?    # => true
result.scores   # => { "toxicity" => 0.0, "hallucination" => 0.0, "label" => "factual" }
result.action   # => :allow

Toxic or injection-style prompts are scored (including a keyword safety net); if any score exceeds threshold, action is :block.

Vector classification uses embeddings + pgvector to assign labels to text. You train each label with example phrases; the gem embeds them, stores one vector per label, and classifies new content by nearest-neighbor (cosine distance). No ML training and no LLM call per classification — only an embedding API (OpenAI or Cohere).

• Train labels: RailsAiKit.classifier("Article").train("sports", examples: ["football match", "cricket"]) → one vector per label in rails_ai_kit_labels.
• Auto-classify on save: Add vector_classify :content, labels: ["sports", "politics", "tech"] to your model. On save, the gem embeds content, stores it, compares to label vectors, and sets label and confidence_score.
• Classify without saving: RailsAiKit.classifier("Article").classify("India won the cricket match") → { label: "sports", confidence: 0.91 }.
• Batch classify: RailsAiKit.classifier("Article").batch_classify(records, text_attribute: :content).
• Similarity search: Article.similar_to("new iPhone launch", limit: 5).
• Filtering: Article.where(label: "sports"), Article.where("confidence_score >= ?", 0.8).

# 1. Train labels once
c = RailsAiKit.classifier("Article")
c.train("sports", examples: ["football match", "cricket tournament"])
c.train("technology", examples: ["new iPhone launch", "AI update"])

# 2. Model
class Article < ApplicationRecord
  vector_classify :content, labels: ["sports", "politics", "technology"]
end

# 3. Create record → auto-classified
article = Article.create!(content: "Apple released a new iPhone")
article.label            # => "technology"
article.confidence_score # => 0.91

• Rails 6+
• PostgreSQL with pgvector (for vector classification only)
• Embedding API (OpenAI or Cohere) for vector classification
• LLM API (OpenAI, Anthropic, Google, Groq, or custom) for Guardrails / ai_generate / Eval

# Gemfile
gem "rails_ai_kit"

bundle install
rails g rails_ai_kit:install
rails db:migrate

The install generator adds:

• pgvector and tables: rails_ai_kit_labels (for vector classification), rails_ai_traces (for Guardrails tracing)
• Initializer: config/initializers/rails_ai_kit.rb

Edit config/initializers/rails_ai_kit.rb:

RailsAiKit.configure do |config|
  # ----- Vector classification (embeddings) -----
  config.embedding_provider = :openai
  config.embedding_dimensions = 1536
  config.api_keys = {
    openai: ENV["OPENAI_API_KEY"],
    cohere: ENV["COHERE_API_KEY"]
  }
  config.default_classifier_name = "default"

  # ----- Guardrails (LLM) -----
  config.llm_provider = :openai
  config.default_llm_model = "gpt-4o-mini"
  config.llm_api_keys = {
    openai: ENV["OPENAI_API_KEY"],
    anthropic: ENV["ANTHROPIC_API_KEY"],
    google: ENV["GOOGLE_AI_API_KEY"],
    groq: ENV["GROQ_API_KEY"]
  }
  # Custom endpoint:
  # config.llm_provider = :custom
  # config.llm_url = "https://your-llm.example.com/v1"
  # config.llm_key = ENV["CUSTOM_LLM_KEY"]

  config.trace_llm_calls = true
end

Use env vars or Rails credentials; do not commit API keys.

For models you want to classify:

rails g rails_ai_kit:vector_columns Article content
rails db:migrate

Adds embedding, label, confidence_score to the table.

ai_generate macro (Guardrails):

class Article < ApplicationRecord
  ai_generate :summary,
    from: :content,
    prompt_template: "Summarize in 2–3 sentences:\n\n%{text}",
    guards: [:toxicity, :hallucination],
    threshold: 0.85
end
article.ai_summary  # => generated summary or nil if blocked

vector_classify macro:

class Article < ApplicationRecord
  vector_classify :content,
    labels: ["sports", "politics", "technology"],
    classifier_name: "Article"
end
# On save: embed content → store embedding → set label & confidence_score

RailsAiKit.embed("some text")
RailsAiKit.embedding.embed_batch(["a", "b"])

1. You call RailsAiKit.guard(prompt:, model:, checks:, threshold:).
2. The gem generates a response with the configured LLM.
3. It runs the requested checks (toxicity, PII, hallucination, prompt injection) on the output and, for toxicity/prompt_injection, on the user prompt (in parallel where possible). Keyword rules backstop obvious offensive prompts.
4. It merges scores and sets action to :block if any score exceeds threshold.
5. Optionally it records the run in rails_ai_traces.

1. You train labels with example texts; the gem embeds them and stores one vector per label in rails_ai_kit_labels.
2. When you save a record with vector_classify, the gem embeds the source column, stores the vector, and finds the nearest label (cosine distance). It sets label and confidence_score.
3. Similarity search uses the same embedding column and pgvector nearest-neighbor.

• Guardrails: More guards, configurable keyword lists, retry/fallback behavior.
• Vector classification: Hierarchical labels, confidence threshold, hybrid search, incremental learning.
• More features: Additional AI capabilities as the gem evolves.

bundle install
bundle exec rake install

MIT.

• pgvector – Vector similarity search for Postgres
• Neighbor – Nearest neighbor search for Rails (used for vector classification)

Rohit Kushwaha — AI Engineer