prescient 0.0.0 → 0.1.0

data/lib/prescient/provider/anthropic.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+class Prescient::Provider::Anthropic < Prescient::Base
+  include HTTParty
+
+  base_uri 'https://api.anthropic.com'
+
+  def initialize(**options)
+    super
+    self.class.default_timeout(@options[:timeout] || 60)
+  end
+
+  def generate_embedding(_text, **_options)
+    # Anthropic doesn't provide embedding API, raise error
+    raise Prescient::Error,
+          'Anthropic provider does not support embeddings. Use OpenAI or HuggingFace for embeddings.'
+  end
+
+  def generate_response(prompt, context_items = [], **options)
+    handle_errors do
+      formatted_prompt = build_prompt(prompt, context_items)
+
+      response = self.class.post('/v1/messages',
+                                 headers: {
+                                   'Content-Type'      => 'application/json',
+                                   'x-api-key'         => @options[:api_key],
+                                   'anthropic-version' => '2023-06-01',
+                                 },
+                                 body:    {
+                                   model:       @options[:model],
+                                   max_tokens:  options[:max_tokens] || 2000,
+                                   temperature: options[:temperature] || 0.7,
+                                   messages:    [
+                                     {
+                                       role:    'user',
+                                       content: formatted_prompt,
+                                     },
+                                   ],
+                                 }.to_json)
+
+      validate_response!(response, 'text generation')
+
+      content = response.parsed_response.dig('content', 0, 'text')
+      raise Prescient::InvalidResponseError, 'No response generated' unless content
+
+      {
+        response:        content.strip,
+        model:           @options[:model],
+        provider:        'anthropic',
+        processing_time: nil,
+        metadata:        {
+          usage: response.parsed_response['usage'],
+        },
+      }
+    end
+  end
+
+  def health_check
+    handle_errors do
+      # Test with a simple message
+      response = self.class.post('/v1/messages',
+                                 headers: {
+                                   'Content-Type'      => 'application/json',
+                                   'x-api-key'         => @options[:api_key],
+                                   'anthropic-version' => '2023-06-01',
+                                 },
+                                 body:    {
+                                   model:      @options[:model],
+                                   max_tokens: 10,
+                                   messages:   [
+                                     {
+                                       role:    'user',
+                                       content: 'Test',
+                                     },
+                                   ],
+                                 }.to_json)
+
+      if response.success?
+        {
+          status:   'healthy',
+          provider: 'anthropic',
+          model:    @options[:model],
+          ready:    true,
+        }
+      else
+        {
+          status:   'unhealthy',
+          provider: 'anthropic',
+          error:    "HTTP #{response.code}",
+          message:  response.message,
+        }
+      end
+    end
+  rescue Prescient::ConnectionError => e
+    {
+      status:   'unavailable',
+      provider: 'anthropic',
+      error:    e.class.name,
+      message:  e.message,
+    }
+  end
+
+  def list_models
+    # Anthropic doesn't provide a models list API
+    [
+      { name: 'claude-3-haiku-20240307', type: 'text' },
+      { name: 'claude-3-sonnet-20240229', type: 'text' },
+      { name: 'claude-3-opus-20240229', type: 'text' },
+    ]
+  end
+
+  protected
+
+  def validate_configuration!
+    required_options = [:api_key, :model]
+    missing_options = required_options.select { |opt| @options[opt].nil? }
+
+    return unless missing_options.any?
+
+    raise Prescient::Error, "Missing required options: #{missing_options.join(', ')}"
+  end
+
+  private
+
+  def validate_response!(response, operation)
+    return if response.success?
+
+    case response.code
+    when 400
+      raise Prescient::Error, "Bad request for #{operation}: #{response.body}"
+    when 401
+      raise Prescient::AuthenticationError, "Authentication failed for #{operation}"
+    when 403
+      raise Prescient::AuthenticationError, "Forbidden access for #{operation}"
+    when 429
+      raise Prescient::RateLimitError, "Rate limit exceeded for #{operation}"
+    when 500..599
+      raise Prescient::Error, "Anthropic server error during #{operation}: #{response.body}"
+    else
+      raise Prescient::Error,
+            "Anthropic request failed for #{operation}: HTTP #{response.code} - #{response.message}"
+    end
+  end
+end

data/lib/prescient/provider/huggingface.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+class Prescient::Provider::HuggingFace < Prescient::Base
+  include HTTParty
+
+  base_uri 'https://api-inference.huggingface.co'
+
+  EMBEDDING_DIMENSIONS = {
+    'sentence-transformers/all-MiniLM-L6-v2'     => 384,
+    'sentence-transformers/all-mpnet-base-v2'    => 768,
+    'sentence-transformers/all-roberta-large-v1' => 1024,
+  }.freeze
+
+  def initialize(**options)
+    super
+    self.class.default_timeout(@options[:timeout] || 60)
+  end
+
+  def generate_embedding(text, **_options)
+    handle_errors do
+      clean_text_input = clean_text(text)
+
+      response = self.class.post("/pipeline/feature-extraction/#{@options[:embedding_model]}",
+                                 headers: {
+                                   'Content-Type'  => 'application/json',
+                                   'Authorization' => "Bearer #{@options[:api_key]}",
+                                 },
+                                 body:    {
+                                   inputs:  clean_text_input,
+                                   options: {
+                                     wait_for_model: true,
+                                   },
+                                 }.to_json)
+
+      validate_response!(response, 'embedding generation')
+
+      # HuggingFace returns embeddings as nested arrays, get the first one
+      embedding_data = response.parsed_response
+      embedding_data = embedding_data.first if embedding_data.is_a?(Array) && embedding_data.first.is_a?(Array)
+
+      raise Prescient::InvalidResponseError, 'No embedding returned' unless embedding_data.is_a?(Array)
+
+      expected_dimensions = EMBEDDING_DIMENSIONS[@options[:embedding_model]] || 384
+      normalize_embedding(embedding_data, expected_dimensions)
+    end
+  end
+
+  def generate_response(prompt, context_items = [], **options)
+    handle_errors do
+      formatted_prompt = build_prompt(prompt, context_items)
+
+      response = self.class.post("/models/#{@options[:chat_model]}",
+                                 headers: {
+                                   'Content-Type'  => 'application/json',
+                                   'Authorization' => "Bearer #{@options[:api_key]}",
+                                 },
+                                 body:    {
+                                   inputs:     formatted_prompt,
+                                   parameters: {
+                                     max_new_tokens:   options[:max_tokens] || 2000,
+                                     temperature:      options[:temperature] || 0.7,
+                                     top_p:            options[:top_p] || 0.9,
+                                     return_full_text: false,
+                                   },
+                                   options:    {
+                                     wait_for_model: true,
+                                   },
+                                 }.to_json)
+
+      validate_response!(response, 'text generation')
+
+      # HuggingFace returns different formats depending on the model
+      generated_text = nil
+      parsed_response = response.parsed_response
+
+      if parsed_response.is_a?(Array) && parsed_response.first.is_a?(Hash)
+        generated_text = parsed_response.first['generated_text']
+      elsif parsed_response.is_a?(Hash)
+        generated_text = parsed_response['generated_text'] || parsed_response['text']
+      end
+
+      raise Prescient::InvalidResponseError, 'No response generated' unless generated_text
+
+      {
+        response:        generated_text.strip,
+        model:           @options[:chat_model],
+        provider:        'huggingface',
+        processing_time: nil,
+        metadata:        {},
+      }
+    end
+  end
+
+  def health_check
+    handle_errors do
+      # Test embedding model
+      embedding_response = self.class.post("/pipeline/feature-extraction/#{@options[:embedding_model]}",
+                                           headers: {
+                                             'Authorization' => "Bearer #{@options[:api_key]}",
+                                           },
+                                           body:    { inputs: 'test' }.to_json)
+
+      # Test chat model
+      chat_response = self.class.post("/models/#{@options[:chat_model]}",
+                                      headers: {
+                                        'Authorization' => "Bearer #{@options[:api_key]}",
+                                      },
+                                      body:    {
+                                        inputs:     'test',
+                                        parameters: { max_new_tokens: 5 },
+                                      }.to_json)
+
+      embedding_healthy = embedding_response.success?
+      chat_healthy = chat_response.success?
+
+      {
+        status:          embedding_healthy && chat_healthy ? 'healthy' : 'partial',
+        provider:        'huggingface',
+        embedding_model: {
+          name:      @options[:embedding_model],
+          available: embedding_healthy,
+        },
+        chat_model:      {
+          name:      @options[:chat_model],
+          available: chat_healthy,
+        },
+        ready:           embedding_healthy && chat_healthy,
+      }
+    end
+  rescue Prescient::ConnectionError => e
+    {
+      status:   'unavailable',
+      provider: 'huggingface',
+      error:    e.class.name,
+      message:  e.message,
+    }
+  end
+
+  def list_models
+    # HuggingFace doesn't provide a simple API to list all models
+    # Return the configured models
+    [
+      {
+        name:       @options[:embedding_model],
+        type:       'embedding',
+        dimensions: EMBEDDING_DIMENSIONS[@options[:embedding_model]],
+      },
+      {
+        name: @options[:chat_model],
+        type: 'text-generation',
+      },
+    ]
+  end
+
+  protected
+
+  def validate_configuration!
+    required_options = [:api_key, :embedding_model, :chat_model]
+    missing_options = required_options.select { |opt| @options[opt].nil? }
+
+    return unless missing_options.any?
+
+    raise Prescient::Error, "Missing required options: #{missing_options.join(', ')}"
+  end
+
+  private
+
+  def validate_response!(response, operation)
+    return if response.success?
+
+    case response.code
+    when 400
+      raise Prescient::Error, "Bad request for #{operation}: #{response.body}"
+    when 401
+      raise Prescient::AuthenticationError, "Authentication failed for #{operation}"
+    when 403
+      raise Prescient::AuthenticationError, "Forbidden access for #{operation}"
+    when 429
+      raise Prescient::RateLimitError, "Rate limit exceeded for #{operation}"
+    when 503
+      # HuggingFace model loading
+      error_body = begin
+        response.parsed_response
+      rescue StandardError
+        response.body
+      end
+      if error_body.is_a?(Hash) && error_body['error']&.include?('loading')
+        raise Prescient::Error, 'Model is loading, please try again later'
+      end
+
+      raise Prescient::Error, "HuggingFace service unavailable for #{operation}"
+
+    when 500..599
+      raise Prescient::Error, "HuggingFace server error during #{operation}: #{response.body}"
+    else
+      raise Prescient::Error,
+            "HuggingFace request failed for #{operation}: HTTP #{response.code} - #{response.message}"
+    end
+  end
+end

data/lib/prescient/provider/ollama.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+class Prescient::Provider::Ollama < Prescient::Base
+  include HTTParty
+
+  EMBEDDING_DIMENSIONS = 768 # nomic-embed-text dimensions
+
+  def initialize(**options)
+    super
+    self.class.base_uri(@options[:url])
+    self.class.default_timeout(@options[:timeout] || 60)
+  end
+
+  def generate_embedding(text, **_options)
+    handle_errors do
+      embedding = fetch_and_parse('post', '/api/embeddings',
+                                  root_key: 'embedding',
+                                  headers:  { 'Content-Type' => 'application/json' },
+                                  body:     {
+                                    model:  @options[:embedding_model],
+                                    prompt: clean_text(text),
+                                  }.to_json)
+
+      raise Prescient::InvalidResponseError, 'No embedding returned' unless embedding
+
+      normalize_embedding(embedding, EMBEDDING_DIMENSIONS)
+    end
+  end
+
+  def generate_response(prompt, context_items = [], **options)
+    handle_errors do
+      request_options = prepare_generate_response(prompt, context_items, **options)
+
+      # Make the request and store both text and full response
+      response = self.class.post('/api/generate', **request_options)
+      validate_response!(response, 'POST /api/generate')
+
+      generated_text = response.parsed_response['response']
+      raise Prescient::InvalidResponseError, 'No response generated' unless generated_text
+
+      {
+        response:        generated_text.strip,
+        model:           @options[:chat_model],
+        provider:        'ollama',
+        processing_time: response.parsed_response['total_duration']&./(1_000_000_000.0),
+        metadata:        {
+          eval_count:        response.parsed_response['eval_count'],
+          eval_duration:     response.parsed_response['eval_duration'],
+          prompt_eval_count: response.parsed_response['prompt_eval_count'],
+        },
+      }
+    end
+  end
+
+  def health_check
+    handle_errors do
+      models = available_models
+      embedding_available = models.any? { |m| m[:embedding] }
+      chat_available = models.any? { |m| m[:chat] }
+
+      {
+        status:           'healthy',
+        provider:         'ollama',
+        url:              @options[:url],
+        models_available: models.map { |m| m[:name] },
+        embedding_model:  {
+          name:      @options[:embedding_model],
+          available: embedding_available,
+        },
+        chat_model:       {
+          name:      @options[:chat_model],
+          available: chat_available,
+        },
+        ready:            embedding_available && chat_available,
+      }
+    end
+  rescue Prescient::Error => e
+    {
+      status:   'unavailable',
+      provider: 'ollama',
+      error:    e.class.name,
+      message:  e.message,
+      url:      @options[:url],
+    }
+  end
+
+  def available_models
+    return @_available_models if defined?(@_available_models)
+
+    handle_errors do
+      @_available_models = (fetch_and_parse('get', '/api/tags', root_key: 'models') || []).map { |model|
+        { embedding:  model['name'] == @options[:embedding_model],
+          chat:       model['name'] == @options[:chat_model],
+          name: model['name'], size: model['size'], modified_at: model['modified_at'], digest: model['digest'] }
+      }
+    end
+  end
+
+  def pull_model(model_name)
+    handle_errors do
+      fetch_and_parse('post', '/api/pull',
+                      headers: { 'Content-Type' => 'application/json' },
+                      body:    { name: model_name }.to_json,
+                      timeout: 300) # 5 minutes for model download
+      {
+        success: true,
+        model:   model_name,
+        message: "Model #{model_name} pulled successfully",
+      }
+    end
+  end
+
+  protected
+
+  def validate_configuration!
+    required_options = [:url, :embedding_model, :chat_model]
+    missing_options = required_options.select { |opt| @options[opt].nil? }
+
+    return unless missing_options.any?
+
+    raise Prescient::Error, "Missing required options: #{missing_options.join(', ')}"
+  end
+
+  private
+
+  def prepare_generate_response(prompt, context_items = [], **options)
+    formatted_prompt = build_prompt(prompt, context_items)
+    { root_key: 'response',
+      headers:  { 'Content-Type' => 'application/json' },
+      body:     {
+        model:   @options[:chat_model],
+        prompt:  formatted_prompt,
+        stream:  false,
+        options: {
+          num_predict: options[:max_tokens] || 2000,
+          temperature: options[:temperature] || 0.7,
+          top_p:       options[:top_p] || 0.9,
+        },
+      }.to_json }
+  end
+
+  def fetch_and_parse(htt_verb, endpoint, **options)
+    options = options.dup
+    root_key = options.delete(:root_key)
+
+    response = self.class.send(htt_verb, endpoint, **options)
+    validate_response!(response, "#{htt_verb.upcase} #{endpoint}")
+    return unless root_key
+
+    response.parsed_response[root_key]
+  end
+
+  def validate_response!(response, operation)
+    return if response.success?
+
+    case response.code
+    when 404
+      raise Prescient::ModelNotAvailableError, "Model not available for #{operation}"
+    when 429
+      raise Prescient::RateLimitError, "Rate limit exceeded for #{operation}"
+    when 401, 403
+      raise Prescient::AuthenticationError, "Authentication failed for #{operation}"
+    when 500..599
+      raise Prescient::Error, "Ollama server error during #{operation}: #{response.body}"
+    else
+      raise Prescient::Error,
+            "Ollama request failed for #{operation}: HTTP #{response.code} - #{response.message}"
+    end
+  end
+end

data/lib/prescient/provider/openai.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+class Prescient::Provider::OpenAI < Prescient::Base
+  include HTTParty
+
+  base_uri 'https://api.openai.com'
+
+  EMBEDDING_DIMENSIONS = {
+    'text-embedding-3-small' => 1536,
+    'text-embedding-3-large' => 3072,
+    'text-embedding-ada-002' => 1536,
+  }.freeze
+
+  def initialize(**options)
+    super
+    self.class.default_timeout(@options[:timeout] || 60)
+  end
+
+  def generate_embedding(text, **_options)
+    handle_errors do
+      clean_text_input = clean_text(text)
+
+      response = self.class.post('/v1/embeddings',
+                                 headers: {
+                                   'Content-Type'  => 'application/json',
+                                   'Authorization' => "Bearer #{@options[:api_key]}",
+                                 },
+                                 body:    {
+                                   model:           @options[:embedding_model],
+                                   input:           clean_text_input,
+                                   encoding_format: 'float',
+                                 }.to_json)
+
+      validate_response!(response, 'embedding generation')
+
+      embedding_data = response.parsed_response.dig('data', 0, 'embedding')
+      raise Prescient::InvalidResponseError, 'No embedding returned' unless embedding_data
+
+      expected_dimensions = EMBEDDING_DIMENSIONS[@options[:embedding_model]] || 1536
+      normalize_embedding(embedding_data, expected_dimensions)
+    end
+  end
+
+  def generate_response(prompt, context_items = [], **options)
+    handle_errors do
+      formatted_prompt = build_prompt(prompt, context_items)
+
+      response = self.class.post('/v1/chat/completions',
+                                 headers: {
+                                   'Content-Type'  => 'application/json',
+                                   'Authorization' => "Bearer #{@options[:api_key]}",
+                                 },
+                                 body:    {
+                                   model:       @options[:chat_model],
+                                   messages:    [
+                                     {
+                                       role:    'user',
+                                       content: formatted_prompt,
+                                     },
+                                   ],
+                                   max_tokens:  options[:max_tokens] || 2000,
+                                   temperature: options[:temperature] || 0.7,
+                                   top_p:       options[:top_p] || 0.9,
+                                 }.to_json)
+
+      validate_response!(response, 'text generation')
+
+      content = response.parsed_response.dig('choices', 0, 'message', 'content')
+      raise Prescient::InvalidResponseError, 'No response generated' unless content
+
+      {
+        response:        content.strip,
+        model:           @options[:chat_model],
+        provider:        'openai',
+        processing_time: nil,
+        metadata:        {
+          usage:         response.parsed_response['usage'],
+          finish_reason: response.parsed_response.dig('choices', 0, 'finish_reason'),
+        },
+      }
+    end
+  end
+
+  def health_check
+    handle_errors do
+      response = self.class.get('/v1/models',
+                                headers: {
+                                  'Authorization' => "Bearer #{@options[:api_key]}",
+                                })
+
+      if response.success?
+        models = response.parsed_response['data'] || []
+        embedding_available = models.any? { |m| m['id'] == @options[:embedding_model] }
+        chat_available = models.any? { |m| m['id'] == @options[:chat_model] }
+
+        {
+          status:           'healthy',
+          provider:         'openai',
+          models_available: models.map { |m| m['id'] },
+          embedding_model:  {
+            name:      @options[:embedding_model],
+            available: embedding_available,
+          },
+          chat_model:       {
+            name:      @options[:chat_model],
+            available: chat_available,
+          },
+          ready:            embedding_available && chat_available,
+        }
+      else
+        {
+          status:   'unhealthy',
+          provider: 'openai',
+          error:    "HTTP #{response.code}",
+          message:  response.message,
+        }
+      end
+    end
+  rescue Prescient::Error => e
+    {
+      status:   'unavailable',
+      provider: 'openai',
+      error:    e.class.name,
+      message:  e.message,
+    }
+  end
+
+  def list_models
+    handle_errors do
+      response = self.class.get('/v1/models',
+                                headers: {
+                                  'Authorization' => "Bearer #{@options[:api_key]}",
+                                })
+      validate_response!(response, 'model listing')
+
+      models = response.parsed_response['data'] || []
+      models.map do |model|
+        {
+          name:     model['id'],
+          created:  model['created'],
+          owned_by: model['owned_by'],
+        }
+      end
+    end
+  end
+
+  protected
+
+  def validate_configuration!
+    required_options = [:api_key, :embedding_model, :chat_model]
+    missing_options = required_options.select { |opt| @options[opt].nil? }
+
+    return unless missing_options.any?
+
+    raise Prescient::Error, "Missing required options: #{missing_options.join(', ')}"
+  end
+
+  private
+
+  def validate_response!(response, operation)
+    return if response.success?
+
+    case response.code
+    when 400
+      raise Prescient::Error, "Bad request for #{operation}: #{response.body}"
+    when 401
+      raise Prescient::AuthenticationError, "Authentication failed for #{operation}"
+    when 403
+      raise Prescient::AuthenticationError, "Forbidden access for #{operation}"
+    when 429
+      raise Prescient::RateLimitError, "Rate limit exceeded for #{operation}"
+    when 500..599
+      raise Prescient::Error, "OpenAI server error during #{operation}: #{response.body}"
+    else
+      raise Prescient::Error,
+            "OpenAI request failed for #{operation}: HTTP #{response.code} - #{response.message}"
+    end
+  end
+end