ratacat/claude-skills/dspy-ruby

Claude Code and agent skill by ratacat/claude-skills

Trust tier 2
  • community
LLM review pending
Source check pending

Checking that the SKILL.md file is still in the repository.

This skill should be used when working with DSPy.rb, a Ruby framework for building type-safe, composable LLM applications. Use this when implementing predictable AI features, creating LLM signatures and modules, configuring language model providers (OpenAI, Anthropic, Gemini, Ollama), building agent systems with tools, optimizing prompts, or testing LLM-powered functionality in Ruby applications.

Install

npx vskill@latest install ratacat/claude-skills/dspy-ruby

SKILL.md

DSPy.rb Expert

Overview

DSPy.rb is a Ruby framework that enables developers to program LLMs, not prompt them. Instead of manually crafting prompts, define application requirements through type-safe, composable modules that can be tested, optimized, and version-controlled like regular code.

This skill provides comprehensive guidance on:

  • Creating type-safe signatures for LLM operations
  • Building composable modules and workflows
  • Configuring multiple LLM providers
  • Implementing agents with tools
  • Testing and optimizing LLM applications
  • Production deployment patterns

Core Capabilities

1. Type-Safe Signatures

Create input/output contracts for LLM operations with runtime type checking.

When to use: Defining any LLM task, from simple classification to complex analysis.

Quick reference:

ruby
class EmailClassificationSignature < DSPy::Signature
  description "Classify customer support emails"
 
  input do
    const :email_subject, String
    const :email_body, String
  end
 
  output do
    const :category, T.enum(["Technical", "Billing", "General"])
    const :priority, T.enum(["Low", "Medium", "High"])
  end
end

Templates: See assets/signature-template.rb for comprehensive examples including:

  • Basic signatures with multiple field types
  • Vision signatures for multimodal tasks
  • Sentiment analysis signatures
  • Code generation signatures

Best practices:

  • Always provide clear, specific descriptions
  • Use enums for constrained outputs
  • Include field descriptions with desc: parameter
  • Prefer specific types over generic String when possible

Full documentation: See references/core-concepts.md sections on Signatures and Type Safety.

2. Composable Modules

Build reusable, chainable modules that encapsulate LLM operations.

When to use: Implementing any LLM-powered feature, especially complex multi-step workflows.

Quick reference:

ruby
class EmailProcessor < DSPy::Module
  def initialize
    super
    @classifier = DSPy::Predict.new(EmailClassificationSignature)
  end
 
  def forward(email_subject:, email_body:)
    @classifier.forward(
      email_subject: email_subject,
      email_body: email_body
    )
  end
end

Templates: See assets/module-template.rb for comprehensive examples including:

  • Basic modules with single predictors
  • Multi-step pipelines that chain modules
  • Modules with conditional logic
  • Error handling and retry patterns
  • Stateful modules with history
  • Caching implementations

Module composition: Chain modules together to create complex workflows:

ruby
class Pipeline < DSPy::Module
  def initialize
    super
    @step1 = Classifier.new
    @step2 = Analyzer.new
    @step3 = Responder.new
  end
 
  def forward(input)
    result1 = @step1.forward(input)
    result2 = @step2.forward(result1)
    @step3.forward(result2)
  end
end

Full documentation: See references/core-concepts.md sections on Modules and Module Composition.

3. Multiple Predictor Types

Choose the right predictor for your task:

Predict: Basic LLM inference with type-safe inputs/outputs

ruby
predictor = DSPy::Predict.new(TaskSignature)
result = predictor.forward(input: "data")

ChainOfThought: Adds automatic reasoning for improved accuracy

ruby
predictor = DSPy::ChainOfThought.new(TaskSignature)
result = predictor.forward(input: "data")
# Returns: { reasoning: "...", output: "..." }

ReAct: Tool-using agents with iterative reasoning

ruby
predictor = DSPy::ReAct.new(
  TaskSignature,
  tools: [SearchTool.new, CalculatorTool.new],
  max_iterations: 5
)

CodeAct: Dynamic code generation (requires dspy-code_act gem)

ruby
predictor = DSPy::CodeAct.new(TaskSignature)
result = predictor.forward(task: "Calculate factorial of 5")

When to use each:

  • Predict: Simple tasks, classification, extraction
  • ChainOfThought: Complex reasoning, analysis, multi-step thinking
  • ReAct: Tasks requiring external tools (search, calculation, API calls)
  • CodeAct: Tasks best solved with generated code

Full documentation: See references/core-concepts.md section on Predictors.

4. LLM Provider Configuration

Support for OpenAI, Anthropic Claude, Google Gemini, Ollama, and OpenRouter.

Quick configuration examples:

ruby
# OpenAI
DSPy.configure do |c|
  c.lm = DSPy::LM.new('openai/gpt-4o-mini',
    api_key: ENV['OPENAI_API_KEY'])
end
 
# Anthropic Claude
DSPy.configure do |c|
  c.lm = DSPy::LM.new('anthropic/claude-3-5-sonnet-20241022',
    api_key: ENV['ANTHROPIC_API_KEY'])
end
 
# Google Gemini
DSPy.configure do |c|
  c.lm = DSPy::LM.new('gemini/gemini-1.5-pro',
    api_key: ENV['GOOGLE_API_KEY'])
end
 
# Local Ollama (free, private)
DSPy.configure do |c|
  c.lm = DSPy::LM.new('ollama/llama3.1')
end

Templates: See assets/config-template.rb for comprehensive examples including:

  • Environment-based configuration
  • Multi-model setups for different tasks
  • Configuration with observability (OpenTelemetry, Langfuse)
  • Retry logic and fallback strategies
  • Budget tracking
  • Rails initializer patterns

Provider compatibility matrix:

FeatureOpenAIAnthropicGeminiOllama
Structured Output✅✅✅✅
Vision (Images)✅✅✅⚠️ Limited
Image URLs✅❌❌❌
Tool Calling✅✅✅Varies

Cost optimization strategy:

  • Development: Ollama (free) or gpt-4o-mini (cheap)
  • Testing: gpt-4o-mini with temperature=0.0
  • Production simple tasks: gpt-4o-mini, claude-3-haiku, gemini-1.5-flash
  • Production complex tasks: gpt-4o, claude-3-5-sonnet, gemini-1.5-pro

Full documentation: See references/providers.md for all configuration options, provider-specific features, and troubleshooting.

5. Multimodal & Vision Support

Process images alongside text using the unified DSPy::Image interface.

Quick reference:

ruby
class VisionSignature < DSPy::Signature
  description "Analyze image and answer questions"
 
  input do
    const :image, DSPy::Image
    const :question, String
  end
 
  output do
    const :answer, String
  end
end
 
predictor = DSPy::Predict.new(VisionSignature)
result = predictor.forward(
  image: DSPy::Image.from_file("path/to/image.jpg"),
  question: "What objects are visible?"
)

Image loading methods:

ruby
# From file
DSPy::Image.from_file("path/to/image.jpg")
 
# From URL (OpenAI only)
DSPy::Image.from_url("https://example.com/image.jpg")
 
# From base64
DSPy::Image.from_base64(base64_data, mime_type: "image/jpeg")

Provider support:

  • OpenAI: Full support including URLs
  • Anthropic, Gemini: Base64 or file loading only
  • Ollama: Limited multimodal depending on model

Full documentation: See references/core-concepts.md section on Multimodal Support.

6. Testing LLM Applications

Write standard RSpec tests for LLM logic.

Quick reference:

ruby
RSpec.describe EmailClassifier do
  before do
    DSPy.configure do |c|
      c.lm = DSPy::LM.new('openai/gpt-4o-mini',
        api_key: ENV['OPENAI_API_KEY'])
    end
  end
 
  it 'classifies technical emails correctly' do
    classifier = EmailClassifier.new
    result = classifier.forward(
      email_subject: "Can't log in",
      email_body: "Unable to access account"
    )
 
    expect(result[:category]).to eq('Technical')
    expect(result[:priority]).to be_in(['High', 'Medium', 'Low'])
  end
end

Testing patterns:

  • Mock LLM responses for unit tests
  • Use VCR for deterministic API testing
  • Test type safety and validation
  • Test edge cases (empty inputs, special characters, long texts)
  • Integration test complete workflows

Full documentation: See references/optimization.md section on Testing.

7. Optimization & Improvement

Automatically improve prompts and modules using optimization techniques.

MIPROv2 optimization:

ruby
require 'dspy/mipro'
 
# Define evaluation metric
def accuracy_metric(example, prediction)
  example[:expected_output][:category] == prediction[:category] ? 1.0 : 0.0
end
 
# Prepare training data
training_examples = [
  {
    input: { email_subject: "...", email_body: "..." },
    expected_output: { category: 'Technical' }
  },
  # More examples...
]
 
# Run optimization
optimizer = DSPy::MIPROv2.new(
  metric: method(:accuracy_metric),
  num_candidates: 10
)
 
optimized_module = optimizer.compile(
  EmailClassifier.new,
  trainset: training_examples
)

A/B testing different approaches:

ruby
# Test ChainOfThought vs ReAct
approach_a_score = evaluate_approach(ChainOfThoughtModule, test_set)
approach_b_score = evaluate_approach(ReActModule, test_set)

Full documentation: See references/optimization.md section on Optimization.

8. Observability & Monitoring

Track performance, token usage, and behavior in production.

OpenTelemetry integration:

ruby
require 'opentelemetry/sdk'
 
OpenTelemetry::SDK.configure do |c|
  c.service_name = 'my-dspy-app'
  c.use_all
end
 
# DSPy automatically creates traces

Langfuse tracing:

ruby
DSPy.configure do |c|
  c.lm = DSPy::LM.new('openai/gpt-4o-mini',
    api_key: ENV['OPENAI_API_KEY'])
 
  c.langfuse = {
    public_key: ENV['LANGFUSE_PUBLIC_KEY'],
    secret_key: ENV['LANGFUSE_SECRET_KEY']
  }
end

Custom monitoring:

  • Token tracking
  • Performance monitoring
  • Error rate tracking
  • Custom logging

Full documentation: See references/optimization.md section on Observability.

Quick Start Workflow

For New Projects
  1. Install DSPy.rb and provider gems:
bash
gem install dspy dspy-openai  # or dspy-anthropic, dspy-gemini
  1. Configure LLM provider (see assets/config-template.rb):
ruby
require 'dspy'
 
DSPy.configure do |c|
  c.lm = DSPy::LM.new('openai/gpt-4o-mini',
    api_key: ENV['OPENAI_API_KEY'])
end
  1. Create a signature (see assets/signature-template.rb):
ruby
class MySignature < DSPy::Signature
  description "Clear description of task"
 
  input do
    const :input_field, String, desc: "Description"
  end
 
  output do
    const :output_field, String, desc: "Description"
  end
end
  1. Create a module (see assets/module-template.rb):
ruby
class MyModule < DSPy::Module
  def initialize
    super
    @predictor = DSPy::Predict.new(MySignature)
  end
 
  def forward(input_field:)
    @predictor.forward(input_field: input_field)
  end
end
  1. Use the module:
ruby
module_instance = MyModule.new
result = module_instance.forward(input_field: "test")
puts result[:output_field]
  1. Add tests (see references/optimization.md):
ruby
RSpec.describe MyModule do
  it 'produces expected output' do
    result = MyModule.new.forward(input_field: "test")
    expect(result[:output_field]).to be_a(String)
  end
end
For Rails Applications
  1. Add to Gemfile:
ruby
gem 'dspy'
gem 'dspy-openai'  # or other provider
  1. Create initializer at config/initializers/dspy.rb (see assets/config-template.rb for full example):
ruby
require 'dspy'
 
DSPy.configure do |c|
  c.lm = DSPy::LM.new('openai/gpt-4o-mini',
    api_key: ENV['OPENAI_API_KEY'])
end
  1. Create modules in app/llm/ directory:
ruby
# app/llm/email_classifier.rb
class EmailClassifier < DSPy::Module
  # Implementation here
end
  1. Use in controllers/services:
ruby
class EmailsController < ApplicationController
  def classify
    classifier = EmailClassifier.new
    result = classifier.forward(
      email_subject: params[:subject],
      email_body: params[:body]
    )
    render json: result
  end
end

Common Patterns

Pattern: Multi-Step Analysis Pipeline
ruby
class AnalysisPipeline < DSPy::Module
  def initialize
    super
    @extract = DSPy::Predict.new(ExtractSignature)
    @analyze = DSPy::ChainOfThought.new(AnalyzeSignature)
    @summarize = DSPy::Predict.new(SummarizeSignature)
  end

This is the start of the file. Read the full SKILL.md on GitHub.

Security

  • Security scanPassed, 100 of 100Pattern checks on the skill's files.
  • Model reviewNot runA model review is scheduled for the next rescan.

See the full security report

Quality evaluation

  • Task evaluationPassed, 70 of 100Effective. 1 run. Evaluated 8 months ago.

See evaluation results

Source

Popularity

Repository stars
56
Repository forks
9
7-day trend score
20

Stars and forks are for the whole GitHub repository, not this skill alone. Refreshed 17 Mar 2026, 7 months ago.

Works with

Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.

  • Claude Code
  • Cursor
  • GitHub Copilot
  • Windsurf
  • Codex
  • Gemini CLI
  • Cline
  • Amp
  • Roo Code
  • Goose
  • Continue
  • Kilo Code
  • Junie
  • Trae
  • OpenHands
  • Qwen Code
  • AI Agent
  • Tabnine Chat
  • Sourcegraph Cody
  • Amazon Q
  • Firebase Genkit
  • Sweep
  • Devin
  • Phind
  • Mentat
  • Claude Desktop
  • Aider
  • GPT Pilot
  • Plandex
  • bolt.new
  • v0
  • Replit Agent
  • Anse
  • TypingMind
  • BetterChatGPT
  • LibreChat
  • Warp AI
  • Pieces
  • Fig AI
Embed badge
vskill VERIFIED badge
[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/ratacat/claude-skills/dspy-ruby/badge)](https://verified-skill.com/skills/ratacat/claude-skills/dspy-ruby)

Something wrong with this skill or its page? Tell us.