ollama-client 0.2.5 → 0.2.7

data/examples/dhanhq/README.md

@@ -1,236 +0,0 @@
-# DhanHQ Agent - Complete Trading & Technical Analysis System
-
-## Features
-
-### Core Capabilities
-- **Data Retrieval**: 6 DhanHQ Data APIs (Market Quote, LTP, Depth, Historical, Options, Chain)
-- **Trading Tools**: Order parameter building (regular, super orders, cancel)
-- **LLM-Powered Decisions**: Ollama for intelligent market analysis and decision making
-- **LLM Orchestration**: AI decides what symbols to analyze, which exchange segments, and what analysis to run
-
-### Technical Analysis (NEW!)
-- **Trend Analysis**: Uptrend, downtrend, sideways detection with strength calculation
-- **Market Structure**: SMC (Smart Money Concepts) analysis
-  - Order blocks identification
-  - Liquidity zones (buy-side/sell-side)
-  - Structure breaks detection
-- **Pattern Recognition**:
-  - Candlestick patterns (engulfing, hammer, shooting star, etc.)
-  - Chart patterns (head & shoulders, double top/bottom)
-- **Technical Indicators**:
-  - Moving Averages (SMA, EMA)
-  - RSI (Relative Strength Index)
-  - MACD (Moving Average Convergence Divergence)
-  - Bollinger Bands
-  - ATR (Average True Range)
-  - Support & Resistance levels
-
-### Scanners (NEW!)
-- **Swing Trading Scanner**: Find swing trading candidates based on technical analysis
-- **Intraday Options Scanner**: Find intraday options buying opportunities with IV/OI analysis
-
-## Structure
-
-```
-dhanhq/
-├── agents/                    # Agent classes (LLM decision makers)
-│   ├── base_agent.rb
-│   ├── data_agent.rb
-│   ├── trading_agent.rb
-│   ├── technical_analysis_agent.rb
-│   └── orchestrator_agent.rb  # NEW - LLM decides what to analyze
-├── services/                  # Service classes (API executors)
-│   ├── base_service.rb
-│   ├── data_service.rb
-│   └── trading_service.rb
-├── analysis/                  # Technical analysis modules (NEW)
-│   ├── market_structure.rb    # SMC, trend, structure breaks
-│   ├── pattern_recognizer.rb # Candlestick & chart patterns
-│   └── trend_analyzer.rb     # Comprehensive trend analysis
-├── indicators/                # Technical indicators (NEW)
-│   └── technical_indicators.rb # RSI, MACD, MA, Bollinger, ATR, etc.
-├── scanners/                  # Trading scanners (NEW)
-│   ├── swing_scanner.rb      # Swing trading candidates
-│   └── intraday_options_scanner.rb # Options opportunities
-├── builders/                  # Builder classes
-│   └── market_context_builder.rb
-├── utils/                     # Utility classes
-│   ├── instrument_helper.rb
-│   ├── parameter_normalizer.rb
-│   ├── parameter_cleaner.rb
-│   ├── trading_parameter_normalizer.rb
-│   └── rate_limiter.rb
-├── schemas/                   # JSON schemas for LLM
-│   └── agent_schemas.rb
-└── dhanhq_agent.rb            # Main entry point
-```
-
-## Design Principles
-
-- **SOLID**: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
-- **KISS**: Keep It Simple, Stupid
-- **DRY**: Don't Repeat Yourself
-- **Namespacing**: All classes under `DhanHQ` module
-
-## Usage
-
-### Basic Usage
-
-```ruby
-require_relative "dhanhq/dhanhq_agent"
-
-agent = DhanHQ::Agent.new
-
-# Data retrieval
-decision = agent.data_agent.analyze_and_decide(market_context: "...")
-result = agent.data_agent.execute_decision(decision)
-
-# Trading
-trading_decision = agent.trading_agent.analyze_and_decide(market_context: "...")
-order_params = agent.trading_agent.execute_decision(trading_decision)
-```
-
-### LLM Orchestration (NEW!)
-
-```ruby
-# Let LLM decide what to analyze
-plan = agent.orchestrator_agent.decide_analysis_plan(
-  market_context: "NIFTY is at 25,790, RELIANCE showing strength",
-  user_query: "Find swing trading opportunities in banking stocks"
-)
-
-# Plan contains:
-# - analysis_plan: Array of tasks with symbol, exchange_segment, analysis_type
-# - reasoning: Why the LLM chose this plan
-
-# Execute the plan
-plan["analysis_plan"].each do |task|
-  case task["analysis_type"]
-  when "technical_analysis"
-    agent.analysis_agent.analyze_symbol(...)
-  when "swing_scan"
-    agent.swing_scanner.scan_symbols(...)
-  when "options_scan"
-    agent.options_scanner.scan_for_options_setups(...)
-  end
-end
-```
-
-### Technical Analysis
-
-```ruby
-# Analyze a symbol
-analysis = agent.analysis_agent.analyze_symbol(
-  symbol: "RELIANCE",
-  exchange_segment: "NSE_EQ"
-)
-
-# Get swing trading recommendation
-recommendation = agent.analysis_agent.generate_recommendation(
-  analysis,
-  trading_style: :swing
-)
-```
-
-### Scanning
-
-```ruby
-# Swing trading scanner
-candidates = agent.swing_scanner.scan_symbols(
-  ["RELIANCE", "TCS", "INFY"],
-  exchange_segment: "NSE_EQ"
-)
-
-# Intraday options scanner
-options_setups = agent.options_scanner.scan_for_options_setups(
-  "NIFTY",
-  exchange_segment: "IDX_I"
-)
-```
-
-## Technical Analysis Capabilities
-
-### Trend Analysis
-- Detects uptrend, downtrend, sideways
-- Calculates trend strength percentage
-- Uses moving averages for confirmation
-
-### SMC (Smart Money Concepts)
-- **Order Blocks**: Identifies institutional order zones
-- **Liquidity Zones**: Finds buy-side and sell-side liquidity areas
-- **Structure Breaks**: Detects trend changes and breakouts
-
-### Pattern Recognition
-- **Candlestick Patterns**: Engulfing, hammer, shooting star, three white soldiers/crows
-- **Chart Patterns**: Head & shoulders, double top/bottom
-
-### Indicators
-- **RSI**: Overbought/oversold conditions
-- **MACD**: Momentum and trend changes
-- **Moving Averages**: Trend confirmation
-- **Bollinger Bands**: Volatility and mean reversion
-- **ATR**: Volatility measurement
-- **Support/Resistance**: Key price levels
-
-## Scanner Features
-
-### Swing Trading Scanner
-- Scores symbols based on:
-  - Trend strength
-  - RSI levels (prefers 40-60 zone)
-  - MACD bullish crossovers
-  - Structure breaks
-  - Pattern recognition
-- Returns top candidates sorted by score
-
-### Intraday Options Scanner
-- Analyzes underlying trend
-- Finds ATM/near-ATM strikes
-- Considers:
-  - Implied Volatility (lower is better for buying)
-  - Open Interest (higher is better)
-  - Volume (higher is better)
-  - Trend alignment
-  - RSI levels
-- Returns top 5 setups with scores
-
-## Running
-
-### Full Demo (All Features)
-```bash
-ruby examples/dhanhq/dhanhq_agent.rb
-```
-
-This will demonstrate:
-1. Data retrieval with LLM decisions
-2. Trading order parameter building
-3. Technical analysis for a symbol
-4. Swing trading scanner
-5. Intraday options scanner
-
-### Technical Analysis Only
-```bash
-# LLM decides what to analyze (default)
-ruby examples/dhanhq/technical_analysis_runner.rb
-
-# With custom query
-ruby examples/dhanhq/technical_analysis_runner.rb "Find options opportunities for NIFTY"
-
-# With custom query and market context
-ruby examples/dhanhq/technical_analysis_runner.rb "Analyze banking stocks" "Banking sector showing strength"
-
-# Show manual examples too (for comparison)
-SHOW_MANUAL_EXAMPLES=true ruby examples/dhanhq/technical_analysis_runner.rb
-```
-
-**LLM-Powered Orchestration:**
-The LLM decides:
-- Which symbols to analyze (e.g., "RELIANCE", "NIFTY", "BANKNIFTY")
-- Which exchange segments to use (NSE_EQ, IDX_I, etc.)
-- What type of analysis to run (technical_analysis, swing_scan, options_scan)
-- Priority order of analysis tasks
-
-This makes the system truly autonomous - you just ask what you want, and the LLM figures out how to get it.
-
-**Manual Examples (optional):**
-If `SHOW_MANUAL_EXAMPLES=true`, it also runs fixed examples for comparison.

data/examples/dhanhq/agents/base_agent.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../utils/parameter_normalizer"
-require_relative "../utils/parameter_cleaner"
-
-module DhanHQ
-  module Agents
-    # Base class for all agents with common LLM interaction logic
-    class BaseAgent
-      MIN_CONFIDENCE = 0.6
-
-      def initialize(ollama_client:, schema:)
-        @ollama_client = ollama_client
-        @schema = schema
-      end
-
-      def analyze_and_decide(market_context:)
-        prompt = build_analysis_prompt(market_context: market_context)
-
-        decision = call_llm(prompt)
-        return invalid_decision unless valid_decision?(decision)
-
-        decision = clean_parameters(decision)
-        return low_confidence_decision(decision) if low_confidence?(decision)
-
-        decision
-      rescue StandardError => e
-        error_decision(e.message)
-      end
-
-      protected
-
-      def build_analysis_prompt(market_context:)
-        raise NotImplementedError, "Subclasses must implement build_analysis_prompt"
-      end
-
-      private
-
-      def call_llm(prompt)
-        @ollama_client.generate(prompt: prompt, schema: @schema)
-      end
-
-      def valid_decision?(decision)
-        decision.is_a?(Hash) && decision["confidence"]
-      end
-
-      def clean_parameters(decision)
-        return decision unless decision["parameters"].is_a?(Hash)
-
-        cleaned_params = DhanHQ::Utils::ParameterCleaner.clean(decision["parameters"])
-        decision.merge("parameters" => cleaned_params)
-      end
-
-      def low_confidence?(decision)
-        decision["confidence"] < MIN_CONFIDENCE
-      end
-
-      def invalid_decision
-        { action: "no_action", reason: "invalid_decision" }
-      end
-
-      def low_confidence_decision(decision)
-        confidence_pct = (decision["confidence"] * 100).round
-        puts "⚠️  Low confidence (#{confidence_pct}%) - skipping action"
-        { action: "no_action", reason: "low_confidence" }
-      end
-
-      def error_decision(message)
-        puts "❌ Ollama error: #{message}"
-        { action: "no_action", reason: "error", error: message }
-      end
-    end
-  end
-end

data/examples/dhanhq/agents/data_agent.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_agent"
-require_relative "../schemas/agent_schemas"
-require_relative "../services/data_service"
-
-module DhanHQ
-  module Agents
-    # Agent for market data retrieval decisions using LLM
-    class DataAgent < BaseAgent
-      def initialize(ollama_client:)
-        super(ollama_client: ollama_client, schema: DhanHQ::Schemas::AgentSchemas::DATA_AGENT_SCHEMA)
-        @data_service = DhanHQ::Services::DataService.new
-      end
-
-      def execute_decision(decision)
-        action = decision["action"]
-        params = DhanHQ::Utils::ParameterNormalizer.normalize(decision["parameters"] || {})
-
-        @data_service.execute(action: action, params: params)
-      end
-
-      protected
-
-      def build_analysis_prompt(market_context:)
-        <<~PROMPT
-          Analyze the following market situation and decide the best data retrieval action:
-
-          Market Context:
-          #{market_context}
-
-          Available Actions (DATA ONLY - NO TRADING):
-          - get_market_quote: Get market quote using Instrument.quote convenience method (requires: symbol OR security_id as STRING, exchange_segment as STRING)
-          - get_live_ltp: Get live last traded price using Instrument.ltp convenience method (requires: symbol OR security_id as STRING, exchange_segment as STRING)
-          - get_market_depth: Get full market depth (bid/ask levels) using Instrument.quote convenience method (requires: symbol OR security_id as STRING, exchange_segment as STRING)
-          - get_historical_data: Get historical data using Instrument.daily/intraday convenience methods (requires: symbol OR security_id as STRING, exchange_segment as STRING, from_date, to_date, optional: interval, expiry_code)
-          - get_expired_options_data: Get expired options historical data (requires: symbol OR security_id as STRING, exchange_segment as STRING, expiry_date; optional: expiry_code, interval, instrument, expiry_flag, strike, drv_option_type, required_data)
-          - get_option_chain: Get option chain using Instrument.expiry_list/option_chain convenience methods (requires: symbol OR security_id as STRING, exchange_segment as STRING, optional: expiry)
-          - no_action: Take no action if unclear what data is needed
-
-          CRITICAL: Each API call handles ONLY ONE symbol at a time. If you need data for multiple symbols, choose ONE symbol for this decision.
-          - symbol must be a SINGLE STRING value (e.g., "NIFTY" or "RELIANCE"), NOT an array
-          - exchange_segment must be a SINGLE STRING value (e.g., "NSE_EQ" or "IDX_I"), NOT an array
-          - All APIs use Instrument.find() which expects SYMBOL (e.g., "NIFTY", "RELIANCE"), not security_id
-          - Instrument convenience methods automatically use the instrument's security_id, exchange_segment, and instrument attributes
-          - Use symbol when possible for better compatibility
-          Examples:
-            - For NIFTY: symbol="NIFTY", exchange_segment="IDX_I"
-            - For RELIANCE: symbol="RELIANCE", exchange_segment="NSE_EQ"
-          Valid exchange_segments: NSE_EQ, NSE_FNO, NSE_CURRENCY, BSE_EQ, BSE_FNO, BSE_CURRENCY, MCX_COMM, IDX_I
-
-          Decision Criteria:
-          - Only take actions with confidence > 0.6
-          - Focus on data retrieval, not trading decisions
-          - Provide all required parameters for the chosen action
-
-          Respond with a JSON object containing:
-          - action: one of the available actions
-          - reasoning: why this action was chosen
-          - confidence: your confidence level (0-1)
-          - parameters: object with required parameters for the action
-        PROMPT
-      end
-    end
-  end
-end

data/examples/dhanhq/agents/orchestrator_agent.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_agent"
-require_relative "../schemas/agent_schemas"
-
-module DhanHQ
-  module Agents
-    # Orchestrator agent that uses LLM to decide what to analyze
-    class OrchestratorAgent < BaseAgent
-      def initialize(ollama_client:)
-        super(ollama_client: ollama_client, schema: build_orchestration_schema)
-      end
-
-      def decide_analysis_plan(market_context: "", user_query: "")
-        prompt = build_orchestration_prompt(market_context: market_context, user_query: user_query)
-
-        begin
-          plan = @ollama_client.generate(
-            prompt: prompt,
-            schema: build_orchestration_schema
-          )
-
-          return { error: "Invalid plan" } unless plan.is_a?(Hash) && plan["analysis_plan"]
-
-          plan
-        rescue Ollama::Error => e
-          { error: e.message }
-        end
-      end
-
-      protected
-
-      def build_analysis_prompt(*)
-        ""
-      end
-
-      private
-
-      def build_orchestration_prompt(market_context:, user_query:)
-        <<~PROMPT
-          You are a trading analysis orchestrator. Based on the market context and user query, decide what technical analysis to perform.
-
-          Market Context:
-          #{market_context.empty? ? 'No specific market context provided' : market_context}
-
-          User Query:
-          #{user_query.empty? ? 'No specific query - analyze current market opportunities' : user_query}
-
-          Your task is to create an analysis plan that includes:
-          1. Which symbols to analyze:
-             - Equity stocks: "RELIANCE", "TCS", "INFY", "HDFC" (use NSE_EQ or BSE_EQ)
-             - Indices: "NIFTY", "SENSEX", "BANKNIFTY" (use IDX_I)
-          2. Which exchange segments to use:
-             - NSE_EQ or BSE_EQ for equity stocks
-             - IDX_I for indices (NIFTY, SENSEX, BANKNIFTY)
-          3. What type of analysis to perform:
-             - "technical_analysis": Full technical analysis (trend, indicators, patterns) - can be used for both stocks and indices
-             - "swing_scan": Scan for swing trading opportunities - ONLY for equity stocks, NEVER for indices
-             - "options_scan": Scan for intraday options opportunities - ONLY for indices (NIFTY, SENSEX, BANKNIFTY)
-             - "all": Run all applicable analysis types (swing_scan only for stocks, options_scan only for indices)
-          4. Priority order (which symbols/analyses to run first)
-
-          Consider:
-          - If user mentions specific stocks, prioritize those
-          - If user asks about "swing trading", use swing_scan ONLY for equity stocks (not indices)
-          - If user asks about "options" or "intraday", use options_scan
-          - If no specific query, scan for opportunities across multiple symbols
-          - CRITICAL: Index symbols (NIFTY, SENSEX, BANKNIFTY) are INDICES, not stocks
-            * Indices should ONLY be analyzed with options_scan (for options buying opportunities)
-            * Indices should NEVER be analyzed with swing_scan (swing trading is for stocks only)
-          - For options, use index symbols (NIFTY, SENSEX, BANKNIFTY) with IDX_I segment
-          - For swing trading, use ONLY equity symbols (RELIANCE, TCS, INFY, HDFC) with NSE_EQ or BSE_EQ segment
-
-          Respond with a JSON object containing your analysis plan.
-        PROMPT
-      end
-
-      def build_orchestration_schema
-        {
-          "type" => "object",
-          "required" => ["analysis_plan", "reasoning"],
-          "properties" => {
-            "analysis_plan" => {
-              "type" => "array",
-              "items" => {
-                "type" => "object",
-                "required" => ["symbol", "exchange_segment", "analysis_type"],
-                "properties" => {
-                  "symbol" => {
-                    "type" => "string",
-                    "description" => "Symbol to analyze (e.g., 'RELIANCE', 'NIFTY', 'TCS')"
-                  },
-                  "exchange_segment" => {
-                    "type" => "string",
-                    "enum" => ["NSE_EQ", "NSE_FNO", "NSE_CURRENCY", "BSE_EQ", "BSE_FNO",
-                               "BSE_CURRENCY", "MCX_COMM", "IDX_I"],
-                    "description" => "Exchange segment for the symbol"
-                  },
-                  "analysis_type" => {
-                    "type" => "string",
-                    "enum" => ["technical_analysis", "swing_scan", "options_scan", "all"],
-                    "description" => "Type of analysis to perform"
-                  },
-                  "priority" => {
-                    "type" => "number",
-                    "description" => "Priority (1 = highest, lower numbers = higher priority)"
-                  }
-                }
-              }
-            },
-            "reasoning" => {
-              "type" => "string",
-              "description" => "Why you chose this analysis plan"
-            }
-          }
-        }
-      end
-    end
-  end
-end