leva 0.3.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '03694d16308b610d8c1cc83ec070cf2c0a03273d93b4e220834ff063f8df5b0a'
-  data.tar.gz: 31fa8e5737410dbb9b5729bf43616ef037fbad1c6b8188e60649a5156c8f87c1
+  metadata.gz: df2ad9b893851f23ca75b7f498279ff86b8687fa38d783bc5d33001327cd4928
+  data.tar.gz: 920b07a223df9e0f89f6e7f56d81270f12749b2afc9d47817d70069e17bab582
 SHA512:
-  metadata.gz: f12f9ec8d00a5dcd9a8c003a598d9ec316be4bd8b8b2deb7a99680a14dcd64790b496829e7635e28f5b86dd7a5f484b9043b504bda24f7e3d0fd75b8e4eee271
-  data.tar.gz: 293f53edc39d95ed612b0ce0e0e5097f38e888990c7e8530b54da6afcf2015ae7f150f8f9bd9d2bb1171c5bf18c0c4a34180482594c376ed17341ae42bce9f09
+  metadata.gz: 0c43f558d5e096512c90541d13d6dcc1d2d0cf4d08801aaf396829c0bf4f9c8ad3a7bd7d82a582efa55a99719fb54d70af44d5124ce3bd9c62affc9d2f2b69fe
+  data.tar.gz: 8880059ab2e141c2091fe0b2fc18581316dbc770109c1957e081a85413882e736373d9c00d791bab10b896e824ca68dae7bc02e72286fb8e7eb6bb5c16bf1a6c

data/README.md

@@ -81,6 +81,14 @@ class TextContent < ApplicationRecord
       created_at: created_at.strftime('%Y-%m-%d %H:%M:%S')
     }
   end
+
+  # Optional: Override for DSPy optimization (falls back to to_llm_context if not defined).
+  # Use this to provide a simplified context with only the fields needed for optimization.
+  # All values must be strings (nil values are automatically converted to empty strings).
+  # @return [Hash<Symbol, String>] Context hash for DSPy optimization
+  def to_dspy_context
+    { text: text }
+  end
 end
 
 dataset = Leva::Dataset.create(name: "Sentiment Analysis Dataset")
@@ -195,10 +203,13 @@ Add the DSPy gems to your Gemfile:
 
 ```ruby
 gem "dspy"           # Core DSPy functionality (required)
+gem "dspy-ruby_llm"  # RubyLLM provider adapter (required)
 gem "dspy-gepa"      # GEPA optimizer (optional, recommended)
 gem "dspy-miprov2"   # MIPROv2 optimizer (optional)
 ```
 
+You can use any DSPy provider adapter instead of `dspy-ruby_llm`, such as `dspy-openai` or `dspy-anthropic`.
+
 ### Available Optimizers
 
 | Optimizer | Best For | Description |
@@ -215,7 +226,7 @@ optimizer = Leva::PromptOptimizer.new(
   dataset: dataset,
   optimizer: :gepa,      # :bootstrap, :gepa, or :miprov2
   mode: :medium,         # :light, :medium, or :heavy
-  model: "gpt-4o-mini"   # Any model supported by RubyLLM
+  model: "claude-opus-4-5"   # Any model supported by RubyLLM
 )
 
 # Run optimization

data/app/controllers/leva/optimization_runs_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leva
+  class OptimizationRunsController < ApplicationController
+    before_action :set_optimization_run
+
+    # GET /optimization_runs/:id
+    # Shows the optimization progress page
+    # @return [void]
+    def show
+      respond_to do |format|
+        format.html
+        format.json { render json: @optimization_run }
+      end
+    end
+
+    private
+
+    # @return [void]
+    def set_optimization_run
+      @optimization_run = OptimizationRun.find(params[:id])
+    end
+  end
+end

data/app/helpers/leva/application_helper.rb

@@ -1,5 +1,26 @@
 module Leva
   module ApplicationHelper
+    # Returns the status of an optimization step.
+    #
+    # @param optimization_run [Leva::OptimizationRun] The optimization run
+    # @param step_key [String] The step key to check
+    # @return [String] 'completed', 'active', or 'pending'
+    def optimization_step_status(optimization_run, step_key)
+      steps = Leva::OptimizationRun::STEPS.keys
+      current_index = steps.index(optimization_run.current_step) || -1
+      step_index = steps.index(step_key)
+
+      return "pending" if step_index.nil?
+
+      if optimization_run.completed? || step_index < current_index
+        "completed"
+      elsif step_index == current_index
+        "active"
+      else
+        "pending"
+      end
+    end
+
     # Loads all evaluator classes that inherit from Leva::BaseEval
     #
     # @return [Array<Class>] An array of evaluator classes

data/app/jobs/leva/prompt_optimization_job.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Leva
+  # Background job for running prompt optimization with progress tracking.
+  #
+  # This job executes the optimization process asynchronously, updating
+  # the OptimizationRun record with progress for live UI updates.
+  #
+  # @example Enqueue an optimization job
+  #   run = OptimizationRun.create!(dataset: dataset, prompt_name: "My Prompt", mode: :light)
+  #   Leva::PromptOptimizationJob.perform_later(optimization_run_id: run.id)
+  class PromptOptimizationJob < ApplicationJob
+    queue_as :default
+
+    # Performs the prompt optimization and creates a new Prompt.
+    #
+    # @param optimization_run_id [Integer] The ID of the OptimizationRun to process
+    # @return [Leva::Prompt] The created optimized prompt
+    def perform(optimization_run_id:)
+      @run = OptimizationRun.find(optimization_run_id)
+      @run.start!
+
+      dataset = @run.dataset
+
+      optimizer = PromptOptimizer.new(
+        dataset: dataset,
+        mode: @run.mode.to_sym,
+        model: @run.model,
+        optimizer: @run.optimizer.to_sym,
+        progress_callback: method(:update_progress)
+      )
+
+      result = optimizer.optimize
+
+      ActiveRecord::Base.transaction do
+        prompt = Prompt.create!(
+          name: @run.prompt_name,
+          system_prompt: result[:system_prompt],
+          user_prompt: result[:user_prompt],
+          metadata: result[:metadata]
+        )
+
+        @run.complete!(prompt)
+        prompt
+      end
+    rescue ActiveRecord::RecordNotFound => e
+      Rails.logger.error "[Leva::PromptOptimizationJob] OptimizationRun not found: #{e.message}"
+      raise
+    rescue Leva::DspyConfigurationError => e
+      Rails.logger.error "[Leva::PromptOptimizationJob] Configuration error: #{e.message}"
+      @run&.fail!("Configuration error - please check server logs for details")
+      raise
+    rescue Leva::InsufficientDataError, Leva::OptimizationError => e
+      @run&.fail!(e)
+      Rails.logger.error "[Leva::PromptOptimizationJob] Optimization failed: #{e.message}"
+      raise
+    rescue StandardError => e
+      Rails.logger.error "[Leva::PromptOptimizationJob] Unexpected error: #{e.message}"
+      Rails.logger.error e.backtrace.first(10).join("\n")
+      @run&.fail!(e.message.truncate(500))
+      raise
+    end
+
+    private
+
+    # Callback for progress updates from the optimizer.
+    #
+    # @param step [String] Current step name
+    # @param progress [Integer] Progress percentage (0-100)
+    # @param examples_processed [Integer, nil] Number of examples processed
+    # @param total [Integer, nil] Total examples to process
+    # @return [void]
+    def update_progress(step:, progress:, examples_processed: nil, total: nil)
+      @run.update_progress(
+        step: step,
+        progress: progress,
+        examples_processed: examples_processed,
+        total: total
+      )
+    end
+  end
+end

data/app/models/leva/prompt.rb

@@ -16,7 +16,6 @@ module Leva
     has_many :experiments
 
     validates :name, presence: true
-    validates :system_prompt, presence: true
     validates :user_prompt, presence: true
 
     before_save :increment_version

data/app/services/leva/dataset_converter.rb

@@ -21,6 +21,7 @@ module Leva
     end
 
     # Converts all dataset records to DSPy example format.
+    # Uses to_dspy_context if available, otherwise falls back to to_llm_context.
     #
     # @return [Array<Hash>] Array of example hashes with :input and :expected keys
     def to_dspy_examples
@@ -28,8 +29,8 @@ module Leva
         next unless record.recordable
 
         {
-          input: record.recordable.to_llm_context,
-          expected: { output: record.recordable.ground_truth }
+          input: sanitize_context(context_for(record.recordable)),
+          expected: { output: record.recordable.ground_truth.to_s }
         }
       end.compact
     end
@@ -60,5 +61,28 @@ module Leva
     def valid_record_count
       to_dspy_examples.size
     end
+
+    private
+
+    # Returns the context for a recordable, preferring to_dspy_context if available.
+    #
+    # @param recordable [Object] The recordable object
+    # @return [Hash] The context hash
+    def context_for(recordable)
+      if recordable.respond_to?(:to_dspy_context)
+        recordable.to_dspy_context
+      else
+        recordable.to_llm_context
+      end
+    end
+
+    # Sanitizes context hash by converting nil values to empty strings.
+    # DSPy signatures require String types, not nil.
+    #
+    # @param context [Hash] The LLM context hash
+    # @return [Hash] Sanitized hash with nil values converted to empty strings
+    def sanitize_context(context)
+      context.transform_values { |v| v.nil? ? "" : v.to_s }
+    end
   end
 end

data/app/services/leva/prompt_optimizer.rb

@@ -181,6 +181,7 @@ module Leva
     end
 
     # Builds the final result hash from optimization.
+    # Follows DSPy-style format: instruction + examples + input in user prompt.
     #
     # @param result [Hash] The optimizer result with :instruction, :few_shot_examples, :score
     # @param splits [Hash] The data splits
@@ -188,15 +189,15 @@ module Leva
     # @return [Hash] The formatted result
     def build_final_result(result, splits, optimizer_type)
       sample_record = @dataset.dataset_records.first&.recordable
-      input_fields = sample_record&.to_llm_context&.keys || []
+      input_fields = context_for(sample_record)&.keys || []
 
       formatted_examples = result[:few_shot_examples].map do |ex|
         { input: ex[:input], output: ex.dig(:expected, :output) }
       end
 
       {
-        system_prompt: result[:instruction],
-        user_prompt: build_user_prompt_template(input_fields),
+        system_prompt: "",
+        user_prompt: build_dspy_user_prompt(result[:instruction], formatted_examples, input_fields),
         metadata: {
           optimization: {
             score: result[:score],
@@ -275,6 +276,20 @@ module Leva
       MSG
     end
 
+    # Returns the context for a recordable, preferring to_dspy_context if available.
+    #
+    # @param recordable [Object] The recordable object
+    # @return [Hash] The context hash
+    def context_for(recordable)
+      return nil unless recordable
+
+      if recordable.respond_to?(:to_dspy_context)
+        recordable.to_dspy_context
+      else
+        recordable.to_llm_context
+      end
+    end
+
     # Returns the default evaluation metric (case-insensitive exact match).
     # Handles both Hash examples and DSPy::Example objects.
     #
@@ -294,12 +309,41 @@ module Leva
       end
     end
 
-    # Builds the user prompt template with Liquid placeholders.
+    # Builds a DSPy-style user prompt with instruction, examples, and input placeholders.
     #
+    # @param instruction [String] The task instruction
+    # @param examples [Array<Hash>] The few-shot examples
     # @param input_fields [Array<Symbol>] The input field names
-    # @return [String] The user prompt template
-    def build_user_prompt_template(input_fields)
-      input_fields.map { |field| "{{ #{field} }}" }.join("\n\n")
+    # @return [String] The DSPy-style user prompt template
+    def build_dspy_user_prompt(instruction, examples, input_fields)
+      sections = []
+
+      # Instruction
+      sections << instruction if instruction.present?
+
+      # Few-shot examples (DSPy style)
+      if examples.any?
+        sections << ""
+        sections << "---"
+        sections << ""
+        examples.each_with_index do |example, index|
+          sections << "Example #{index + 1}:"
+          example[:input].each do |field, value|
+            sections << "#{field}: #{value}"
+          end
+          sections << "Output: #{example[:output]}"
+          sections << ""
+        end
+        sections << "---"
+      end
+
+      # Input placeholders (Liquid)
+      sections << ""
+      input_fields.each do |field|
+        sections << "#{field}: {{ #{field} }}"
+      end
+
+      sections.join("\n")
     end
   end
 end

data/app/services/leva/signature_generator.rb

@@ -43,14 +43,27 @@ module Leva
 
     private
 
-    # Extracts input fields from the sample record's LLM context.
+    # Extracts input fields from the sample record's context.
+    # Uses to_dspy_context if available, otherwise falls back to to_llm_context.
     #
     # @return [Hash<Symbol, Class>] Map of field names to their inferred types
     def extract_input_fields
-      context = @sample_record.to_llm_context
+      context = context_for(@sample_record)
       context.transform_values { |value| infer_type(value) }
     end
 
+    # Returns the context for a recordable, preferring to_dspy_context if available.
+    #
+    # @param recordable [Object] The recordable object
+    # @return [Hash] The context hash
+    def context_for(recordable)
+      if recordable.respond_to?(:to_dspy_context)
+        recordable.to_dspy_context
+      else
+        recordable.to_llm_context
+      end
+    end
+
     # Infers the Ruby type for a given value.
     #
     # @param value [Object] The value to analyze

data/app/views/leva/dataset_optimizations/new.html.erb

@@ -0,0 +1,257 @@
+<% content_for :title, "Optimize Prompt - #{@dataset.name}" %>
+<div class="container page">
+  <div class="page-header">
+    <div>
+      <div class="breadcrumb mb-2">
+        <%= link_to "Datasets", datasets_path, class: "breadcrumb-link" %>
+        <span class="breadcrumb-sep">/</span>
+        <%= link_to @dataset.name, dataset_path(@dataset), class: "breadcrumb-link" %>
+        <span class="breadcrumb-sep">/</span>
+        <span class="breadcrumb-current">Optimize Prompt</span>
+      </div>
+      <h1 class="page-title">Optimize Prompt</h1>
+      <p class="text-muted text-sm mt-2" style="max-width: 600px;">
+        Use DSPy.rb to automatically discover optimal prompt instructions and few-shot examples for your dataset.
+      </p>
+    </div>
+  </div>
+
+  <section class="mb-8">
+    <div class="card">
+      <div class="card-header">
+        <h3 class="card-title">Dataset Information</h3>
+      </div>
+      <div class="card-body">
+        <div class="grid grid-cols-2 gap-4">
+          <div>
+            <label class="text-muted text-xs uppercase tracking-wide">Dataset</label>
+            <p class="text-lg font-medium"><%= @dataset.name %></p>
+          </div>
+          <div>
+            <label class="text-muted text-xs uppercase tracking-wide">Records</label>
+            <p class="text-lg font-medium">
+              <%= @record_count %>
+              <% if @can_optimize %>
+                <span class="badge badge-success ml-2">Ready</span>
+              <% else %>
+                <span class="badge badge-warning ml-2">Need <%= @records_needed %> more</span>
+              <% end %>
+            </p>
+          </div>
+        </div>
+        <p class="text-xs text-muted mt-4">
+          Minimum <%= Leva::PromptOptimizer::MINIMUM_EXAMPLES %> records required for optimization.
+        </p>
+      </div>
+    </div>
+  </section>
+
+  <% if @can_optimize %>
+    <section>
+      <div class="card">
+        <div class="card-header">
+          <h3 class="card-title">Optimization Settings</h3>
+        </div>
+        <div class="card-body">
+          <%= form_with url: dataset_optimization_path(@dataset), method: :post, local: true do |f| %>
+            <div class="form-group mb-4">
+              <%= f.label :prompt_name, "Prompt Name", class: "form-label" %>
+              <%= f.text_field :prompt_name,
+                  value: "Optimized: #{@dataset.name}",
+                  class: "form-input",
+                  placeholder: "Enter a name for the optimized prompt" %>
+              <p class="form-hint">The name for the new prompt that will be created.</p>
+            </div>
+
+            <div class="form-group mb-4">
+              <%= f.label :model, "Model", class: "form-label" %>
+              <%= f.select :model,
+                  @models.map { |m| ["#{m.name} (#{m.provider})", m.id] },
+                  { selected: Leva::PromptOptimizer::DEFAULT_MODEL },
+                  class: "form-select" %>
+              <p class="form-hint">The AI model to use for optimization. Make sure you have the API key configured.</p>
+            </div>
+
+            <div class="form-group mb-6">
+              <%= f.label :optimizer, "Optimizer", class: "form-label" %>
+              <div class="radio-group">
+                <% @optimizers.each do |key, config| %>
+                  <label class="radio-card <%= 'disabled' unless Leva::PromptOptimizer.optimizer_available?(key) %>">
+                    <%= f.radio_button :optimizer, key,
+                        checked: key == :bootstrap,
+                        disabled: !Leva::PromptOptimizer.optimizer_available?(key),
+                        class: "radio-input" %>
+                    <div class="radio-content">
+                      <span class="radio-title">
+                        <%= config[:name] %>
+                        <% unless Leva::PromptOptimizer.optimizer_available?(key) %>
+                          <span class="badge badge-muted ml-2">Requires <%= config[:gem] %></span>
+                        <% end %>
+                      </span>
+                      <span class="radio-description"><%= config[:description] %></span>
+                    </div>
+                  </label>
+                <% end %>
+              </div>
+            </div>
+
+            <div class="form-group mb-6">
+              <%= f.label :mode, "Optimization Mode", class: "form-label" %>
+              <div class="radio-group">
+                <% @modes.each do |mode, config| %>
+                  <label class="radio-card">
+                    <%= f.radio_button :mode, mode, checked: mode == :light, class: "radio-input" %>
+                    <div class="radio-content">
+                      <span class="radio-title"><%= mode.to_s.capitalize %></span>
+                      <span class="radio-description"><%= config[:description] %></span>
+                    </div>
+                  </label>
+                <% end %>
+              </div>
+            </div>
+
+            <div class="alert alert-info mb-6">
+              <svg class="icon-sm" viewBox="0 0 20 20" fill="currentColor">
+                <path fill-rule="evenodd" d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a1 1 0 000 2v3a1 1 0 001 1h1a1 1 0 100-2v-3a1 1 0 00-1-1H9z" clip-rule="evenodd" />
+              </svg>
+              <div>
+                <p class="font-medium">How it works</p>
+                <p class="text-sm mt-1">
+                  The optimizer will analyze your dataset records to find the best prompt instructions
+                  and select optimal few-shot examples. The process runs in the background.
+                </p>
+              </div>
+            </div>
+
+            <div class="flex gap-3">
+              <%= f.submit "Start Optimization", class: "btn btn-primary" %>
+              <%= link_to "Cancel", dataset_path(@dataset), class: "btn btn-ghost" %>
+            </div>
+          <% end %>
+        </div>
+      </div>
+    </section>
+  <% else %>
+    <section>
+      <div class="card">
+        <div class="card-body">
+          <div class="empty-state">
+            <svg class="empty-state-icon" viewBox="0 0 20 20" fill="currentColor">
+              <path fill-rule="evenodd" d="M8.257 3.099c.765-1.36 2.722-1.36 3.486 0l5.58 9.92c.75 1.334-.213 2.98-1.742 2.98H4.42c-1.53 0-2.493-1.646-1.743-2.98l5.58-9.92zM11 13a1 1 0 11-2 0 1 1 0 012 0zm-1-8a1 1 0 00-1 1v3a1 1 0 002 0V6a1 1 0 00-1-1z" clip-rule="evenodd" />
+            </svg>
+            <h3 class="empty-state-title">Not Enough Data</h3>
+            <p class="empty-state-description">
+              Add at least <%= @records_needed %> more records to enable prompt optimization.
+              The optimizer requires a minimum of <%= Leva::PromptOptimizer::MINIMUM_EXAMPLES %> records
+              to find meaningful patterns.
+            </p>
+            <div class="mt-4">
+              <%= link_to "Back to Dataset", dataset_path(@dataset), class: "btn btn-primary" %>
+            </div>
+          </div>
+        </div>
+      </div>
+    </section>
+  <% end %>
+</div>
+
+<style>
+  .radio-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+  }
+
+  .radio-card {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.75rem;
+    padding: 1rem;
+    border: 1px solid var(--border-color);
+    border-radius: 0.5rem;
+    cursor: pointer;
+    transition: border-color 0.15s, background-color 0.15s;
+  }
+
+  .radio-card:hover {
+    border-color: var(--primary);
+    background-color: var(--bg-secondary);
+  }
+
+  .radio-card:has(.radio-input:checked) {
+    border-color: var(--primary);
+    background-color: var(--bg-secondary);
+  }
+
+  .radio-input {
+    margin-top: 0.25rem;
+  }
+
+  .radio-content {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+
+  .radio-title {
+    font-weight: 500;
+  }
+
+  .radio-description {
+    font-size: 0.875rem;
+    color: var(--text-muted);
+  }
+
+  .badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 0.125rem 0.5rem;
+    font-size: 0.75rem;
+    font-weight: 500;
+    border-radius: 9999px;
+  }
+
+  .badge-success {
+    background-color: rgba(34, 197, 94, 0.15);
+    color: rgb(34, 197, 94);
+  }
+
+  .badge-warning {
+    background-color: rgba(234, 179, 8, 0.15);
+    color: rgb(234, 179, 8);
+  }
+
+  .badge-muted {
+    background-color: var(--bg-secondary);
+    color: var(--text-muted);
+    font-size: 0.65rem;
+  }
+
+  .radio-card.disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .radio-card.disabled:hover {
+    border-color: var(--border-color);
+    background-color: transparent;
+  }
+
+  .alert {
+    display: flex;
+    gap: 0.75rem;
+    padding: 1rem;
+    border-radius: 0.5rem;
+  }
+
+  .alert-info {
+    background-color: rgba(59, 130, 246, 0.1);
+    border: 1px solid rgba(59, 130, 246, 0.2);
+    color: var(--text-primary);
+  }
+
+  .alert-info svg {
+    color: rgb(59, 130, 246);
+    flex-shrink: 0;
+  }
+</style>

data/app/views/leva/datasets/show.html.erb

@@ -84,8 +84,69 @@
     <% end %>
   </section>
 
-  <%# Optimized Prompts Section - TODO: Enable when DSPy routes are added %>
-  <%# This feature is available in the PromptOptimizer service but UI routes are pending %>
+  <%# Prompt Optimization Section %>
+  <section class="mb-8">
+    <div class="section-header">
+      <h3 class="section-title">Prompt Optimization</h3>
+      <span class="section-count"><%= @dataset.optimization_runs.count %></span>
+      <div class="ml-auto">
+        <% optimizer = Leva::PromptOptimizer.new(dataset: @dataset) %>
+        <% if optimizer.can_optimize? %>
+          <%= link_to new_dataset_optimization_path(@dataset), class: "btn btn-primary btn-sm" do %>
+            <svg class="icon-sm" viewBox="0 0 20 20" fill="currentColor">
+              <path fill-rule="evenodd" d="M11.3 1.046A1 1 0 0112 2v5h4a1 1 0 01.82 1.573l-7 10A1 1 0 018 18v-5H4a1 1 0 01-.82-1.573l7-10a1 1 0 011.12-.38z" clip-rule="evenodd" />
+            </svg>
+            Optimize Prompt
+          <% end %>
+        <% else %>
+          <button class="btn btn-ghost btn-sm" disabled title="Need <%= optimizer.records_needed %> more records">
+            <svg class="icon-sm" viewBox="0 0 20 20" fill="currentColor">
+              <path fill-rule="evenodd" d="M11.3 1.046A1 1 0 0112 2v5h4a1 1 0 01.82 1.573l-7 10A1 1 0 018 18v-5H4a1 1 0 01-.82-1.573l7-10a1 1 0 011.12-.38z" clip-rule="evenodd" />
+            </svg>
+            Need <%= optimizer.records_needed %> more records
+          </button>
+        <% end %>
+      </div>
+    </div>
+
+    <% if @dataset.optimization_runs.any? %>
+      <div class="table-wrapper">
+        <div class="table-scroll">
+          <table class="table table-clickable">
+            <thead>
+              <tr>
+                <th>Prompt Name</th>
+                <th>Optimizer</th>
+                <th>Mode</th>
+                <th>Status</th>
+                <th class="text-right">Created</th>
+              </tr>
+            </thead>
+            <tbody>
+              <% @dataset.optimization_runs.order(created_at: :desc).each do |run| %>
+                <tr class="clickable-row" onclick="window.location='<%= optimization_run_path(run) %>'">
+                  <td><span class="row-title"><%= run.prompt_name %></span></td>
+                  <td><%= run.optimizer&.titleize || 'Bootstrap' %></td>
+                  <td><%= run.mode&.titleize || 'Light' %></td>
+                  <td>
+                    <span class="badge badge-<%= run.status == 'completed' ? 'success' : (run.status == 'failed' ? 'error' : 'warning') %>">
+                      <%= run.status&.titleize || 'Pending' %>
+                    </span>
+                  </td>
+                  <td class="text-right text-muted"><%= time_ago_in_words(run.created_at) %> ago</td>
+                </tr>
+              <% end %>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    <% else %>
+      <div class="empty-state-inline">
+        <p class="text-muted text-sm">No optimization runs yet.</p>
+        <p class="text-xs text-subtle mt-2">Use DSPy to optimize your prompts with few-shot examples.</p>
+      </div>
+    <% end %>
+  </section>
 
   <%# Experiments Section %>
   <section>
@@ -126,6 +187,7 @@
               </tr>
             </thead>
             <tbody>
+              <% @evaluator_classes = Leva::EvaluationResult.distinct.pluck(:evaluator_class) %>
               <%= render partial: 'leva/experiments/experiment', collection: @dataset.experiments %>
             </tbody>
           </table>

data/config/routes.rb

@@ -3,8 +3,11 @@ Leva::Engine.routes.draw do
 
   get "design_system", to: "design_system#index"
 
+  resources :optimization_runs, only: [ :show ]
+
   resources :datasets do
     resources :dataset_records, path: "records", only: [ :index, :show ]
+    resource :optimization, only: [ :new, :create ], controller: "dataset_optimizations"
   end
   resources :experiments, except: [ :destroy ] do
     member do

data/lib/leva/dspy_runner.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Leva
+  # Base class for runners that use DSPy.rb for LLM execution.
+  #
+  # DspyRunner extends BaseRun to provide integration with DSPy.rb,
+  # automatically loading optimized instructions and few-shot examples
+  # from the prompt's metadata.
+  #
+  # @example Create a custom DSPy runner
+  #   class SentimentRunner < Leva::DspyRunner
+  #     # DspyRunner handles the execution automatically
+  #     # using the optimized prompt from the experiment
+  #   end
+  #
+  # @example Override for custom behavior
+  #   class CustomRunner < Leva::DspyRunner
+  #     def execute(record)
+  #       context = merged_llm_context
+  #       # Custom execution logic here
+  #     end
+  #   end
+  class DspyRunner < BaseRun
+    # Executes the DSPy predictor on the given record.
+    #
+    # @param record [Object] The recordable object to process
+    # @return [String] The model's prediction
+    def execute(record)
+      context = merged_llm_context
+
+      if optimized_prompt?
+        execute_with_optimization(context)
+      else
+        execute_simple(context)
+      end
+    end
+
+    private
+
+    # Checks if the prompt has optimization metadata.
+    #
+    # @return [Boolean] True if the prompt has optimization data
+    def optimized_prompt?
+      @prompt&.metadata&.dig("optimization", "few_shot_examples").present?
+    end
+
+    # Executes with optimized instruction and few-shot examples.
+    #
+    # @param context [Hash] The merged LLM context
+    # @return [String] The prediction
+    def execute_with_optimization(context)
+      # In a full implementation, this would:
+      # 1. Load the DSPy signature
+      # 2. Create a predictor with the optimized instruction
+      # 3. Add few-shot examples
+      # 4. Execute and return the result
+
+      # For now, we render the prompt template and return a placeholder
+      # that indicates this needs actual DSPy integration
+      instruction = @prompt.system_prompt
+      user_prompt = render_user_prompt(context)
+      few_shot_examples = @prompt.metadata.dig("optimization", "few_shot_examples") || []
+
+      # Build a formatted prompt string for demonstration
+      build_prompt_string(instruction, few_shot_examples, user_prompt)
+    end
+
+    # Executes a simple prediction without optimization.
+    #
+    # @param context [Hash] The merged LLM context
+    # @return [String] The prediction
+    def execute_simple(context)
+      instruction = @prompt&.system_prompt || ""
+      user_prompt = render_user_prompt(context)
+
+      "#{instruction}\n\n#{user_prompt}"
+    end
+
+    # Renders the user prompt template with the given context.
+    #
+    # @param context [Hash] The context for template rendering
+    # @return [String] The rendered prompt
+    def render_user_prompt(context)
+      return "" unless @prompt&.user_prompt
+
+      template = Liquid::Template.parse(@prompt.user_prompt)
+      template.render(context.stringify_keys)
+    end
+
+    # Builds a formatted prompt string including few-shot examples.
+    #
+    # @param instruction [String] The system instruction
+    # @param examples [Array<Hash>] The few-shot examples
+    # @param user_prompt [String] The user's input prompt
+    # @return [String] The formatted prompt
+    def build_prompt_string(instruction, examples, user_prompt)
+      parts = []
+      parts << instruction if instruction.present?
+
+      if examples.any?
+        parts << "\n--- Examples ---"
+        examples.each_with_index do |example, index|
+          parts << "\nExample #{index + 1}:"
+          parts << "Input: #{example['input'].to_json}"
+          parts << "Output: #{example['output']}"
+        end
+        parts << "\n--- Your Turn ---"
+      end
+
+      parts << user_prompt if user_prompt.present?
+
+      parts.join("\n")
+    end
+
+    # Generates a signature class for the current dataset.
+    #
+    # @return [Class] The generated signature class
+    def build_signature
+      SignatureGenerator.new(@experiment.dataset).generate
+    end
+  end
+end

data/lib/leva/version.rb

@@ -1,3 +1,3 @@
 module Leva
-  VERSION = "0.3.1"
+  VERSION = "0.3.3"
 end

data/lib/leva.rb

@@ -158,3 +158,6 @@ module Leva
     end
   end
 end
+
+# Load DspyRunner after BaseRun is defined
+require "leva/dspy_runner"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leva
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Kieran Klaassen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-07 00:00:00.000000000 Z
+date: 2025-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -58,6 +58,7 @@ files:
 - app/controllers/leva/datasets_controller.rb
 - app/controllers/leva/design_system_controller.rb
 - app/controllers/leva/experiments_controller.rb
+- app/controllers/leva/optimization_runs_controller.rb
 - app/controllers/leva/runner_results_controller.rb
 - app/controllers/leva/workbench_controller.rb
 - app/helpers/leva/application_helper.rb
@@ -65,6 +66,7 @@ files:
 - app/javascript/controllers/prompt_selector_controller.js
 - app/jobs/leva/application_job.rb
 - app/jobs/leva/experiment_job.rb
+- app/jobs/leva/prompt_optimization_job.rb
 - app/jobs/leva/run_eval_job.rb
 - app/mailers/leva/application_mailer.rb
 - app/models/concerns/leva/recordable.rb
@@ -85,6 +87,7 @@ files:
 - app/services/leva/prompt_optimizer.rb
 - app/services/leva/signature_generator.rb
 - app/views/layouts/leva/application.html.erb
+- app/views/leva/dataset_optimizations/new.html.erb
 - app/views/leva/dataset_records/index.html.erb
 - app/views/leva/dataset_records/show.html.erb
 - app/views/leva/datasets/_dataset.html.erb
@@ -124,6 +127,7 @@ files:
 - lib/generators/leva/templates/eval.rb.erb
 - lib/generators/leva/templates/runner.rb.erb
 - lib/leva.rb
+- lib/leva/dspy_runner.rb
 - lib/leva/engine.rb
 - lib/leva/errors.rb
 - lib/leva/version.rb