ruby_llm 0.1.0.pre37 → 0.1.0.pre39

data/docs/guides/getting-started.md

@@ -1,164 +0,0 @@
----
-layout: default
-title: Getting Started
-parent: Guides
-nav_order: 1
-permalink: /guides/getting-started
----
-
-# Getting Started with RubyLLM
-
-This guide will help you get up and running with RubyLLM, showing you the basics of chatting with AI models, generating images, and creating embeddings.
-
-## Prerequisites
-
-Before starting, make sure you have:
-
-1. Installed the RubyLLM gem (see the [Installation guide]({% link installation.md %}))
-2. At least one API key from a supported provider (OpenAI, Anthropic, Google, or DeepSeek)
-
-## Basic Configuration
-
-Let's start by setting up RubyLLM with your API keys:
-
-```ruby
-require 'ruby_llm'
-
-RubyLLM.configure do |config|
-  # Add the API keys you have available
-  config.openai_api_key = ENV['OPENAI_API_KEY']
-  config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
-  config.gemini_api_key = ENV['GEMINI_API_KEY']
-  config.deepseek_api_key = ENV['DEEPSEEK_API_KEY']
-end
-```
-
-## Your First Chat
-
-Let's start with a simple chat interaction:
-
-```ruby
-# Create a chat (uses the default model)
-chat = RubyLLM.chat
-
-# Ask a question
-response = chat.ask "What's the capital of France?"
-puts response.content
-# => "The capital of France is Paris."
-
-# Continue the conversation
-response = chat.ask "What's the population of that city?"
-puts response.content
-# => "Paris has a population of approximately 2.1 million people..."
-```
-
-### Using a Specific Model
-
-You can specify which model you want to use:
-
-```ruby
-# Use Claude
-claude_chat = RubyLLM.chat(model: 'claude-3-5-sonnet-20241022')
-claude_chat.ask "Tell me about Ruby programming language"
-
-# Use Gemini
-gemini_chat = RubyLLM.chat(model: 'gemini-2.0-flash')
-gemini_chat.ask "What are the best Ruby gems for machine learning?"
-```
-
-## Exploring Available Models
-
-RubyLLM gives you access to models from multiple providers. You can see what's available:
-
-```ruby
-# List all models
-all_models = RubyLLM.models.all
-puts "Total models: #{all_models.count}"
-
-# List chat models
-chat_models = RubyLLM.models.chat_models
-puts "Chat models:"
-chat_models.each do |model|
-  puts "- #{model.id} (#{model.provider})"
-end
-
-# List embedding models
-RubyLLM.models.embedding_models.each do |model|
-  puts "- #{model.id} (#{model.provider})"
-end
-
-# Find info about a specific model
-gpt = RubyLLM.models.find('gpt-4o-mini')
-puts "Context window: #{gpt.context_window}"
-puts "Max tokens: #{gpt.max_tokens}"
-puts "Pricing: $#{gpt.input_price_per_million} per million input tokens"
-```
-
-## Generating Images
-
-RubyLLM makes it easy to generate images with DALL-E:
-
-```ruby
-# Generate an image
-image = RubyLLM.paint("a sunset over mountains")
-
-# The URL where you can view/download the image
-puts image.url
-
-# How the model interpreted your prompt
-puts image.revised_prompt
-
-# Generate a larger image
-large_image = RubyLLM.paint(
-  "a cyberpunk city at night with neon lights",
-  size: "1792x1024"
-)
-```
-
-## Creating Embeddings
-
-Embeddings are vector representations of text that can be used for semantic search, classification, and more:
-
-```ruby
-# Create an embedding for a single text
-embedding = RubyLLM.embed("Ruby is a programmer's best friend")
-
-# The vector representation
-vector = embedding.vectors
-puts "Vector dimension: #{vector.length}"
-
-# Create embeddings for multiple texts
-texts = ["Ruby", "Python", "JavaScript"]
-embeddings = RubyLLM.embed(texts)
-
-# Each text gets its own vector
-puts "Number of vectors: #{embeddings.vectors.length}"
-```
-
-## Working with Conversations
-
-Here's how to have a multi-turn conversation:
-
-```ruby
-chat = RubyLLM.chat
-
-# First message
-chat.ask "What are the benefits of Ruby on Rails?"
-
-# Follow-up questions
-chat.ask "How does that compare to Django?"
-chat.ask "Which one would you recommend for a new web project?"
-
-# You can check all messages in the conversation
-chat.messages.each do |message|
-  puts "#{message.role}: #{message.content[0..100]}..."
-end
-```
-
-## What's Next?
-
-Now that you've got the basics down, you're ready to explore more advanced features:
-
-- [Chatting with AI]({% link guides/chat.md %}) - Learn more about chat capabilities
-- [Using Tools]({% link guides/tools.md %}) - Let AI use your Ruby code
-- [Rails Integration]({% link guides/rails.md %}) - Persist chats in your Rails apps

data/docs/guides/image-generation.md

@@ -1,274 +0,0 @@
----
-layout: default
-title: Image Generation
-parent: Guides
-nav_order: 6
-permalink: /guides/image-generation
----
-
-# Image Generation
-
-RubyLLM makes it easy to generate images using AI models like DALL-E. This guide explains how to create images and customize the generation process.
-
-## Basic Image Generation
-
-The simplest way to generate an image is using the global `paint` method:
-
-```ruby
-# Generate an image with DALL-E
-image = RubyLLM.paint("a sunset over mountains")
-
-# The URL where you can view/download the image
-puts image.url  # => "https://..."
-
-# How the model interpreted your prompt
-puts image.revised_prompt  # => "A breathtaking sunset painting the sky with warm..."
-```
-
-The `paint` method handles all the complexities of connecting to the right provider and processing the request.
-
-## Choosing Models
-
-By default, RubyLLM uses DALL-E 3, but you can specify a different model:
-
-```ruby
-# Use a specific model
-image = RubyLLM.paint(
-  "a cyberpunk city at night",
-  model: "dall-e-3"
-)
-
-# Alternate syntax
-image = RubyLLM.paint(
-  "a cyberpunk city at night",
-  model: "dalle-3"  # with or without hyphen
-)
-```
-
-You can configure the default model globally:
-
-```ruby
-RubyLLM.configure do |config|
-  config.default_image_model = "dall-e-3"
-end
-```
-
-## Image Sizes
-
-You can control the size of the generated image:
-
-```ruby
-# Standard size (1024x1024)
-image = RubyLLM.paint("a white siamese cat")
-
-# Landscape (1792x1024)
-landscape = RubyLLM.paint(
-  "a panoramic mountain landscape",
-  size: "1792x1024"
-)
-
-# Portrait (1024x1792)
-portrait = RubyLLM.paint(
-  "a tall redwood tree",
-  size: "1024x1792"
-)
-
-# Square with custom size
-square = RubyLLM.paint(
-  "a perfect square mandala",
-  size: "1024x1024" # standard square
-)
-```
-
-Available sizes depend on the model. DALL-E 3 supports:
-- `"1024x1024"` - Standard square (default)
-- `"1792x1024"` - Wide landscape
-- `"1024x1792"` - Tall portrait
-
-## Working with Generated Images
-
-The `Image` object returned by `paint` contains information about the generated image:
-
-```ruby
-image = RubyLLM.paint("a cyberpunk cityscape")
-
-# URL to the generated image (temporary, expires after some time)
-image_url = image.url
-
-# How the model interpreted/enhanced your prompt
-enhanced_prompt = image.revised_prompt
-
-# The model used to generate the image
-model_used = image.model_id
-```
-
-### Saving Images Locally
-
-To save the generated image to a local file:
-
-```ruby
-require 'open-uri'
-
-# Generate an image
-image = RubyLLM.paint("a sunset over mountains")
-
-# Save to a file
-File.open("sunset.png", "wb") do |file|
-  file.write(URI.open(image.url).read)
-end
-```
-
-## Prompt Engineering for Images
-
-Crafting effective prompts is crucial for getting the best results:
-
-```ruby
-# Basic prompt
-image = RubyLLM.paint("cat")
-
-# Detailed prompt
-image = RubyLLM.paint(
-  "A fluffy orange tabby cat sitting on a windowsill, " \
-  "looking out at a rainy day. Soft lighting, detailed fur, " \
-  "photorealistic style."
-)
-```
-
-### Tips for Better Prompts
-
-1. **Be specific** about subject, setting, lighting, style, and perspective
-2. **Specify artistic style** (e.g., "oil painting", "digital art", "photorealistic")
-3. **Include lighting details** ("soft morning light", "dramatic sunset")
-4. **Add composition details** ("close-up", "wide angle", "overhead view")
-5. **Specify mood or atmosphere** ("serene", "mysterious", "cheerful")
-
-## Error Handling
-
-Handle errors that may occur during image generation:
-
-```ruby
-begin
-  image = RubyLLM.paint("a sunset over mountains")
-  puts "Image generated: #{image.url}"
-rescue RubyLLM::UnauthorizedError
-  puts "Please check your API key"
-rescue RubyLLM::BadRequestError => e
-  puts "Invalid request: #{e.message}"
-rescue RubyLLM::Error => e
-  puts "Error generating image: #{e.message}"
-end
-```
-
-Common errors include:
-- `UnauthorizedError` - Invalid API key
-- `BadRequestError` - Content policy violation
-- `RateLimitError` - Too many requests
-- `ServiceUnavailableError` - Service temporarily unavailable
-
-## Content Safety
-
-Image generation models have built-in safety filters. If your prompt violates content policies, you'll receive an error.
-
-To avoid content policy violations:
-- Avoid requesting violent, adult, or disturbing content
-- Don't ask for images of real public figures
-- Avoid copyrighted characters and content
-- Be mindful of sensitive subject matter
-
-## Performance Considerations
-
-Image generation typically takes 5-15 seconds. Consider these best practices:
-
-1. **Handle asynchronously** - Don't block your application while waiting
-2. **Implement timeouts** - Set appropriate request timeouts
-3. **Cache results** - Save images to your server rather than regenerating
-4. **Implement retries** - Retry on temporary failures
-
-## Rails Integration
-
-In a Rails application, you might implement image generation like this:
-
-```ruby
-class ImagesController < ApplicationController
-  def create
-    GenerateImageJob.perform_later(
-      prompt: params[:prompt],
-      user_id: current_user.id
-    )
-
-    redirect_to images_path, notice: "Your image is being generated..."
-  end
-end
-
-class GenerateImageJob < ApplicationJob
-  queue_as :default
-
-  def perform(prompt:, user_id:)
-    user = User.find(user_id)
-
-    begin
-      image = RubyLLM.paint(prompt)
-
-      # Download and store the image
-      image_file = URI.open(image.url)
-
-      # Create record in your database
-      user.images.create!(
-        prompt: prompt,
-        revised_prompt: image.revised_prompt,
-        file: image_file,
-        model: image.model_id
-      )
-
-      # Notify user
-      UserMailer.image_ready(user, prompt).deliver_later
-    rescue RubyLLM::Error => e
-      ErrorLogger.log(e, context: { prompt: prompt, user_id: user_id })
-      UserMailer.image_failed(user, prompt, e.message).deliver_later
-    end
-  end
-end
-```
-
-## Example Use Cases
-
-### Product Visualization
-
-```ruby
-def visualize_product(product_name, description)
-  prompt = "#{product_name}: #{description}. " \
-           "Professional product photography on white background, " \
-           "detailed, commercial quality."
-
-  RubyLLM.paint(prompt, size: "1024x1024")
-end
-
-image = visualize_product(
-  "Ergonomic Office Chair",
-  "Modern mesh back office chair with adjustable armrests and lumbar support"
-)
-```
-
-### Art Generation for Content
-
-```ruby
-def generate_article_header(title, style)
-  prompt = "Header image for an article titled '#{title}'. " \
-           "Style: #{style}. Wide format, suitable for a blog header."
-
-  RubyLLM.paint(prompt, size: "1792x1024")
-end
-
-image = generate_article_header(
-  "The Future of Renewable Energy",
-  "Minimalist digital illustration with clean lines and a blue-green color palette"
-)
-```
-
-## Next Steps
-
-Now that you understand image generation, you might want to explore:
-
-- [Embeddings]({% link guides/embeddings.md %}) for vector representations
-- [Chat with Images]({% link guides/chat.md %}#working-with-images) to analyze images with AI
-- [Error Handling]({% link guides/error-handling.md %}) for robust applications

data/docs/guides/index.md

@@ -1,45 +0,0 @@
----
-layout: default
-title: Guides
-nav_order: 3
-has_children: true
-permalink: /guides/
----
-
-# RubyLLM Guides
-
-This section contains detailed guides to help you make the most of RubyLLM. Each guide focuses on a specific aspect of the library and provides practical examples and best practices.
-
-## Available Guides
-
-### [Getting Started]({% link guides/getting-started.md %})
-Learn the basics of RubyLLM and get up and running quickly with simple examples.
-
-### [Chat]({% link guides/chat.md %})
-Explore the chat interface, which is the primary way to interact with AI models through RubyLLM.
-
-### [Tools]({% link guides/tools.md %})
-Learn how to extend AI capabilities by creating tools that let models call your Ruby code.
-
-### [Streaming]({% link guides/streaming.md %})
-Understand how to use streaming responses for real-time interactions.
-
-### [Rails Integration]({% link guides/rails.md %})
-See how to integrate RubyLLM with Rails applications, including ActiveRecord persistence.
-
-### [Image Generation]({% link guides/image-generation.md %})
-Learn how to generate images using DALL-E and other providers.
-
-### [Embeddings]({% link guides/embeddings.md %})
-Explore how to create vector embeddings for semantic search and other applications.
-
-### [Error Handling]({% link guides/error-handling.md %})
-Master the techniques for robust error handling in AI applications.
-
-## Getting Help
-
-If you can't find what you're looking for in these guides, consider:
-
-1. Checking the [API Documentation]() for detailed information about specific classes and methods
-2. Looking at the [GitHub repository](https://github.com/yourusername/ruby_llm) for examples and the latest updates
-3. Filing an issue on GitHub if you find a bug or have a feature request