Rails AI

gem 'rails_ai'

# config/initializers/rails_ai.rb
RailsAi.configure do |config|
  config.provider = :openai  # or :anthropic, :gemini, :dummy
  config.default_model = "gpt-5"  # Latest GPT-5 model!
  config.token_limit = 4000
  config.cache_ttl = 1.hour
  config.stub_responses = false
end

# Text generation
response = RailsAi.chat("Write a blog post about AI")
puts response

# Image generation
image = RailsAi.generate_image("A sunset over mountains", model: "dall-e-3")
puts image

# Video generation
video = RailsAi.generate_video("A cat playing with a ball", model: "sora")
puts video

# Audio generation
speech = RailsAi.generate_speech("Hello world", voice: "alloy")
puts speech

# Image analysis
analysis = RailsAi.analyze_image(image_file, "What do you see?")
puts analysis

# Create specialized agents
research_agent = RailsAi.create_research_agent(name: "ResearchBot")
creative_agent = RailsAi.create_creative_agent(name: "CreativeBot")
tech_agent = RailsAi.create_technical_agent(name: "TechBot")
coordinator = RailsAi.create_coordinator_agent(name: "CoordinatorBot")

# Start the agent system
RailsAi.start_agents!

# Create a content creation team
content_team = RailsAi.create_agent_team(
  "ContentTeam",
  [research_agent, creative_agent, coordinator],
  strategy: :collaborative
)

# Assign tasks to the team
content_team.assign_task({
  description: "Create a comprehensive marketing strategy",
  type: :creative
})

# Agents can communicate with each other
RailsAi.send_agent_message("ResearchBot", "CreativeBot", {
  type: :research_findings,
  data: "AI market will reach $1.8T by 2030"
})

# Broadcast messages to all agents
RailsAi.broadcast_agent_message("CoordinatorBot", {
  type: :status_update,
  message: "All systems operational"
})

# Submit tasks to the system
task = RailsAi.submit_task({
  id: "task_001",
  description: "Analyze customer feedback data",
  required_capabilities: [:analysis, :data_processing],
  priority: :high
})

# Auto-assign to best agent
RailsAi.auto_assign_task(task)

# Or manually assign
RailsAi.assign_task(task, "ResearchBot")

# Create content creation workflow
def create_blog_post(topic)
  # Research phase
  research_task = {
    description: "Research #{topic} for blog post",
    type: :analysis
  }
  content_team.assign_task(research_task)
  
  # Writing phase
  writing_task = {
    description: "Write blog post about #{topic}",
    type: :creative,
    dependencies: [research_task[:id]]
  }
  content_team.assign_task(writing_task)
  
  # Editing phase
  editing_task = {
    description: "Edit and optimize blog post",
    type: :problem_solving,
    dependencies: [writing_task[:id]]
  }
  content_team.assign_task(editing_task)
end

# Create support agents
triage_agent = RailsAi.create_agent(
  name: "TriageAgent",
  role: "Support Triage",
  capabilities: [:classification, :routing]
)

technical_agent = RailsAi.create_technical_agent(name: "TechSupport")
billing_agent = RailsAi.create_agent(
  name: "BillingAgent",
  role: "Billing Support",
  capabilities: [:billing, :account_management]
)

# Support workflow
def handle_support_ticket(ticket)
  # Triage the ticket
  triage_result = triage_agent.think("Classify this support ticket: #{ticket[:description]}")
  
  case triage_result
  when /technical/
    technical_agent.assign_task(ticket)
  when /billing/
    billing_agent.assign_task(ticket)
  else
    # Escalate to human
    Rails.logger.info("Ticket requires human intervention: #{ticket[:id]}")
  end
end

# Create R&D team
researcher = RailsAi.create_research_agent(name: "R&D_Researcher")
architect = RailsAi.create_technical_agent(name: "SystemArchitect")
prototyper = RailsAi.create_creative_agent(name: "PrototypeDesigner")
coordinator = RailsAi.create_coordinator_agent(name: "R&D_Coordinator")

# R&D workflow
def develop_new_feature(requirements)
  # Research phase
  research_task = {
    description: "Research existing solutions for #{requirements[:feature]}",
    type: :analysis
  }
  researcher.assign_task(research_task)
  
  # Architecture phase
  architecture_task = {
    description: "Design architecture for #{requirements[:feature]}",
    type: :problem_solving,
    dependencies: [research_task[:id]]
  }
  architect.assign_task(architecture_task)
  
  # Prototype phase
  prototype_task = {
    description: "Create prototype for #{requirements[:feature]}",
    type: :creative,
    dependencies: [architecture_task[:id]]
  }
  prototyper.assign_task(prototype_task)
  
  # Coordination
  coordinator.coordinate_task(requirements, [researcher, architect, prototyper])
end

# User context
user_context = RailsAi::UserContext.new(
  id: 123,
  email: "user@example.com",
  role: "premium",
  preferences: { language: "en", theme: "dark" }
)

# Window context
window_context = RailsAi::WindowContext.from_controller(self)

# Generate with context
response = RailsAi.generate_with_context(
  "Write a personalized email",
  user_context: user_context,
  window_context: window_context
)

# Warm up the system
RailsAi.warmup!

# Check performance metrics
metrics = RailsAi.metrics
puts "Average response time: #{metrics[:average_response_time]}ms"

# Clear cache if needed
RailsAi.clear_cache!

# Check system status
status = RailsAi.agent_system_status
puts "Active agents: #{status[:active_agents]}"
puts "Pending tasks: #{status[:pending_tasks]}"

# Health check
health = RailsAi.agent_health_check
puts "System healthy: #{health[:system_healthy]}"

# In your tests
RSpec.describe "AI Features" do
  before do
    RailsAi.configure do |config|
      config.provider = :dummy
      config.stub_responses = true
    end
  end

  it "generates content" do
    result = RailsAi.chat("Hello")
    expect(result).to include("Hello")
  end
end