Module: Elasticsearch::API::Inference::Actions

Included in:: InferenceClient

Defined in:: lib/elasticsearch/api/namespace/inference.rb,
lib/elasticsearch/api/actions/inference/get.rb,
lib/elasticsearch/api/actions/inference/put.rb,
lib/elasticsearch/api/actions/inference/delete.rb,
lib/elasticsearch/api/actions/inference/rerank.rb,
lib/elasticsearch/api/actions/inference/update.rb,
lib/elasticsearch/api/actions/inference/inference.rb,
lib/elasticsearch/api/actions/inference/put_elser.rb,
lib/elasticsearch/api/actions/inference/completion.rb,
lib/elasticsearch/api/actions/inference/put_cohere.rb,
lib/elasticsearch/api/actions/inference/put_custom.rb,
lib/elasticsearch/api/actions/inference/put_jinaai.rb,
lib/elasticsearch/api/actions/inference/put_openai.rb,
lib/elasticsearch/api/actions/inference/put_mistral.rb,
lib/elasticsearch/api/actions/inference/put_watsonx.rb,
lib/elasticsearch/api/actions/inference/put_deepseek.rb,
lib/elasticsearch/api/actions/inference/put_voyageai.rb,
lib/elasticsearch/api/actions/inference/put_anthropic.rb,
lib/elasticsearch/api/actions/inference/text_embedding.rb,
lib/elasticsearch/api/actions/inference/put_azureopenai.rb,
lib/elasticsearch/api/actions/inference/put_alibabacloud.rb,
lib/elasticsearch/api/actions/inference/put_hugging_face.rb,
lib/elasticsearch/api/actions/inference/sparse_embedding.rb,
lib/elasticsearch/api/actions/inference/put_amazonbedrock.rb,
lib/elasticsearch/api/actions/inference/put_azureaistudio.rb,
lib/elasticsearch/api/actions/inference/put_elasticsearch.rb,
lib/elasticsearch/api/actions/inference/stream_completion.rb,
lib/elasticsearch/api/actions/inference/put_googleaistudio.rb,
lib/elasticsearch/api/actions/inference/put_googlevertexai.rb,
lib/elasticsearch/api/actions/inference/put_amazonsagemaker.rb,
lib/elasticsearch/api/actions/inference/chat_completion_unified.rb

Instance Method Summary collapse

#chat_completion_unified(arguments = {}) ⇒ Object

Perform chat completion inference.
#completion(arguments = {}) ⇒ Object

Perform completion inference on the service.
#delete(arguments = {}) ⇒ Object

Delete an inference endpoint.
#get(arguments = {}) ⇒ Object

Get an inference endpoint.
#inference(arguments = {}) ⇒ Object

Perform inference on the service.
#put(arguments = {}) ⇒ Object

Create an inference endpoint.
#put_alibabacloud(arguments = {}) ⇒ Object

Create an AlibabaCloud AI Search inference endpoint.
#put_amazonbedrock(arguments = {}) ⇒ Object

Create an Amazon Bedrock inference endpoint.
#put_amazonsagemaker(arguments = {}) ⇒ Object

Create an Amazon SageMaker inference endpoint.
#put_anthropic(arguments = {}) ⇒ Object

Create an Anthropic inference endpoint.
#put_azureaistudio(arguments = {}) ⇒ Object

Create an Azure AI studio inference endpoint.
#put_azureopenai(arguments = {}) ⇒ Object

Create an Azure OpenAI inference endpoint.
#put_cohere(arguments = {}) ⇒ Object

Create a Cohere inference endpoint.
#put_custom(arguments = {}) ⇒ Object

Create a custom inference endpoint.
#put_deepseek(arguments = {}) ⇒ Object

Create a DeepSeek inference endpoint.
#put_elasticsearch(arguments = {}) ⇒ Object

Create an Elasticsearch inference endpoint.
#put_elser(arguments = {}) ⇒ Object

Create an ELSER inference endpoint.
#put_googleaistudio(arguments = {}) ⇒ Object

Create an Google AI Studio inference endpoint.
#put_googlevertexai(arguments = {}) ⇒ Object

Create a Google Vertex AI inference endpoint.
#put_hugging_face(arguments = {}) ⇒ Object

Create a Hugging Face inference endpoint.
#put_jinaai(arguments = {}) ⇒ Object

Create an JinaAI inference endpoint.
#put_mistral(arguments = {}) ⇒ Object

Create a Mistral inference endpoint.
#put_openai(arguments = {}) ⇒ Object

Create an OpenAI inference endpoint.
#put_voyageai(arguments = {}) ⇒ Object

Create a VoyageAI inference endpoint.
#put_watsonx(arguments = {}) ⇒ Object

Create a Watsonx inference endpoint.
#rerank(arguments = {}) ⇒ Object

Perform reranking inference on the service.
#sparse_embedding(arguments = {}) ⇒ Object

Perform sparse embedding inference on the service.
#stream_completion(arguments = {}) ⇒ Object

Perform streaming inference.
#text_embedding(arguments = {}) ⇒ Object

Perform text embedding inference on the service.
#update(arguments = {}) ⇒ Object

Update an inference endpoint.

Instance Method Details

#chat_completion_unified(arguments = {}) ⇒ `Object`

Perform chat completion inference

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference payload (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/chat-completion-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/chat_completion_unified.rb', line 33

def chat_completion_unified(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.chat_completion_unified' }

  defined_params = [:inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'inference_id' missing" unless arguments[:inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _inference_id = arguments.delete(:inference_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_inference/chat_completion/#{Utils.__listify(_inference_id)}/_stream"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#completion(arguments = {}) ⇒ `Object`

Perform completion inference on the service

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference payload (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/post-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/completion.rb', line 33

def completion(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.completion' }

  defined_params = [:inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'inference_id' missing" unless arguments[:inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _inference_id = arguments.delete(:inference_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_inference/completion/#{Utils.__listify(_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete(arguments = {}) ⇒ `Object`

Delete an inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:task_type (String) —

The task type
:dry_run (Boolean) —

If true the endpoint will not be deleted and a list of ingest processors which reference this endpoint will be returned.
:force (Boolean) —

If true the endpoint will be forcefully stopped (regardless of whether or not it is referenced by any ingest processors or semantic text fields).
:headers (Hash) —

Custom HTTP headers

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/delete-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/delete.rb', line 35

def delete(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.delete' }

  defined_params = %i[inference_id task_type].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'inference_id' missing" unless arguments[:inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _inference_id = arguments.delete(:inference_id)

  _task_type = arguments.delete(:task_type)

  method = Elasticsearch::API::HTTP_DELETE
  path   = if _task_type && _inference_id
             "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_inference_id)}"
           else
             "_inference/#{Utils.__listify(_inference_id)}"
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get(arguments = {}) ⇒ `Object`

Get an inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:task_type (String) —

The task type
:headers (Hash) —

Custom HTTP headers

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/get-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/get.rb', line 33

def get(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.get' }

  defined_params = %i[inference_id task_type].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _inference_id = arguments.delete(:inference_id)

  _task_type = arguments.delete(:task_type)

  method = Elasticsearch::API::HTTP_GET
  path   = if _task_type && _inference_id
             "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_inference_id)}"
           elsif _inference_id
             "_inference/#{Utils.__listify(_inference_id)}"
           else
             '_inference'
           end
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#inference(arguments = {}) ⇒ `Object`

Perform inference on the service

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:task_type (String) —

The task type
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference payload (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/post-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/inference.rb', line 34

def inference(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.inference' }

  defined_params = %i[inference_id task_type].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'inference_id' missing" unless arguments[:inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _inference_id = arguments.delete(:inference_id)

  _task_type = arguments.delete(:task_type)

  method = Elasticsearch::API::HTTP_POST
  path   = if _task_type && _inference_id
             "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_inference_id)}"
           else
             "_inference/#{Utils.__listify(_inference_id)}"
           end
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put(arguments = {}) ⇒ `Object`

Create an inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:task_type (String) —

The task type
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/put-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/put.rb', line 34

def put(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put' }

  defined_params = %i[inference_id task_type].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'inference_id' missing" unless arguments[:inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _inference_id = arguments.delete(:inference_id)

  _task_type = arguments.delete(:task_type)

  method = Elasticsearch::API::HTTP_PUT
  path   = if _task_type && _inference_id
             "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_inference_id)}"
           else
             "_inference/#{Utils.__listify(_inference_id)}"
           end
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_alibabacloud(arguments = {}) ⇒ `Object`

Create an AlibabaCloud AI Search inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:alibabacloud_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-alibabacloud-ai-search.html

# File 'lib/elasticsearch/api/actions/inference/put_alibabacloud.rb', line 34

def put_alibabacloud(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_alibabacloud' }

  defined_params = %i[task_type alibabacloud_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:alibabacloud_inference_id]
    raise ArgumentError,
          "Required argument 'alibabacloud_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _alibabacloud_inference_id = arguments.delete(:alibabacloud_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_alibabacloud_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_amazonbedrock(arguments = {}) ⇒ `Object`

Create an Amazon Bedrock inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:amazonbedrock_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-amazon-bedrock.html

# File 'lib/elasticsearch/api/actions/inference/put_amazonbedrock.rb', line 34

def put_amazonbedrock(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_amazonbedrock' }

  defined_params = %i[task_type amazonbedrock_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:amazonbedrock_inference_id]
    raise ArgumentError,
          "Required argument 'amazonbedrock_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _amazonbedrock_inference_id = arguments.delete(:amazonbedrock_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_amazonbedrock_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_amazonsagemaker(arguments = {}) ⇒ `Object`

Create an Amazon SageMaker inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:amazonsagemaker_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-put-amazonsagemaker

# File 'lib/elasticsearch/api/actions/inference/put_amazonsagemaker.rb', line 34

def put_amazonsagemaker(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_amazonsagemaker' }

  defined_params = %i[task_type amazonsagemaker_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:amazonsagemaker_inference_id]
    raise ArgumentError,
          "Required argument 'amazonsagemaker_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _amazonsagemaker_inference_id = arguments.delete(:amazonsagemaker_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_amazonsagemaker_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_anthropic(arguments = {}) ⇒ `Object`

Create an Anthropic inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:anthropic_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-anthropic.html

# File 'lib/elasticsearch/api/actions/inference/put_anthropic.rb', line 34

def put_anthropic(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_anthropic' }

  defined_params = %i[task_type anthropic_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:anthropic_inference_id]
    raise ArgumentError,
          "Required argument 'anthropic_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _anthropic_inference_id = arguments.delete(:anthropic_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_anthropic_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_azureaistudio(arguments = {}) ⇒ `Object`

Create an Azure AI studio inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:azureaistudio_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-azure-ai-studio.html

# File 'lib/elasticsearch/api/actions/inference/put_azureaistudio.rb', line 34

def put_azureaistudio(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_azureaistudio' }

  defined_params = %i[task_type azureaistudio_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:azureaistudio_inference_id]
    raise ArgumentError,
          "Required argument 'azureaistudio_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _azureaistudio_inference_id = arguments.delete(:azureaistudio_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_azureaistudio_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_azureopenai(arguments = {}) ⇒ `Object`

Create an Azure OpenAI inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:azureopenai_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-azure-openai.html

# File 'lib/elasticsearch/api/actions/inference/put_azureopenai.rb', line 34

def put_azureopenai(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_azureopenai' }

  defined_params = %i[task_type azureopenai_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:azureopenai_inference_id]
    raise ArgumentError,
          "Required argument 'azureopenai_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _azureopenai_inference_id = arguments.delete(:azureopenai_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_azureopenai_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_cohere(arguments = {}) ⇒ `Object`

Create a Cohere inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:cohere_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-cohere.html

# File 'lib/elasticsearch/api/actions/inference/put_cohere.rb', line 34

def put_cohere(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_cohere' }

  defined_params = %i[task_type cohere_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]
  raise ArgumentError, "Required argument 'cohere_inference_id' missing" unless arguments[:cohere_inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _cohere_inference_id = arguments.delete(:cohere_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_cohere_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_custom(arguments = {}) ⇒ `Object`

Create a custom inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:custom_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-put-custom

# File 'lib/elasticsearch/api/actions/inference/put_custom.rb', line 34

def put_custom(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_custom' }

  defined_params = %i[task_type custom_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]
  raise ArgumentError, "Required argument 'custom_inference_id' missing" unless arguments[:custom_inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _custom_inference_id = arguments.delete(:custom_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_custom_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_deepseek(arguments = {}) ⇒ `Object`

Create a DeepSeek inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:deepseek_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-deepseek.html

# File 'lib/elasticsearch/api/actions/inference/put_deepseek.rb', line 34

def put_deepseek(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_deepseek' }

  defined_params = %i[task_type deepseek_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:deepseek_inference_id]
    raise ArgumentError,
          "Required argument 'deepseek_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _deepseek_inference_id = arguments.delete(:deepseek_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_deepseek_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_elasticsearch(arguments = {}) ⇒ `Object`

Create an Elasticsearch inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:elasticsearch_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-elasticsearch.html

# File 'lib/elasticsearch/api/actions/inference/put_elasticsearch.rb', line 34

def put_elasticsearch(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_elasticsearch' }

  defined_params = %i[task_type elasticsearch_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:elasticsearch_inference_id]
    raise ArgumentError,
          "Required argument 'elasticsearch_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _elasticsearch_inference_id = arguments.delete(:elasticsearch_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_elasticsearch_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_elser(arguments = {}) ⇒ `Object`

Create an ELSER inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:elser_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-elser.html

# File 'lib/elasticsearch/api/actions/inference/put_elser.rb', line 34

def put_elser(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_elser' }

  defined_params = %i[task_type elser_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]
  raise ArgumentError, "Required argument 'elser_inference_id' missing" unless arguments[:elser_inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _elser_inference_id = arguments.delete(:elser_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_elser_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_googleaistudio(arguments = {}) ⇒ `Object`

Create an Google AI Studio inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:googleaistudio_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-google-ai-studio.html

# File 'lib/elasticsearch/api/actions/inference/put_googleaistudio.rb', line 34

def put_googleaistudio(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_googleaistudio' }

  defined_params = %i[task_type googleaistudio_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:googleaistudio_inference_id]
    raise ArgumentError,
          "Required argument 'googleaistudio_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _googleaistudio_inference_id = arguments.delete(:googleaistudio_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_googleaistudio_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_googlevertexai(arguments = {}) ⇒ `Object`

Create a Google Vertex AI inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:googlevertexai_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-google-vertex-ai.html

# File 'lib/elasticsearch/api/actions/inference/put_googlevertexai.rb', line 34

def put_googlevertexai(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_googlevertexai' }

  defined_params = %i[task_type googlevertexai_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:googlevertexai_inference_id]
    raise ArgumentError,
          "Required argument 'googlevertexai_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _googlevertexai_inference_id = arguments.delete(:googlevertexai_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_googlevertexai_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_hugging_face(arguments = {}) ⇒ `Object`

Create a Hugging Face inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:huggingface_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-hugging-face.html

# File 'lib/elasticsearch/api/actions/inference/put_hugging_face.rb', line 34

def put_hugging_face(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_hugging_face' }

  defined_params = %i[task_type huggingface_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:huggingface_inference_id]
    raise ArgumentError,
          "Required argument 'huggingface_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _huggingface_inference_id = arguments.delete(:huggingface_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_huggingface_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_jinaai(arguments = {}) ⇒ `Object`

Create an JinaAI inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:jinaai_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-jinaai.html

# File 'lib/elasticsearch/api/actions/inference/put_jinaai.rb', line 34

def put_jinaai(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_jinaai' }

  defined_params = %i[task_type jinaai_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]
  raise ArgumentError, "Required argument 'jinaai_inference_id' missing" unless arguments[:jinaai_inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _jinaai_inference_id = arguments.delete(:jinaai_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_jinaai_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_mistral(arguments = {}) ⇒ `Object`

Create a Mistral inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:mistral_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-mistral.html

# File 'lib/elasticsearch/api/actions/inference/put_mistral.rb', line 34

def put_mistral(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_mistral' }

  defined_params = %i[task_type mistral_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:mistral_inference_id]
    raise ArgumentError,
          "Required argument 'mistral_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _mistral_inference_id = arguments.delete(:mistral_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_mistral_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_openai(arguments = {}) ⇒ `Object`

Create an OpenAI inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:openai_inference_id (String) —

The inference ID
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-openai.html

# File 'lib/elasticsearch/api/actions/inference/put_openai.rb', line 34

def put_openai(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_openai' }

  defined_params = %i[task_type openai_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]
  raise ArgumentError, "Required argument 'openai_inference_id' missing" unless arguments[:openai_inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _openai_inference_id = arguments.delete(:openai_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_openai_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_voyageai(arguments = {}) ⇒ `Object`

Create a VoyageAI inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:voyageai_inference_id (String) —

The inference ID
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-voyageai.html

# File 'lib/elasticsearch/api/actions/inference/put_voyageai.rb', line 34

def put_voyageai(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_voyageai' }

  defined_params = %i[task_type voyageai_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:voyageai_inference_id]
    raise ArgumentError,
          "Required argument 'voyageai_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _voyageai_inference_id = arguments.delete(:voyageai_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_voyageai_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_watsonx(arguments = {}) ⇒ `Object`

Create a Watsonx inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:task_type (String) —

The task type
:watsonx_inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-watsonx-ai.html

# File 'lib/elasticsearch/api/actions/inference/put_watsonx.rb', line 34

def put_watsonx(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.put_watsonx' }

  defined_params = %i[task_type watsonx_inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'task_type' missing" unless arguments[:task_type]

  unless arguments[:watsonx_inference_id]
    raise ArgumentError,
          "Required argument 'watsonx_inference_id' missing"
  end

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _task_type = arguments.delete(:task_type)

  _watsonx_inference_id = arguments.delete(:watsonx_inference_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_watsonx_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#rerank(arguments = {}) ⇒ `Object`

Perform reranking inference on the service

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference payload (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/post-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/rerank.rb', line 33

def rerank(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.rerank' }

  defined_params = [:inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'inference_id' missing" unless arguments[:inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _inference_id = arguments.delete(:inference_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_inference/rerank/#{Utils.__listify(_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#sparse_embedding(arguments = {}) ⇒ `Object`

Perform sparse embedding inference on the service

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference payload (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/post-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/sparse_embedding.rb', line 33

def sparse_embedding(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.sparse_embedding' }

  defined_params = [:inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'inference_id' missing" unless arguments[:inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _inference_id = arguments.delete(:inference_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_inference/sparse_embedding/#{Utils.__listify(_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#stream_completion(arguments = {}) ⇒ `Object`

Perform streaming inference

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference payload (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/stream-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/stream_completion.rb', line 33

def stream_completion(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.stream_completion' }

  defined_params = [:inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'inference_id' missing" unless arguments[:inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _inference_id = arguments.delete(:inference_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_inference/completion/#{Utils.__listify(_inference_id)}/_stream"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#text_embedding(arguments = {}) ⇒ `Object`

Perform text embedding inference on the service

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference payload (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/post-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/text_embedding.rb', line 33

def text_embedding(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.text_embedding' }

  defined_params = [:inference_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'inference_id' missing" unless arguments[:inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _inference_id = arguments.delete(:inference_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_inference/text_embedding/#{Utils.__listify(_inference_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#update(arguments = {}) ⇒ `Object`

Update an inference endpoint

Parameters:

arguments (Hash) (defaults to: {}) —

a customizable set of options

Options Hash (arguments):

:inference_id (String) —

The inference Id
:task_type (String) —

The task type
:headers (Hash) —

Custom HTTP headers
:body (Hash) —

The inference endpoint’s task and service settings (Required)

Raises:

(ArgumentError)

See Also:

https://www.elastic.co/guide/en/elasticsearch/reference/8.19/update-inference-api.html

# File 'lib/elasticsearch/api/actions/inference/update.rb', line 34

def update(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'inference.update' }

  defined_params = %i[inference_id task_type].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'inference_id' missing" unless arguments[:inference_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _inference_id = arguments.delete(:inference_id)

  _task_type = arguments.delete(:task_type)

  method = Elasticsearch::API::HTTP_PUT
  path   = if _task_type && _inference_id
             "_inference/#{Utils.__listify(_task_type)}/#{Utils.__listify(_inference_id)}/_update"
           else
             "_inference/#{Utils.__listify(_inference_id)}/_update"
           end
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

Module: Elasticsearch::API::Inference::Actions

Instance Method Summary collapse

Instance Method Details

#chat_completion_unified(arguments = {}) ⇒ Object

#completion(arguments = {}) ⇒ Object

#delete(arguments = {}) ⇒ Object

#get(arguments = {}) ⇒ Object

#inference(arguments = {}) ⇒ Object

#put(arguments = {}) ⇒ Object

#put_alibabacloud(arguments = {}) ⇒ Object

#put_amazonbedrock(arguments = {}) ⇒ Object

#put_amazonsagemaker(arguments = {}) ⇒ Object

#put_anthropic(arguments = {}) ⇒ Object

#put_azureaistudio(arguments = {}) ⇒ Object

#put_azureopenai(arguments = {}) ⇒ Object

#put_cohere(arguments = {}) ⇒ Object

#put_custom(arguments = {}) ⇒ Object

#put_deepseek(arguments = {}) ⇒ Object

#put_elasticsearch(arguments = {}) ⇒ Object

#put_elser(arguments = {}) ⇒ Object

#put_googleaistudio(arguments = {}) ⇒ Object

#put_googlevertexai(arguments = {}) ⇒ Object

#put_hugging_face(arguments = {}) ⇒ Object

#put_jinaai(arguments = {}) ⇒ Object

#put_mistral(arguments = {}) ⇒ Object

#put_openai(arguments = {}) ⇒ Object

#put_voyageai(arguments = {}) ⇒ Object

#put_watsonx(arguments = {}) ⇒ Object

#rerank(arguments = {}) ⇒ Object

#sparse_embedding(arguments = {}) ⇒ Object

#stream_completion(arguments = {}) ⇒ Object

#text_embedding(arguments = {}) ⇒ Object

#update(arguments = {}) ⇒ Object

#chat_completion_unified(arguments = {}) ⇒ `Object`

#completion(arguments = {}) ⇒ `Object`

#delete(arguments = {}) ⇒ `Object`

#get(arguments = {}) ⇒ `Object`

#inference(arguments = {}) ⇒ `Object`

#put(arguments = {}) ⇒ `Object`

#put_alibabacloud(arguments = {}) ⇒ `Object`

#put_amazonbedrock(arguments = {}) ⇒ `Object`

#put_amazonsagemaker(arguments = {}) ⇒ `Object`

#put_anthropic(arguments = {}) ⇒ `Object`

#put_azureaistudio(arguments = {}) ⇒ `Object`

#put_azureopenai(arguments = {}) ⇒ `Object`

#put_cohere(arguments = {}) ⇒ `Object`

#put_custom(arguments = {}) ⇒ `Object`

#put_deepseek(arguments = {}) ⇒ `Object`

#put_elasticsearch(arguments = {}) ⇒ `Object`

#put_elser(arguments = {}) ⇒ `Object`

#put_googleaistudio(arguments = {}) ⇒ `Object`

#put_googlevertexai(arguments = {}) ⇒ `Object`

#put_hugging_face(arguments = {}) ⇒ `Object`

#put_jinaai(arguments = {}) ⇒ `Object`

#put_mistral(arguments = {}) ⇒ `Object`

#put_openai(arguments = {}) ⇒ `Object`

#put_voyageai(arguments = {}) ⇒ `Object`

#put_watsonx(arguments = {}) ⇒ `Object`

#rerank(arguments = {}) ⇒ `Object`

#sparse_embedding(arguments = {}) ⇒ `Object`

#stream_completion(arguments = {}) ⇒ `Object`

#text_embedding(arguments = {}) ⇒ `Object`

#update(arguments = {}) ⇒ `Object`