Perform decision inference on the service

POST /_inference/decision/{inference_id}

Auth

Answer a set of named questions about an input, such as whether a customer is complaining, which team should handle a request, or how angry a customer is. The questions are defined in the task settings of the inference endpoint, and can be replaced for a single request through task_settings.

Note

Only the elastic service currently supports the decision task.

Required privileges

Cluster privileges monitor_inference

Path parameters

inference_id string required: The unique identifier for the inference endpoint.

Query parameters

timeout union oneOf · default: 30s: The amount of time to wait for the inference request to complete.; Values: -1 0

Request body

input union oneOf required

The input to answer the questions about. It can be specified as a string, or as an object. The object form additionally allows specifying images.

string example:

"input": "I was charged twice for my order and nobody answers my emails."

object example:

"input": {
  "type": "image",
  "format": "base64",
  "value": "data:image/jpeg;base64,..."
}

One of:

task_settings object

Task settings for the individual inference request. These settings override the task settings specified when creating the inference endpoint.

questions map string to oneOf: The questions to answer, keyed by question name. The answers in the response use the same names. The questions replace the ones of the inference endpoint as a whole. At least one question is required.

Response

application/json

decision object required

View as Markdown

Examples

Request Console 1 / 7 languages

Run POST _inference/decision/my-decision-endpoint to answer questions about a customer message

Console Kibana Dev Tools

POST _inference/decision/my-decision-endpoint
{
  "input": "I was charged twice for my order and nobody answers my emails.",
  "task_settings": {
    "questions": {
      "is_complaint": {
        "type": "predicate",
        "instructions": "Is the customer complaining?"
      },
      "team": {
        "type": "choice",
        "instructions": "Which team should handle this?",
        "choices": {
          "billing": "Charges, refunds, invoices",
          "shipping": "Deliveries and returns",
          "other": null
        }
      },
      "anger": {
        "type": "score",
        "instructions": "How angry is the customer?",
        "levels": ["calm", "annoyed", { "label": "furious", "description": "Threatens to leave" }]
      }
    }
  }
}

JavaScript Elasticsearch JavaScript Client

const response = await client.inference.decision({
  inference_id: "my-decision-endpoint",
  input: "I was charged twice for my order and nobody answers my emails.",
  task_settings: {
    questions: {
      is_complaint: {
        type: "predicate",
        instructions: "Is the customer complaining?",
      },
      team: {
        type: "choice",
        instructions: "Which team should handle this?",
        choices: {
          billing: "Charges, refunds, invoices",
          shipping: "Deliveries and returns",
          other: null,
        },
      },
      anger: {
        type: "score",
        instructions: "How angry is the customer?",
        levels: [
          "calm",
          "annoyed",
          {
            label: "furious",
            description: "Threatens to leave",
          },
        ],
      },
    },
  },
});

Python Elasticsearch Python Client

resp = client.inference.decision(
    inference_id="my-decision-endpoint",
    input="I was charged twice for my order and nobody answers my emails.",
    task_settings={
        "questions": {
            "is_complaint": {
                "type": "predicate",
                "instructions": "Is the customer complaining?"
            },
            "team": {
                "type": "choice",
                "instructions": "Which team should handle this?",
                "choices": {
                    "billing": "Charges, refunds, invoices",
                    "shipping": "Deliveries and returns",
                    "other": None
                }
            },
            "anger": {
                "type": "score",
                "instructions": "How angry is the customer?",
                "levels": [
                    "calm",
                    "annoyed",
                    {
                        "label": "furious",
                        "description": "Threatens to leave"
                    }
                ]
            }
        }
    },
)

curl Shell

curl -X POST "$ELASTICSEARCH_URL/_inference/decision/my-decision-endpoint" \
  -H "Authorization: ApiKey $ELASTIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "I was charged twice for my order and nobody answers my emails.",
    "task_settings": {
      "questions": {
        "is_complaint": {
          "type": "predicate",
          "instructions": "Is the customer complaining?"
        },
        "team": {
          "type": "choice",
          "instructions": "Which team should handle this?",
          "choices": {
            "billing": "Charges, refunds, invoices",
            "shipping": "Deliveries and returns",
            "other": null
          }
        },
        "anger": {
          "type": "score",
          "instructions": "How angry is the customer?",
          "levels": [
            "calm",
            "annoyed",
            {
              "label": "furious",
              "description": "Threatens to leave"
            }
          ]
        }
      }
    }
  }'

C# Elasticsearch .NET Client

var response = await client.Inference
    .DecisionAsync(inferenceId: "my-decision-endpoint", d1 => d1
        .Input("I was charged twice for my order and nobody answers my emails.")
        .TaskSettings(d2 => d2
            .Questions(d3 => d3
                .Predicate("is_complaint", d4 => d4
                    .Instructions("Is the customer complaining?")
                )
                .Choice("team", d4 => d4
                    .Choices(new Dictionary<string, string?>()
                    {
                        { "billing", "Charges, refunds, invoices" },
                        { "shipping", "Deliveries and returns" },
                        { "other", null }
                    })
                    .Instructions("Which team should handle this?")
                )
                .Score("anger", d4 => d4
                    .Instructions("How angry is the customer?")
                    .Levels(["calm", "annoyed", new DecisionScoreLevelObject()
                    {
                        Description = "Threatens to leave",
                        Label = "furious"
                    }])
                )
            )
        )
    );

PHP Elasticsearch PHP Client

$resp = $client->inference()->decision([
    "inference_id" => "my-decision-endpoint",
    "body" => [
        "input" => "I was charged twice for my order and nobody answers my emails.",
        "task_settings" => [
            "questions" => [
                "is_complaint" => [
                    "type" => "predicate",
                    "instructions" => "Is the customer complaining?",
                ],
                "team" => [
                    "type" => "choice",
                    "instructions" => "Which team should handle this?",
                    "choices" => [
                        "billing" => "Charges, refunds, invoices",
                        "shipping" => "Deliveries and returns",
                        "other" => null,
                    ],
                ],
                "anger" => [
                    "type" => "score",
                    "instructions" => "How angry is the customer?",
                    "levels" => array(
                        "calm",
                        "annoyed",
                        [
                            "label" => "furious",
                            "description" => "Threatens to leave",
                        ],
                    ),
                ],
            ],
        ],
    ],
]);

Ruby Elasticsearch Ruby Client

response = client.inference.decision(
  inference_id: "my-decision-endpoint",
  body: {
    "input": "I was charged twice for my order and nobody answers my emails.",
    "task_settings": {
      "questions": {
        "is_complaint": {
          "type": "predicate",
          "instructions": "Is the customer complaining?"
        },
        "team": {
          "type": "choice",
          "instructions": "Which team should handle this?",
          "choices": {
            "billing": "Charges, refunds, invoices",
            "shipping": "Deliveries and returns",
            "other": nil
          }
        },
        "anger": {
          "type": "score",
          "instructions": "How angry is the customer?",
          "levels": [
            "calm",
            "annoyed",
            {
              "label": "furious",
              "description": "Threatens to leave"
            }
          ]
        }
      }
    }
  }
)

Response

A response from POST _inference/decision/my-decision-endpoint, with an answer for each question.

{
  "decision": {
    "answers": {
      "is_complaint": {
        "type": "predicate",
        "probability": 0.94
      },
      "team": {
        "type": "choice",
        "choice": "billing",
        "probabilities": [
          { "value": "billing", "probability": 0.91 },
          { "value": "shipping", "probability": 0.04 },
          { "value": "other", "probability": 0.05 }
        ],
        "confidence": 0.89
      },
      "anger": {
        "type": "score",
        "score": 1.4,
        "probabilities": [
          { "value": 0, "label": "calm", "probability": 0.1 },
          { "value": 1, "label": "annoyed", "probability": 0.4 },
          { "value": 2, "label": "furious", "probability": 0.5 }
        ],
        "confidence": 0.62
      }
    }
  }
}