smart_prompt 0.4.4 → 0.5.1

data/examples/anthropic_streaming.rb

@@ -0,0 +1,312 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require './lib/smart_prompt'
+
+# Example: Streaming Responses with Anthropic Claude
+# This example demonstrates how to use Claude's streaming capabilities
+
+puts "=" * 60
+puts "Anthropic Claude - Streaming Response Example"
+puts "=" * 60
+
+# Initialize the engine with Anthropic configuration
+engine = SmartPrompt::Engine.new('config/anthropic_config.yml')
+
+# Example 1: Basic Streaming
+puts "\n1. Basic Streaming Response"
+puts "-" * 60
+
+SmartPrompt.define_worker :streaming_chat do
+  use "claude"
+  sys_msg("You are a helpful assistant.")
+  prompt(params[:message])
+  send_msg
+end
+
+print "User: Tell me a short story about a brave knight.\n"
+print "Claude (streaming): "
+
+engine.call_worker_by_stream(:streaming_chat, {
+  message: "Tell me a short story about a brave knight."
+}) do |chunk, bytesize|
+  # Handle Anthropic streaming format
+  if chunk.is_a?(Hash)
+    if chunk["type"] == "content_block_delta"
+      text = chunk.dig("delta", "text")
+      print text if text
+    end
+  end
+end
+
+puts "\n"
+
+# Example 2: Streaming with Different Event Types
+puts "\n2. Streaming with Event Type Handling"
+puts "-" * 60
+
+SmartPrompt.define_worker :detailed_streaming do
+  use "claude"
+  sys_msg("You are a knowledgeable teacher.")
+  prompt(params[:message])
+  send_msg
+end
+
+print "User: Explain how photosynthesis works.\n"
+print "Claude: "
+
+message_started = false
+content_started = false
+
+engine.call_worker_by_stream(:detailed_streaming, {
+  message: "Explain how photosynthesis works in 3-4 sentences."
+}) do |chunk, bytesize|
+  if chunk.is_a?(Hash)
+    case chunk["type"]
+    when "message_start"
+      message_started = true
+      # Message metadata available in chunk["message"]
+    when "content_block_start"
+      content_started = true
+      # Content block started
+    when "content_block_delta"
+      text = chunk.dig("delta", "text")
+      print text if text
+    when "content_block_stop"
+      # Content block finished
+    when "message_delta"
+      # Message metadata update (e.g., stop_reason)
+    when "message_stop"
+      # Message completely finished
+    end
+  end
+end
+
+puts "\n"
+
+# Example 3: Streaming Long-form Content
+puts "\n3. Streaming Long-form Content"
+puts "-" * 60
+
+SmartPrompt.define_worker :long_form_streaming do
+  use "claude"
+  sys_msg("You are a creative writer who writes engaging stories.")
+  prompt(params[:message])
+  send_msg
+end
+
+print "User: Write a detailed story about a robot learning to paint.\n"
+print "Claude: "
+
+total_chars = 0
+
+engine.call_worker_by_stream(:long_form_streaming, {
+  message: "Write a detailed story (about 200 words) about a robot learning to paint."
+}) do |chunk, bytesize|
+  if chunk.is_a?(Hash) && chunk["type"] == "content_block_delta"
+    text = chunk.dig("delta", "text")
+    if text
+      print text
+      total_chars += text.length
+    end
+  end
+end
+
+puts "\n\n[Total characters streamed: #{total_chars}]"
+
+# Example 4: Streaming with Progress Indicator
+puts "\n4. Streaming with Progress Indicator"
+puts "-" * 60
+
+SmartPrompt.define_worker :progress_streaming do
+  use "claude"
+  sys_msg("You are a helpful coding assistant.")
+  prompt(params[:message])
+  send_msg
+end
+
+print "User: Write a Python function to calculate Fibonacci numbers.\n"
+print "Claude: "
+
+char_count = 0
+last_dot_time = Time.now
+
+engine.call_worker_by_stream(:progress_streaming, {
+  message: "Write a Python function to calculate Fibonacci numbers with comments."
+}) do |chunk, bytesize|
+  if chunk.is_a?(Hash) && chunk["type"] == "content_block_delta"
+    text = chunk.dig("delta", "text")
+    if text
+      print text
+      char_count += text.length
+      
+      # Print a progress indicator every 50 characters
+      if char_count % 50 == 0 && Time.now - last_dot_time > 0.5
+        # This is just for demonstration
+        last_dot_time = Time.now
+      end
+    end
+  end
+end
+
+puts "\n"
+
+# Example 5: Streaming with Error Handling
+puts "\n5. Streaming with Error Handling"
+puts "-" * 60
+
+SmartPrompt.define_worker :safe_streaming do
+  use "claude"
+  sys_msg("You are a helpful assistant.")
+  prompt(params[:message])
+  send_msg
+end
+
+print "User: What are the benefits of exercise?\n"
+print "Claude: "
+
+begin
+  engine.call_worker_by_stream(:safe_streaming, {
+    message: "What are the benefits of exercise? List 5 benefits."
+  }) do |chunk, bytesize|
+    if chunk.is_a?(Hash) && chunk["type"] == "content_block_delta"
+      text = chunk.dig("delta", "text")
+      print text if text
+    end
+  end
+  puts "\n[Stream completed successfully]"
+rescue SmartPrompt::LLMAPIError => e
+  puts "\n[Error during streaming: #{e.message}]"
+rescue StandardError => e
+  puts "\n[Unexpected error: #{e.message}]"
+end
+
+puts ""
+
+# Example 6: Streaming vs Non-Streaming Comparison
+puts "\n6. Streaming vs Non-Streaming Comparison"
+puts "-" * 60
+
+question = "Explain the theory of relativity in simple terms."
+
+# Non-streaming (traditional)
+puts "Non-streaming mode:"
+print "User: #{question}\n"
+print "Claude: "
+
+start_time = Time.now
+
+SmartPrompt.define_worker :non_streaming_chat do
+  use "claude"
+  sys_msg("You are a physics teacher.")
+  prompt(params[:message])
+  send_msg
+end
+
+response = engine.call_worker(:non_streaming_chat, { message: question })
+end_time = Time.now
+
+puts response
+puts "[Response received in #{(end_time - start_time).round(2)} seconds]\n"
+
+# Streaming mode
+puts "\nStreaming mode:"
+print "User: #{question}\n"
+print "Claude: "
+
+start_time = Time.now
+first_chunk_time = nil
+
+SmartPrompt.define_worker :streaming_comparison do
+  use "claude"
+  sys_msg("You are a physics teacher.")
+  prompt(params[:message])
+  send_msg
+end
+
+engine.call_worker_by_stream(:streaming_comparison, { message: question }) do |chunk, bytesize|
+  if chunk.is_a?(Hash) && chunk["type"] == "content_block_delta"
+    first_chunk_time ||= Time.now
+    text = chunk.dig("delta", "text")
+    print text if text
+  end
+end
+
+end_time = Time.now
+
+puts "\n[First chunk in #{(first_chunk_time - start_time).round(2)} seconds]"
+puts "[Total time: #{(end_time - start_time).round(2)} seconds]\n"
+
+# Example 7: Streaming with Different Models
+puts "\n7. Streaming with Different Claude Models"
+puts "-" * 60
+
+question = "What is machine learning?"
+
+# Claude 3.5 Sonnet
+puts "Claude 3.5 Sonnet (streaming):"
+print "User: #{question}\n"
+print "Claude: "
+
+SmartPrompt.define_worker :sonnet_streaming do
+  use "claude"
+  model "claude-3-5-sonnet-20241022"
+  prompt(params[:message])
+  send_msg
+end
+
+engine.call_worker_by_stream(:sonnet_streaming, { message: question }) do |chunk, bytesize|
+  if chunk.is_a?(Hash) && chunk["type"] == "content_block_delta"
+    text = chunk.dig("delta", "text")
+    print text if text
+  end
+end
+
+puts "\n"
+
+# Claude 3.5 Haiku (faster)
+puts "\nClaude 3.5 Haiku (streaming):"
+print "User: #{question}\n"
+print "Claude: "
+
+SmartPrompt.define_worker :haiku_streaming do
+  use "claude_haiku"
+  model "claude-3-5-haiku-20241022"
+  prompt(params[:message])
+  send_msg
+end
+
+engine.call_worker_by_stream(:haiku_streaming, { message: question }) do |chunk, bytesize|
+  if chunk.is_a?(Hash) && chunk["type"] == "content_block_delta"
+    text = chunk.dig("delta", "text")
+    print text if text
+  end
+end
+
+puts "\n"
+
+# Example 8: Streaming Best Practices
+puts "\n8. Streaming Best Practices"
+puts "-" * 60
+
+puts "Best Practices for Streaming with Claude:"
+puts "1. Use streaming for long-form content to improve perceived latency"
+puts "2. Handle different event types appropriately:"
+puts "   - message_start: Initialize UI/state"
+puts "   - content_block_delta: Display incremental text"
+puts "   - message_stop: Finalize and clean up"
+puts "3. Implement proper error handling for network issues"
+puts "4. Consider buffering small chunks for smoother display"
+puts "5. Show loading indicators before first chunk arrives"
+puts "6. Use streaming for better user experience in chat applications"
+puts "7. Non-streaming is better for short responses or batch processing"
+puts "8. Test streaming behavior with different network conditions"
+puts "9. Implement timeout handling for stalled streams"
+puts "10. Consider token usage - streaming doesn't reduce costs\n"
+
+puts "\n" + "=" * 60
+puts "Streaming examples completed!"
+puts "=" * 60
+puts "\nNote: Streaming provides a better user experience by showing"
+puts "responses as they're generated, reducing perceived latency."
+puts "The total time and token usage is similar to non-streaming mode."

data/examples/anthropic_tool_calling.rb

@@ -0,0 +1,393 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require './lib/smart_prompt'
+require 'json'
+
+# Example: Tool Calling (Function Calling) with Anthropic Claude
+# This example demonstrates how to use Claude with external tools/functions
+
+puts "=" * 60
+puts "Anthropic Claude - Tool Calling Example"
+puts "=" * 60
+
+# Initialize the engine with Anthropic configuration
+engine = SmartPrompt::Engine.new('config/anthropic_config.yml')
+
+# Example 1: Simple Weather Tool
+puts "\n1. Simple Weather Tool"
+puts "-" * 60
+
+# Define the weather tool
+weather_tool = [
+  {
+    type: "function",
+    function: {
+      name: "get_weather",
+      description: "Get the current weather for a specific location",
+      parameters: {
+        type: "object",
+        properties: {
+          location: {
+            type: "string",
+            description: "The city and state, e.g. San Francisco, CA"
+          },
+          unit: {
+            type: "string",
+            enum: ["celsius", "fahrenheit"],
+            description: "The temperature unit to use"
+          }
+        },
+        required: ["location"]
+      }
+    }
+  }
+]
+
+SmartPrompt.define_worker :weather_assistant do
+  use "claude"
+  sys_msg("You are a helpful weather assistant. Use the get_weather tool when users ask about weather.")
+  prompt(params[:message])
+  params.merge(tools: weather_tool)
+  send_msg
+end
+
+response = engine.call_worker(:weather_assistant, {
+  message: "What's the weather like in Tokyo?"
+})
+puts "User: What's the weather like in Tokyo?"
+puts "Claude: #{response}\n"
+
+# Example 2: Multiple Tools - Calculator
+puts "\n2. Calculator Tools"
+puts "-" * 60
+
+calculator_tools = [
+  {
+    type: "function",
+    function: {
+      name: "add",
+      description: "Add two numbers together",
+      parameters: {
+        type: "object",
+        properties: {
+          a: { type: "number", description: "First number" },
+          b: { type: "number", description: "Second number" }
+        },
+        required: ["a", "b"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "multiply",
+      description: "Multiply two numbers",
+      parameters: {
+        type: "object",
+        properties: {
+          a: { type: "number", description: "First number" },
+          b: { type: "number", description: "Second number" }
+        },
+        required: ["a", "b"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "divide",
+      description: "Divide two numbers",
+      parameters: {
+        type: "object",
+        properties: {
+          a: { type: "number", description: "Numerator" },
+          b: { type: "number", description: "Denominator" }
+        },
+        required: ["a", "b"]
+      }
+    }
+  }
+]
+
+SmartPrompt.define_worker :calculator_assistant do
+  use "claude"
+  sys_msg("You are a helpful calculator assistant. Use the available math tools to help users with calculations.")
+  prompt(params[:message])
+  params.merge(tools: calculator_tools)
+  send_msg
+end
+
+response = engine.call_worker(:calculator_assistant, {
+  message: "What is 15 multiplied by 23, then divided by 5?"
+})
+puts "User: What is 15 multiplied by 23, then divided by 5?"
+puts "Claude: #{response}\n"
+
+# Example 3: Database Query Tool
+puts "\n3. Database Query Tool"
+puts "-" * 60
+
+database_tools = [
+  {
+    type: "function",
+    function: {
+      name: "query_database",
+      description: "Query the customer database for information",
+      parameters: {
+        type: "object",
+        properties: {
+          query_type: {
+            type: "string",
+            enum: ["customer_info", "order_history", "product_details"],
+            description: "The type of query to perform"
+          },
+          customer_id: {
+            type: "string",
+            description: "The customer ID to query"
+          },
+          filters: {
+            type: "object",
+            description: "Additional filters for the query"
+          }
+        },
+        required: ["query_type"]
+      }
+    }
+  }
+]
+
+SmartPrompt.define_worker :database_assistant do
+  use "claude"
+  sys_msg("You are a customer service assistant with access to the customer database. Use the query_database tool to help users.")
+  prompt(params[:message])
+  params.merge(tools: database_tools)
+  send_msg
+end
+
+response = engine.call_worker(:database_assistant, {
+  message: "Can you look up the order history for customer ID 12345?"
+})
+puts "User: Can you look up the order history for customer ID 12345?"
+puts "Claude: #{response}\n"
+
+# Example 4: File Operations Tool
+puts "\n4. File Operations Tool"
+puts "-" * 60
+
+file_tools = [
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read the contents of a file",
+      parameters: {
+        type: "object",
+        properties: {
+          file_path: {
+            type: "string",
+            description: "The path to the file to read"
+          }
+        },
+        required: ["file_path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "write_file",
+      description: "Write content to a file",
+      parameters: {
+        type: "object",
+        properties: {
+          file_path: {
+            type: "string",
+            description: "The path to the file to write"
+          },
+          content: {
+            type: "string",
+            description: "The content to write to the file"
+          }
+        },
+        required: ["file_path", "content"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_files",
+      description: "List files in a directory",
+      parameters: {
+        type: "object",
+        properties: {
+          directory: {
+            type: "string",
+            description: "The directory path to list files from"
+          }
+        },
+        required: ["directory"]
+      }
+    }
+  }
+]
+
+SmartPrompt.define_worker :file_assistant do
+  use "claude"
+  sys_msg("You are a helpful file management assistant. Use the available file tools to help users manage their files.")
+  prompt(params[:message])
+  params.merge(tools: file_tools)
+  send_msg
+end
+
+response = engine.call_worker(:file_assistant, {
+  message: "Can you list all files in the /documents folder?"
+})
+puts "User: Can you list all files in the /documents folder?"
+puts "Claude: #{response}\n"
+
+# Example 5: API Integration Tool
+puts "\n5. API Integration Tool"
+puts "-" * 60
+
+api_tools = [
+  {
+    type: "function",
+    function: {
+      name: "fetch_stock_price",
+      description: "Fetch the current stock price for a given ticker symbol",
+      parameters: {
+        type: "object",
+        properties: {
+          ticker: {
+            type: "string",
+            description: "The stock ticker symbol (e.g., AAPL, GOOGL)"
+          }
+        },
+        required: ["ticker"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "fetch_news",
+      description: "Fetch recent news articles about a company or topic",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query for news articles"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of articles to return"
+          }
+        },
+        required: ["query"]
+      }
+    }
+  }
+]
+
+SmartPrompt.define_worker :market_assistant do
+  use "claude"
+  sys_msg("You are a financial market assistant. Use the available tools to provide stock prices and news.")
+  prompt(params[:message])
+  params.merge(tools: api_tools)
+  send_msg
+end
+
+response = engine.call_worker(:market_assistant, {
+  message: "What's the current price of Apple stock and any recent news about the company?"
+})
+puts "User: What's the current price of Apple stock and any recent news about the company?"
+puts "Claude: #{response}\n"
+
+# Example 6: Complex Tool with Nested Parameters
+puts "\n6. Complex Tool with Nested Parameters"
+puts "-" * 60
+
+search_tool = [
+  {
+    type: "function",
+    function: {
+      name: "search_products",
+      description: "Search for products in the catalog with advanced filters",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query"
+          },
+          filters: {
+            type: "object",
+            properties: {
+              category: {
+                type: "string",
+                description: "Product category"
+              },
+              price_range: {
+                type: "object",
+                properties: {
+                  min: { type: "number", description: "Minimum price" },
+                  max: { type: "number", description: "Maximum price" }
+                }
+              },
+              in_stock: {
+                type: "boolean",
+                description: "Only show in-stock items"
+              }
+            }
+          },
+          sort_by: {
+            type: "string",
+            enum: ["price_asc", "price_desc", "popularity", "newest"],
+            description: "How to sort the results"
+          }
+        },
+        required: ["query"]
+      }
+    }
+  }
+]
+
+SmartPrompt.define_worker :shopping_assistant do
+  use "claude"
+  sys_msg("You are a helpful shopping assistant. Use the search_products tool to help users find products.")
+  prompt(params[:message])
+  params.merge(tools: search_tool)
+  send_msg
+end
+
+response = engine.call_worker(:shopping_assistant, {
+  message: "Find me laptops under $1000 that are in stock, sorted by popularity"
+})
+puts "User: Find me laptops under $1000 that are in stock, sorted by popularity"
+puts "Claude: #{response}\n"
+
+# Example 7: Tool Calling Best Practices
+puts "\n7. Tool Calling Best Practices"
+puts "-" * 60
+
+puts "Best Practices for Tool Calling with Claude:"
+puts "1. Provide clear, descriptive function names"
+puts "2. Write detailed descriptions for functions and parameters"
+puts "3. Use appropriate parameter types (string, number, boolean, object, array)"
+puts "4. Mark required parameters explicitly"
+puts "5. Use enums for parameters with limited valid values"
+puts "6. Include examples in parameter descriptions when helpful"
+puts "7. Keep tool definitions focused and single-purpose"
+puts "8. Test tools with various user queries"
+puts "9. Handle tool errors gracefully in your implementation"
+puts "10. Consider tool execution order for complex workflows\n"
+
+puts "\n" + "=" * 60
+puts "Tool calling examples completed!"
+puts "=" * 60
+puts "\nNote: These examples show tool definitions. In a real application,"
+puts "you would implement the actual tool functions and handle the tool"
+puts "calls returned by Claude to execute the requested operations."