desiru 0.1.0

data/examples/graphql_api.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'desiru'
+require 'desiru/graphql/schema_generator'
+require 'desiru/graphql/executor'
+
+# Configure Desiru
+Desiru.configure do |config|
+  # Use a mock model for demonstration
+  config.default_model = Desiru::Models::RaixAdapter.new
+end
+
+# Create some example modules
+class AnswerQuestion < Desiru::Module
+  def initialize
+    signature = Desiru::Signature.new(
+      "question: string -> answer: string, confidence: float",
+      descriptions: {
+        question: "The question to answer",
+        answer: "The answer to the question",
+        confidence: "Confidence score between 0 and 1"
+      }
+    )
+    super(signature)
+  end
+
+  def forward(question:)
+    # Simulate processing
+    {
+      answer: "The answer to '#{question}' is 42.",
+      confidence: 0.95
+    }
+  end
+end
+
+class SummarizeText < Desiru::Module
+  def initialize
+    signature = Desiru::Signature.new(
+      "text: string, max_words: int -> summary: string, word_count: int",
+      descriptions: {
+        text: "The text to summarize",
+        max_words: "Maximum words in summary",
+        summary: "The summarized text",
+        word_count: "Actual word count of summary"
+      }
+    )
+    super(signature)
+  end
+
+  def forward(text:, max_words:)
+    words = text.split.take(max_words)
+    summary = words.join(' ') + (words.length < text.split.length ? '...' : '')
+
+    {
+      summary: summary,
+      word_count: words.length
+    }
+  end
+end
+
+class ClassifySentiment < Desiru::Module
+  def initialize
+    signature = Desiru::Signature.new(
+      "text: string -> sentiment: Literal['positive', 'negative', 'neutral'], reasoning: string"
+    )
+    super(signature)
+  end
+
+  def forward(text:)
+    # Simple rule-based sentiment for demo
+    positive_words = %w[good great excellent amazing wonderful]
+    negative_words = %w[bad terrible awful horrible poor]
+
+    text_lower = text.downcase
+    positive_count = positive_words.count { |word| text_lower.include?(word) }
+    negative_count = negative_words.count { |word| text_lower.include?(word) }
+
+    if positive_count > negative_count
+      sentiment = 'positive'
+      reasoning = "Found #{positive_count} positive indicators"
+    elsif negative_count > positive_count
+      sentiment = 'negative'
+      reasoning = "Found #{negative_count} negative indicators"
+    else
+      sentiment = 'neutral'
+      reasoning = "No strong sentiment indicators found"
+    end
+
+    { sentiment: sentiment, reasoning: reasoning }
+  end
+end
+
+# Set up GraphQL schema
+puts "Setting up GraphQL schema..."
+generator = Desiru::GraphQL::SchemaGenerator.new
+
+# Register modules
+generator.register_module(:answerQuestion, AnswerQuestion.new)
+generator.register_module(:summarizeText, SummarizeText.new)
+generator.register_module(:classifySentiment, ClassifySentiment.new)
+
+# Generate schema
+schema = generator.generate_schema
+
+# Create executor with batch loading
+executor = Desiru::GraphQL::Executor.new(schema, data_loader: generator.data_loader)
+
+# Example queries
+puts "\n=== Example 1: Simple Question ==="
+query1 = <<~GRAPHQL
+  query {
+    answerQuestion(question: "What is the meaning of life?") {
+      answer
+      confidence
+    }
+  }
+GRAPHQL
+
+result1 = executor.execute(query1)
+puts "Query: #{query1}"
+puts "Result: #{result1.to_h}"
+
+puts "\n=== Example 2: Text Summarization ==="
+query2 = <<~GRAPHQL
+  query {
+    summarizeText(
+      text: "Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write."
+      maxWords: 10
+    ) {
+      summary
+      wordCount
+    }
+  }
+GRAPHQL
+
+result2 = executor.execute(query2)
+puts "Query: #{query2}"
+puts "Result: #{result2.to_h}"
+
+puts "\n=== Example 3: Sentiment Classification ==="
+query3 = <<~GRAPHQL
+  query {
+    classifySentiment(text: "This framework is absolutely amazing and wonderful!") {
+      sentiment
+      reasoning
+    }
+  }
+GRAPHQL
+
+result3 = executor.execute(query3)
+puts "Query: #{query3}"
+puts "Result: #{result3.to_h}"
+
+puts "\n=== Example 4: Batch Query ==="
+batch_query = <<~GRAPHQL
+  query {
+    positive: classifySentiment(text: "I love this great product") {
+      sentiment
+      reasoning
+    }
+    negative: classifySentiment(text: "This is terrible and awful") {
+      sentiment
+      reasoning
+    }
+    neutral: classifySentiment(text: "It exists and works") {
+      sentiment
+      reasoning
+    }
+  }
+GRAPHQL
+
+result4 = executor.execute(batch_query)
+puts "Query: #{batch_query}"
+puts "Result: #{result4.to_h}"
+
+# Demonstrate batch execution of multiple queries
+puts "\n=== Example 5: Batch Execution ==="
+queries = [
+  { query: 'query { answerQuestion(question: "What is Ruby?") { answer } }' },
+  { query: 'query { answerQuestion(question: "What is GraphQL?") { answer } }' },
+  { query: 'query { answerQuestion(question: "What is Desiru?") { answer } }' }
+]
+
+results = executor.execute_batch(queries)
+puts "Executing #{queries.length} queries in batch..."
+results.each_with_index do |result, i|
+  puts "Query #{i + 1}: #{result.to_h}"
+end

data/examples/graphql_integration.rb

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'desiru'
+require 'desiru/graphql/schema_generator'
+
+# Example: GraphQL Integration with Desiru
+# This demonstrates how to generate GraphQL schemas from Desiru signatures
+
+# Configure Desiru
+Desiru.configure do |config|
+  config.default_model = Desiru::Models::RaixAdapter.new(
+    client: 'openai',
+    model: 'gpt-3.5-turbo'
+  )
+end
+
+# Create a schema generator
+generator = Desiru::GraphQL::SchemaGenerator.new
+
+# Register multiple Desiru signatures as GraphQL operations
+generator.register_signature(
+  'translateText',
+  Desiru::Signature.new(
+    'text: string, target_language: string, source_language?: string -> translation: string, confidence: float'
+  )
+)
+
+generator.register_signature(
+  'analyzeSentiment',
+  Desiru::Signature.new(
+    "text: string -> sentiment: Literal['positive', 'negative', 'neutral'], score: float"
+  )
+)
+
+generator.register_signature(
+  'summarizeBatch',
+  Desiru::Signature.new(
+    'documents: list[string], max_length: int -> summaries: list[string], total_words: int'
+  )
+)
+
+# Generate the GraphQL schema
+schema = generator.generate_schema
+
+# Example GraphQL query execution
+puts "GraphQL Schema generated with operations:"
+schema.query.fields.each do |name, field|
+  puts "  - #{name}: #{field.description}"
+end
+
+# Example queries you can run:
+puts "\nExample GraphQL queries:"
+puts <<~GRAPHQL
+  # Translation query
+  query {
+    translateText(text: "Hello world", targetLanguage: "es") {
+      translation
+      confidence
+    }
+  }
+
+  # Sentiment analysis query#{'  '}
+  query {
+    analyzeSentiment(text: "This framework is amazing!") {
+      sentiment
+      score
+    }
+  }
+
+  # Batch summarization query
+  query {
+    summarizeBatch(
+      documents: ["Long document 1...", "Long document 2..."],
+      maxLength: 100
+    ) {
+      summaries
+      totalWords
+    }
+  }
+GRAPHQL
+
+# Execute a sample query
+result = schema.execute(<<~GRAPHQL)
+  query {
+    analyzeSentiment(text: "GraphQL integration with Desiru is fantastic!") {
+      sentiment
+      score
+    }
+  }
+GRAPHQL
+
+puts "\nQuery result:"
+puts result.to_h.inspect
+
+# Integration with GraphQL servers
+puts "\n\nTo use this schema with a GraphQL server (e.g., graphql-ruby with Rails):"
+puts <<~RUBY
+  # In your GraphQL controller:
+  class GraphQLController < ApplicationController
+    def execute
+      result = DesiruSchema.execute(
+        params[:query],
+        variables: params[:variables],
+        context: { current_user: current_user }
+      )
+      render json: result
+    end
+  end
+
+  # Where DesiruSchema is your generated schema
+  DesiruSchema = generator.generate_schema
+RUBY

data/examples/rag_retrieval.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative '../lib/desiru'
+
+# Example: Using the Retrieve module for RAG (Retrieval Augmented Generation)
+
+# Create a dummy model for demonstration
+class DummyModel
+  def complete(prompt, **_options)
+    { content: "Answer based on retrieved context: #{prompt[:user]}" }
+  end
+end
+
+# Initialize the Retrieve module
+retrieve = Desiru::Retrieve.new(model: DummyModel.new)
+
+# Add some documents to the knowledge base
+documents = [
+  'Desiru is a Ruby implementation of DSPy for programming language models.',
+  'DSPy (Declarative Self-improving Language Programs) enables systematic optimization of LM prompts and weights.',
+  'Ruby is a dynamic, open source programming language with a focus on simplicity and productivity.',
+  'The Retrieve module implements vector search for RAG (Retrieval Augmented Generation) applications.',
+  'RAG combines retrieval from a knowledge base with language model generation for more accurate responses.',
+  'Vector embeddings enable semantic search by representing text as high-dimensional numerical vectors.',
+  'The InMemoryBackend stores documents and embeddings in memory for fast prototyping.',
+  'Production systems might use vector databases like Pinecone, Weaviate, or Qdrant.'
+]
+
+puts "Adding #{documents.size} documents to the retrieval index..."
+retrieve.add_documents(documents)
+puts "Index now contains #{retrieve.document_count} documents\n\n"
+
+# Perform some searches
+queries = [
+  { query: 'What is Desiru?', k: 3 },
+  { query: 'vector search implementation', k: 2 },
+  { query: 'Ruby programming', k: 4 }
+]
+
+queries.each do |params|
+  puts "Query: '#{params[:query]}' (top #{params[:k]} results)"
+  puts '-' * 50
+
+  result = retrieve.call(**params)
+
+  result.documents.each_with_index do |doc, idx|
+    score = result.scores[idx]
+    puts "#{idx + 1}. [Score: #{score.round(3)}] #{doc}"
+  end
+
+  puts "\n"
+end
+
+# Example: Using custom embeddings
+puts "Example with custom embeddings:"
+puts '-' * 50
+
+# Create simple one-hot encoded embeddings for demonstration
+custom_docs = %w[apple banana cherry]
+custom_embeddings = [
+  [1.0, 0.0, 0.0],  # apple
+  [0.0, 1.0, 0.0],  # banana
+  [0.0, 0.0, 1.0]   # cherry
+]
+
+# Create a new retrieve instance with custom backend
+custom_retrieve = Desiru::Retrieve.new(
+  model: DummyModel.new,
+  backend: Desiru::Modules::InMemoryBackend.new(distance_metric: :euclidean)
+)
+
+custom_retrieve.add_documents(custom_docs, embeddings: custom_embeddings)
+
+# Search with a custom query embedding # Closer to apple
+results = custom_retrieve.backend.search('custom', k: 3)
+
+puts "Custom embedding search results:"
+results.each_with_index do |result, idx|
+  puts "#{idx + 1}. #{result[:document]} (distance: #{result[:score].round(3)})"
+end

data/examples/simple_qa.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'desiru'
+
+# Configure Desiru with OpenAI model
+Desiru.configure do |config|
+  config.default_model = Desiru::Models::RaixAdapter.new(
+    provider: :openai,
+    model: 'gpt-3.5-turbo',
+    api_key: ENV['OPENAI_API_KEY'] || raise('Please set OPENAI_API_KEY environment variable')
+  )
+end
+
+# Create a simple question-answering module
+qa = Desiru::Modules::Predict.new('question -> answer')
+
+# Ask a question
+result = qa.call(question: 'What is the capital of France?')
+puts 'Question: What is the capital of France?'
+puts "Answer: #{result.answer}"
+
+# Create a Chain of Thought module for more complex reasoning
+cot = Desiru::Modules::ChainOfThought.new('question -> answer')
+
+# Ask a more complex question
+result = cot.call(question: 'Two dice are tossed. What is the probability that the sum equals two?')
+puts "\nQuestion: Two dice are tossed. What is the probability that the sum equals two?"
+puts "Answer: #{result.answer}"
+puts "Reasoning: #{result.reasoning}" if result.respond_to?(:reasoning)

data/examples/typed_signatures.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'desiru'
+
+# Configure Desiru
+Desiru.configure do |config|
+  config.default_model = Desiru::Models::RaixAdapter.new(
+    provider: :openai,
+    model: 'gpt-3.5-turbo',
+    api_key: ENV['OPENAI_API_KEY'] || raise('Please set OPENAI_API_KEY environment variable')
+  )
+end
+
+# Create a module with typed signature and descriptions
+summarizer = Desiru::Modules::Predict.new(
+  'document: string, max_length: int -> summary: string, key_points: list',
+  descriptions: {
+    'document' => 'The text document to summarize',
+    'max_length' => 'Maximum number of words in the summary',
+    'summary' => 'A concise summary of the document',
+    'key_points' => 'List of key points from the document'
+  }
+)
+
+# Test document
+document = <<~TEXT
+  Ruby is a dynamic, open source programming language with a focus on simplicity and productivity.
+  It has an elegant syntax that is natural to read and easy to write. Ruby was created by Yukihiro
+  Matsumoto in the mid-1990s. The language emphasizes the principle of least surprise, meaning that
+  the language should behave in a way that minimizes confusion for experienced users.
+TEXT
+
+# Generate summary
+result = summarizer.call(document: document, max_length: 50)
+
+puts 'Original Document:'
+puts document
+puts "\nSummary (max #{result.to_h[:max_length] || 50} words):"
+puts result.summary
+puts "\nKey Points:"
+result.key_points.each_with_index do |point, i|
+  puts "#{i + 1}. #{point}"
+end

data/lib/desiru/async_capable.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'redis'
+require 'json'
+
+module Desiru
+  module AsyncCapable
+    def call_async(inputs = {})
+      job_id = SecureRandom.uuid
+
+      Desiru::Jobs::AsyncPredict.perform_async(
+        job_id,
+        self.class.name,
+        signature.to_s,
+        inputs,
+        {
+          'model_class' => model.class.name,
+          'model_config' => model_config,
+          'config' => config,
+          'demos' => demos
+        }
+      )
+
+      AsyncResult.new(job_id)
+    end
+
+    def call_batch_async(inputs_array)
+      batch_id = SecureRandom.uuid
+
+      Desiru::Jobs::BatchProcessor.perform_async(
+        batch_id,
+        self.class.name,
+        signature.to_s,
+        inputs_array,
+        {
+          'model_class' => model.class.name,
+          'model_config' => model_config,
+          'config' => config,
+          'demos' => demos
+        }
+      )
+
+      BatchResult.new(batch_id)
+    end
+
+    private
+
+    def model_config
+      return {} unless model.respond_to?(:to_config)
+
+      model.to_config
+    end
+  end
+
+  class AsyncResult
+    attr_reader :job_id
+
+    def initialize(job_id)
+      @job_id = job_id
+      @redis = Redis.new(url: Desiru.configuration.redis_url || ENV.fetch('REDIS_URL', nil))
+    end
+
+    def ready?
+      result = fetch_result
+      !result.nil?
+    end
+
+    def success?
+      result = fetch_result
+      result && result[:success]
+    end
+
+    def failed?
+      result = fetch_result
+      result && !result[:success]
+    end
+
+    def result
+      data = fetch_result
+      return nil unless data
+
+      raise ModuleError, "Async job failed: #{data[:error]}" unless data[:success]
+
+      ModuleResult.new(data[:result], metadata: { async: true, job_id: job_id })
+    end
+
+    def error
+      data = fetch_result
+      return nil unless data && !data[:success]
+
+      {
+        message: data[:error],
+        class: data[:error_class]
+      }
+    end
+
+    def status
+      status_data = fetch_status
+      return 'pending' unless status_data
+
+      status_data[:status] || 'pending'
+    end
+
+    def progress
+      status_data = fetch_status
+      return nil unless status_data
+
+      status_data[:progress]
+    end
+
+    def wait(timeout: 60, poll_interval: 0.5)
+      start_time = Time.now
+
+      while Time.now - start_time < timeout
+        return result if ready?
+
+        sleep poll_interval
+      end
+
+      raise TimeoutError, "Async result not ready after #{timeout} seconds"
+    end
+
+    private
+
+    def fetch_result
+      raw = @redis.get("desiru:results:#{job_id}")
+      return nil unless raw
+
+      JSON.parse(raw, symbolize_names: true)
+    end
+
+    def fetch_status
+      raw = @redis.get("desiru:status:#{job_id}")
+      return nil unless raw
+
+      JSON.parse(raw, symbolize_names: true)
+    end
+  end
+
+  class BatchResult < AsyncResult
+    def results
+      data = fetch_result
+      return [] unless data && data[:results]
+
+      data[:results].map do |item|
+        ModuleResult.new(item[:result], metadata: { batch_index: item[:index] }) if item[:success]
+      end
+    end
+
+    def errors
+      data = fetch_result
+      return [] unless data && data[:errors]
+
+      data[:errors]
+    end
+
+    def stats
+      data = fetch_result
+      return {} unless data
+
+      {
+        total: data[:total],
+        successful: data[:successful],
+        failed: data[:failed],
+        success_rate: data[:total].positive? ? data[:successful].to_f / data[:total] : 0
+      }
+    end
+  end
+end