ollama-client 0.2.1 → 0.2.3

data/examples/test_dhanhq_tool_calling.rb

@@ -0,0 +1,375 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Test DhanHQ Tool Calling with chat_raw()
+# Demonstrates using structured Tool classes with DhanHQ tools
+
+require_relative "lib/ollama_client"
+require_relative "examples/dhanhq_tools"
+require "date"
+
+puts "\n=== DHANHQ TOOL CALLING TEST ===\n"
+puts "Using chat_raw() to access tool_calls\n"
+
+client = Ollama::Client.new
+
+# Define DhanHQ tools using structured Tool classes
+# This provides better type safety and LLM understanding
+
+# Market Quote Tool
+market_quote_tool = Ollama::Tool.new(
+  type: "function",
+  function: Ollama::Tool::Function.new(
+    name: "get_market_quote",
+    description: "Get market quote for a symbol. Returns OHLC, depth, volume, and other market data.",
+    parameters: Ollama::Tool::Function::Parameters.new(
+      type: "object",
+      properties: {
+        symbol: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Stock or index symbol (e.g., RELIANCE, NIFTY)"
+        ),
+        exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Exchange segment",
+          enum: %w[NSE_EQ NSE_FNO BSE_EQ BSE_FNO IDX_I]
+        )
+      },
+      required: %w[symbol exchange_segment]
+    )
+  )
+)
+
+# Live LTP Tool
+live_ltp_tool = Ollama::Tool.new(
+  type: "function",
+  function: Ollama::Tool::Function.new(
+    name: "get_live_ltp",
+    description: "Get live last traded price (LTP) for a symbol. Fast API for current price.",
+    parameters: Ollama::Tool::Function::Parameters.new(
+      type: "object",
+      properties: {
+        symbol: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Stock or index symbol"
+        ),
+        exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Exchange segment",
+          enum: %w[NSE_EQ NSE_FNO BSE_EQ BSE_FNO IDX_I]
+        )
+      },
+      required: %w[symbol exchange_segment]
+    )
+  )
+)
+
+# Historical Data Tool
+historical_data_tool = Ollama::Tool.new(
+  type: "function",
+  function: Ollama::Tool::Function.new(
+    name: "get_historical_data",
+    description: "Get historical price data (OHLCV) or technical indicators. " \
+                 "Use interval for intraday data (1, 5, 15, 25, 60 minutes). " \
+                 "Omit interval for daily data. " \
+                 "Set calculate_indicators=true to get technical indicators " \
+                 "(RSI, MACD, SMA, EMA, Bollinger Bands, ATR) instead of raw data.",
+    parameters: Ollama::Tool::Function::Parameters.new(
+      type: "object",
+      properties: {
+        symbol: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Stock or index symbol"
+        ),
+        exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Exchange segment",
+          enum: %w[NSE_EQ NSE_FNO BSE_EQ BSE_FNO IDX_I]
+        ),
+        interval: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Minute interval for intraday data. Omit for daily data. " \
+                       "Values: 1 (1-min), 5 (5-min), 15 (15-min), 25 (25-min), 60 (1-hour)",
+          enum: %w[1 5 15 25 60]
+        ),
+        from_date: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Start date (YYYY-MM-DD format)"
+        ),
+        to_date: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "End date (YYYY-MM-DD format, non-inclusive)"
+        ),
+        calculate_indicators: Ollama::Tool::Function::Parameters::Property.new(
+          type: "boolean",
+          description: "If true, returns technical indicators instead of raw data. " \
+                       "Reduces response size and provides ready-to-use indicator values."
+        )
+      },
+      required: %w[symbol exchange_segment from_date to_date]
+    )
+  )
+)
+
+# Combine tools
+dhanhq_tools = [market_quote_tool, live_ltp_tool, historical_data_tool]
+
+puts "--- Test 1: Single tool (Market Quote) ---"
+puts "Request: Get market quote for RELIANCE\n"
+
+begin
+  response = client.chat_raw(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user("Get the market quote for RELIANCE stock")],
+    tools: market_quote_tool,
+    allow_chat: true
+  )
+
+  puts "✅ Response received"
+  puts "Response class: #{response.class.name}\n"
+
+  # Method access (recommended - like ollama-ruby)
+  tool_calls = response.message&.tool_calls
+  if tool_calls && !tool_calls.empty?
+    puts "✅ Tool calls detected (via method access):"
+    tool_calls.each do |call|
+      puts "  Tool: #{call.name}"
+      puts "  Arguments: #{call.arguments.inspect}"
+      puts "  ID: #{call.id}\n"
+    end
+  else
+    puts "⚠️  No tool calls detected"
+    puts "Content: #{response.message&.content}\n"
+  end
+rescue Ollama::Error => e
+  puts "❌ Error: #{e.class.name}"
+  puts "   Message: #{e.message}"
+  puts "\n   Note: Expected if Ollama server is not running"
+  puts "   The important part is that tool_calls structure is correct"
+end
+
+puts "\n--- Test 2: Multiple tools (LLM chooses) ---"
+puts "Request: Get current price for NIFTY\n"
+
+begin
+  response = client.chat_raw(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user("What's the current price of NIFTY?")],
+    tools: dhanhq_tools, # Array of Tool objects
+    allow_chat: true
+  )
+
+  puts "✅ Response received\n"
+
+  tool_calls = response.message&.tool_calls
+  if tool_calls && !tool_calls.empty?
+    puts "✅ Tool calls detected:"
+    tool_calls.each do |call|
+      puts "  - #{call.name}"
+      puts "    Args: #{call.arguments.inspect}\n"
+    end
+  else
+    puts "⚠️  No tool calls detected"
+    puts "Content: #{response.message&.content}\n"
+  end
+rescue Ollama::Error => e
+  puts "❌ Error: #{e.class.name}"
+  puts "   Message: #{e.message}"
+end
+
+puts "\n--- Test 3: Compare chat() vs chat_raw() ---"
+puts "Request: Get RELIANCE market data\n"
+
+# chat_raw() - returns full response with tool_calls
+puts "\nUsing chat_raw() (recommended for tool calling):"
+begin
+  response = client.chat_raw(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user("Get market data for RELIANCE")],
+    tools: market_quote_tool,
+    allow_chat: true
+  )
+
+  tool_calls = response.message&.tool_calls
+  if tool_calls && !tool_calls.empty?
+    puts "  ✅ Can access tool_calls: #{tool_calls.length} call(s)"
+  else
+    puts "  ⚠️  No tool_calls (content only)"
+  end
+rescue Ollama::Error => e
+  puts "  ❌ Error: #{e.message}"
+end
+
+# chat() - returns content only
+puts "\nUsing chat() (not recommended for tool calling):"
+begin
+  content = client.chat(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user("Get market data for RELIANCE")],
+    tools: market_quote_tool,
+    allow_chat: true
+  )
+
+  if content.empty?
+    puts "  ⚠️  Content is empty (tool_calls present but not accessible)"
+    puts "  💡 Use chat_raw() to access tool_calls"
+  else
+    puts "  ✅ Content: #{content[0..50]}..."
+  end
+rescue Ollama::Error => e
+  puts "  ❌ Error: #{e.message}"
+end
+
+puts "\n--- Test 4: Full flow - Execute tool after getting tool_calls ---"
+puts "Request: Get market quote for RELIANCE and execute it\n"
+
+begin
+  # Step 1: Get tool_calls from LLM
+  response = client.chat_raw(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user("Get the market quote for RELIANCE stock on NSE")],
+    tools: market_quote_tool,
+    allow_chat: true
+  )
+
+  tool_calls = response.message&.tool_calls
+  if tool_calls && !tool_calls.empty?
+    puts "✅ Step 1: Tool call received from LLM"
+    call = tool_calls.first
+    puts "  Tool: #{call.name}"
+    puts "  Arguments: #{call.arguments.inspect}\n"
+
+    # Step 2: Execute the tool (finds instrument first, then calls API)
+    args = call.arguments
+    symbol = args["symbol"] || args[:symbol]
+    exchange_segment = args["exchange_segment"] || args[:exchange_segment]
+
+    puts "✅ Step 2: Executing tool..."
+    puts "  Finding instrument: #{symbol} on #{exchange_segment}"
+
+    begin
+      # The tool will find instrument internally
+      result = DhanHQDataTools.get_market_quote(
+        symbol: symbol,
+        exchange_segment: exchange_segment
+      )
+
+      if result[:error]
+        puts "  ❌ Error: #{result[:error]}"
+      else
+        puts "  ✅ Instrument found and quote retrieved"
+        quote = result[:result][:quote]
+        if quote
+          ohlc = quote[:ohlc]
+          puts "  📊 Last Price: #{quote[:last_price]}"
+          puts "  📊 Volume: #{quote[:volume]}"
+          puts "  📊 OHLC: O=#{ohlc[:open]}, H=#{ohlc[:high]}, " \
+               "L=#{ohlc[:low]}, C=#{ohlc[:close]}"
+        end
+      end
+    rescue StandardError => e
+      puts "  ❌ Tool execution error: #{e.message}"
+      puts "  Note: This is expected if DhanHQ is not configured or market is closed"
+    end
+
+    # Step 3: Feed result back to LLM (optional - for multi-turn)
+    puts "\n✅ Step 3: Tool result can be fed back to LLM for next turn"
+    puts "  (This would be done automatically by Executor)"
+
+  else
+    puts "⚠️  No tool calls detected"
+  end
+rescue Ollama::Error => e
+  puts "❌ Error: #{e.class.name}"
+  puts "   Message: #{e.message}"
+end
+
+puts "\n--- Test 5: Historical Data with Technical Indicators ---"
+puts "Request: Get NIFTY intraday data with technical indicators\n"
+
+begin
+  response = client.chat_raw(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user(
+      "Get intraday historical data for NIFTY with technical indicators for the last 30 days"
+    )],
+    tools: historical_data_tool,
+    allow_chat: true
+  )
+
+  tool_calls = response.message&.tool_calls
+  if tool_calls && !tool_calls.empty?
+    puts "✅ Tool call received"
+    call = tool_calls.first
+    puts "  Tool: #{call.name}"
+    puts "  Arguments: #{call.arguments.inspect}\n"
+
+    args = call.arguments
+    puts "  Expected parameters:"
+    puts "    - symbol: #{args['symbol'] || args[:symbol]}"
+    puts "    - exchange_segment: #{args['exchange_segment'] || args[:exchange_segment]}"
+    puts "    - interval: #{args['interval'] || args[:interval]} (for intraday)"
+    puts "    - from_date: #{args['from_date'] || args[:from_date]}"
+    puts "    - to_date: #{args['to_date'] || args[:to_date]}"
+    puts "    - calculate_indicators: #{args['calculate_indicators'] || args[:calculate_indicators]}"
+  else
+    puts "⚠️  No tool calls detected"
+    puts "Content: #{response.message&.content}\n"
+  end
+rescue Ollama::Error => e
+  puts "❌ Error: #{e.class.name}"
+  puts "   Message: #{e.message}"
+end
+
+puts "\n--- Test 6: Intraday Data with 5-minute intervals ---"
+puts "Request: Get NIFTY 5-minute intraday data for today\n"
+
+begin
+  today = Date.today.strftime("%Y-%m-%d")
+  response = client.chat_raw(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user(
+      "Get NIFTY intraday data with 5-minute intervals for today (#{today})"
+    )],
+    tools: historical_data_tool,
+    allow_chat: true
+  )
+
+  tool_calls = response.message&.tool_calls
+  if tool_calls && !tool_calls.empty?
+    puts "✅ Tool call received"
+    call = tool_calls.first
+    args = call.arguments
+
+    puts "  Verifying intraday parameters:"
+    interval = args["interval"] || args[:interval]
+    if %w[1 5 15 25 60].include?(interval.to_s)
+      puts "    ✅ Interval: #{interval} (valid intraday value)"
+    else
+      puts "    ❌ Interval: #{interval} (should be one of: 1, 5, 15, 25, 60)"
+    end
+
+    from_date = args["from_date"] || args[:from_date]
+    to_date = args["to_date"] || args[:to_date]
+    puts "    Date range: #{from_date} to #{to_date}"
+  else
+    puts "⚠️  No tool calls detected"
+  end
+rescue Ollama::Error => e
+  puts "❌ Error: #{e.message}"
+end
+
+puts "\n--- Summary ---"
+puts "✅ Use chat_raw() for tool calling - gives access to tool_calls"
+puts "⚠️  Use chat() only for simple content responses (no tool_calls needed)"
+puts "📝 Tool execution flow:"
+puts "   1. LLM requests tool via chat_raw() → get tool_calls"
+puts "   2. Find instrument using exchange_segment + symbol"
+puts "   3. Execute tool with instrument"
+puts "   4. Feed result back to LLM (if using Executor)"
+puts "\n📊 Historical Data enhancements:"
+puts "   - Use interval (1, 5, 15, 25, 60) for intraday data"
+puts "   - Omit interval for daily data"
+puts "   - Use calculate_indicators: true for technical indicators (RSI, MACD, etc.)"
+puts "   - Reduces response size and provides ready-to-use indicator values"
+puts "\n=== DONE ===\n"

data/examples/test_tool_calling.rb

@@ -0,0 +1,160 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Quick test script to verify Tool calling with chat_raw() and chat()
+# This demonstrates the new structured Tool classes and Response wrapper
+
+require_relative "lib/ollama_client"
+
+puts "\n=== TOOL CALLING TEST ===\n"
+
+client = Ollama::Client.new
+
+# Define a simple tool using structured Tool classes
+weather_tool = Ollama::Tool.new(
+  type: "function",
+  function: Ollama::Tool::Function.new(
+    name: "get_weather",
+    description: "Get the current weather for a location",
+    parameters: Ollama::Tool::Function::Parameters.new(
+      type: "object",
+      properties: {
+        location: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "The city name, e.g. Paris, London"
+        ),
+        unit: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Temperature unit",
+          enum: %w[celsius fahrenheit]
+        )
+      },
+      required: %w[location]
+    )
+  )
+)
+
+# Test 1: Using chat_raw() to access tool_calls
+puts "\n--- Test 1: chat_raw() with Tool object ---"
+puts "Sending request with tool definition..."
+
+begin
+  response = client.chat_raw(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user("What's the weather in Paris? Use celsius.")],
+    tools: weather_tool,
+    allow_chat: true
+  )
+
+  puts "\n✅ Response received"
+  puts "Response class: #{response.class.name}"
+
+  # Method access (like ollama-ruby)
+  tool_calls = response.message&.tool_calls
+  if tool_calls && !tool_calls.empty?
+    puts "\n✅ Tool calls detected (via method access):"
+    tool_calls.each do |call|
+      puts "  - Tool: #{call.name}"
+      puts "    Arguments: #{call.arguments}"
+      puts "    ID: #{call.id}"
+    end
+  else
+    puts "\n⚠️  No tool calls detected"
+    puts "Content: #{response.message&.content}"
+  end
+
+  # Hash access (backward compatible)
+  tool_calls_hash = response.to_h.dig("message", "tool_calls")
+  if tool_calls_hash && !tool_calls_hash.empty?
+    puts "\n✅ Tool calls also accessible via hash:"
+    puts "  Count: #{tool_calls_hash.length}"
+  end
+rescue Ollama::Error => e
+  puts "\n❌ Error: #{e.class.name}"
+  puts "   Message: #{e.message}"
+  puts "\n   Note: This is expected if Ollama server is not running"
+  puts "   The important part is that the code structure is correct"
+end
+
+# Test 2: Using chat() with tools (returns content only)
+puts "\n--- Test 2: chat() with Tool object ---"
+puts "Sending request with tool definition..."
+
+begin
+  content = client.chat(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user("What's the weather in London?")],
+    tools: weather_tool,
+    allow_chat: true
+  )
+
+  puts "\n✅ Response received"
+  if content.empty?
+    puts "⚠️  Content is empty (model returned only tool_calls)"
+    puts "   Use chat_raw() to access tool_calls"
+  else
+    puts "Content: #{content}"
+  end
+rescue Ollama::Error => e
+  puts "\n❌ Error: #{e.class.name}"
+  puts "   Message: #{e.message}"
+end
+
+# Test 3: Multiple tools (array)
+puts "\n--- Test 3: Multiple tools (array) ---"
+
+time_tool = Ollama::Tool.new(
+  type: "function",
+  function: Ollama::Tool::Function.new(
+    name: "get_time",
+    description: "Get the current time",
+    parameters: Ollama::Tool::Function::Parameters.new(
+      type: "object",
+      properties: {
+        timezone: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Timezone (default: UTC)",
+          enum: %w[UTC EST PST]
+        )
+      },
+      required: []
+    )
+  )
+)
+
+begin
+  response = client.chat_raw(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user("What time is it? Use the get_time tool.")],
+    tools: [weather_tool, time_tool], # Array of Tool objects
+    allow_chat: true
+  )
+
+  puts "\n✅ Response received"
+  tool_calls = response.message&.tool_calls
+  if tool_calls && !tool_calls.empty?
+    puts "\n✅ Tool calls detected:"
+    tool_calls.each do |call|
+      puts "  - #{call.name}: #{call.arguments}"
+    end
+  else
+    puts "\n⚠️  No tool calls detected"
+  end
+rescue Ollama::Error => e
+  puts "\n❌ Error: #{e.class.name}"
+  puts "   Message: #{e.message}"
+end
+
+# Test 4: Verify Tool object structure
+puts "\n--- Test 4: Tool object structure ---"
+puts "Weather tool:"
+puts "  Type: #{weather_tool.type}"
+puts "  Function name: #{weather_tool.function.name}"
+puts "  Function description: #{weather_tool.function.description}"
+puts "  Parameters type: #{weather_tool.function.parameters.type}"
+puts "  Required params: #{weather_tool.function.parameters.required}"
+
+puts "\nTool.to_h (for API):"
+puts weather_tool.to_h.inspect
+
+puts "\n=== DONE ===\n"

data/examples/tool_calling_direct.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Direct Tool Calling (matching ollama-ruby pattern)
+# Demonstrates using Tool objects directly with chat() and chat_raw()
+
+require "json"
+require_relative "../lib/ollama_client"
+
+puts "\n=== DIRECT TOOL CALLING EXAMPLE ===\n"
+
+client = Ollama::Client.new
+
+# Define tool using Tool classes (matching ollama-ruby pattern)
+tool = Ollama::Tool.new(
+  type: "function",
+  function: Ollama::Tool::Function.new(
+    name: "get_current_weather",
+    description: "Get the current weather for a location",
+    parameters: Ollama::Tool::Function::Parameters.new(
+      type: "object",
+      properties: {
+        location: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "The location to get the weather for, e.g. San Francisco, CA"
+        ),
+        temperature_unit: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "The unit to return the temperature in, either 'celsius' or 'fahrenheit'",
+          enum: %w[celsius fahrenheit]
+        )
+      },
+      required: %w[location temperature_unit]
+    )
+  )
+)
+
+# Create message
+def message(location)
+  Ollama::Agent::Messages.user("What is the weather today in #{location}?")
+end
+
+puts "\n--- Using chat_raw() to access tool_calls ---"
+
+# Use chat_raw() to get full response with tool_calls
+response = client.chat_raw(
+  model: "llama3.1:8b",
+  messages: [message("The City of Love")],
+  tools: tool, # Pass Tool object directly
+  allow_chat: true
+)
+
+# Access tool_calls from response (using method access like ollama-ruby)
+tool_calls = response.message&.tool_calls
+if tool_calls && !tool_calls.empty?
+  puts "\nTool calls detected:"
+  tool_calls.each do |call|
+    name = call.name
+    args = call.arguments
+    puts "  - #{name}: #{args}"
+  end
+else
+  puts "\nNo tool calls in response"
+  puts "Response: #{response.message&.content}"
+end
+
+# You can also use hash access if preferred:
+# tool_calls = response.to_h.dig("message", "tool_calls")
+
+puts "\n--- Using chat() with tools (returns content only) ---"
+
+# chat() returns only the content, not tool_calls
+# When tools are used and model returns only tool_calls (no content),
+# chat() returns empty string. Use chat_raw() to access tool_calls.
+begin
+  content = client.chat(
+    model: "llama3.1:8b",
+    messages: [message("The Windy City")],
+    tools: tool,
+    allow_chat: true
+  )
+
+  if content.empty?
+    puts "Content: (empty - model returned only tool_calls, use chat_raw() to access them)"
+  else
+    puts "Content: #{content}"
+  end
+rescue Ollama::Error => e
+  puts "Note: #{e.message}"
+  puts "For tool calling, use chat_raw() instead of chat()"
+end
+
+puts "\n--- Multiple tools (array) ---"
+
+# You can also pass an array of tools
+tool2 = Ollama::Tool.new(
+  type: "function",
+  function: Ollama::Tool::Function.new(
+    name: "get_time",
+    description: "Get the current time",
+    parameters: Ollama::Tool::Function::Parameters.new(
+      type: "object",
+      properties: {},
+      required: []
+    )
+  )
+)
+
+response2 = client.chat_raw(
+  model: "llama3.1:8b",
+  messages: [Ollama::Agent::Messages.user("What time is it? Use the get_time tool.")],
+  tools: [tool, tool2], # Array of Tool objects
+  allow_chat: true
+)
+
+tool_calls2 = response2.message&.tool_calls
+if tool_calls2 && !tool_calls2.empty?
+  puts "\nTool calls from multiple tools:"
+  tool_calls2.each do |call|
+    puts "  - #{call.name}"
+  end
+end
+
+puts "\n=== DONE ===\n"