Поиск с использованием правил запросов

Правила запросов позволяют настроить результаты поиска для запросов, которые соответствуют заданным метаданным критериям. Это позволяет получить больший контроль над результатами, например, гарантируя, что продвинутые документы, соответствующие определенным критериям, отображаются в верхней части списка результатов. Метаданные определяются в правиле запроса и сопоставляются с критериями запроса. Правила запросов используют метаданные для сопоставления с запросом. Метаданные предоставляются в качестве объекта в запросе на поиск и могут быть чем угодно, что помогает отличить запрос, например:

Правила запросов определяют ключ метаданных, который будет использоваться для сопоставления метаданных, предоставленных в средстве извлечения правил, с критериями, указанными в правиле.

Когда правило запроса соответствует метаданным правила в соответствии с его определенными критериями, действие правила запроса применяется к основному organic запросу.

Например, правило запроса можно определить для сопоставления введенной пользователем строки запроса pugs и страны us и для продвижения собак из приютов, если запрос правила соответствует обоим критериям.

Правила определяются с помощью API правил запросов и ищутся с помощью средства извлечения правил или запроса на основе правил.

При определении правила следует учитывать следующее:

Тип правила, которое необходимо применить. Мы поддерживаем следующие типы правил:

Критерии, по которым это правило будет соответствовать. Критерии определяются как type, metadata и values. Допустимые типы критериев:

Действия, которые необходимо выполнить, когда правило соответствует запросу:

Используйте ids при поиске по одному индексу и docs при поиске по нескольким индексам. ids и docs нельзя комбинировать в одном запросе.

Вы можете добавить правила запросов, используя вызов Создание или обновление набора правил запросов. Это добавляет набор правил, содержащий одно или несколько правил запросов, которые будут применяться к запросам, соответствующим заданным ими критериям.

Следующая команда создаст набор правил запросов под названием my-ruleset с двумя правилами запросов:

resp = client.query_rules.put_ruleset(
    ruleset_id="my-ruleset",
    rules=[
        {
            "rule_id": "rule1",
            "type": "pinned",
            "criteria": [
                {
                    "type": "fuzzy",
                    "metadata": "query_string",
                    "values": [
                        "puggles",
                        "pugs"
                    ]
                },
                {
                    "type": "exact",
                    "metadata": "user_country",
                    "values": [
                        "us"
                    ]
                }
            ],
            "actions": {
                "ids": [
                    "id1",
                    "id2"
                ]
            }
        },
        {
            "rule_id": "rule2",
            "type": "exclude",
            "criteria": [
                {
                    "type": "contains",
                    "metadata": "query_string",
                    "values": [
                        "beagles"
                    ]
                }
            ],
            "actions": {
                "docs": [
                    {
                        "_index": "my-index-000001",
                        "_id": "id3"
                    },
                    {
                        "_index": "my-index-000002",
                        "_id": "id4"
                    }
                ]
            }
        }
    ],
)
print(resp)

const response = await client.transport.request({
  method: "PUT",
  path: "/_query_rules/my-ruleset",
  body: {
    rules: [
      {
        rule_id: "rule1",
        type: "pinned",
        criteria: [
          {
            type: "fuzzy",
            metadata: "query_string",
            values: ["puggles", "pugs"],
          },
          {
            type: "exact",
            metadata: "user_country",
            values: ["us"],
          },
        ],
        actions: {
          ids: ["id1", "id2"],
        },
      },
      {
        rule_id: "rule2",
        type: "exclude",
        criteria: [
          {
            type: "contains",
            metadata: "query_string",
            values: ["beagles"],
          },
        ],
        actions: {
          docs: [
            {
              _index: "my-index-000001",
              _id: "id3",
            },
            {
              _index: "my-index-000002",
              _id: "id4",
            },
          ],
        },
      },
    ],
  },
});
console.log(response);

PUT /_query_rules/my-ruleset
{
  "rules": [
    {
      "rule_id": "rule1",
      "type": "pinned",
      "criteria": [
        {
          "type": "fuzzy",
          "metadata": "query_string",
          "values": [ "puggles", "pugs" ]
        },
        {
          "type": "exact",
          "metadata": "user_country",
          "values": [ "us" ]
        }
      ],
      "actions": {
        "ids": [
          "id1",
          "id2"
        ]
      }
    },
    {
      "rule_id": "rule2",
      "type": "exclude",
      "criteria": [
        {
          "type": "contains",
          "metadata": "query_string",
          "values": [ "beagles" ]
        }
      ],
      "actions": {
        "docs": [
          {
            "_index": "my-index-000001",
            "_id": "id3"
          },
          {
            "_index": "my-index-000002",
            "_id": "id4"
          }
        ]
      }
    }
  ]
}

Ответ API возвращает результаты created или updated в зависимости от того, был ли это новый или отредактированный набор правил.

{
  "result": "created"
}

Вы можете использовать вызов Получение набора правил запроса для получения созданного вами набора правил, вызов Список наборов правил запроса для получения сводки всех наборов правил запросов и вызов Удалить набор правил запроса для удаления набора правил запроса.

После определения одного или нескольких наборов правил запросов вы можете выполнить поиск с использованием этих наборов правил, используя средство извлечения правил или запрос на основе правил. Средства извлечения являются рекомендуемым способом использования запросов на основе правил, так как они будут работать «из коробки» с другими средствами извлечения повторной сортировки, такими как взаимное слияние рангов.

Наборы правил оцениваются в порядке следования, поэтому правила в первом указанном вами наборе правил будут применяться до любых последующих наборов правил.

Пример запроса для набора my-ruleset, определенного выше:

resp = client.search(
    index="my-index-000001",
    retriever={
        "rule": {
            "retriever": {
                "standard": {
                    "query": {
                        "query_string": {
                            "query": "puggles"
                        }
                    }
                }
            },
            "match_criteria": {
                "query_string": "puggles",
                "user_country": "us"
            },
            "ruleset_ids": [
                "my-ruleset"
            ]
        }
    },
)
print(resp)

const response = await client.search({
  index: "my-index-000001",
  retriever: {
    rule: {
      retriever: {
        standard: {
          query: {
            query_string: {
              query: "puggles",
            },
          },
        },
      },
      match_criteria: {
        query_string: "puggles",
        user_country: "us",
      },
      ruleset_ids: ["my-ruleset"],
    },
  },
});
console.log(response);

GET /my-index-000001/_search
{
  "retriever": {
    "rule": {
      "retriever": {
        "standard": {
          "query": {
            "query_string": {
              "query": "puggles"
            }
          }
        }
      },
      "match_criteria": {
        "query_string": "puggles",
        "user_country": "us"
      },
      "ruleset_ids": [ "my-ruleset" ]
    }
  }
}

Этот запрос на основе правил будет сопоставлен с rule1 в определенном наборе правил запроса и преобразует органический запрос в запрос закрепления с id1 и id2, закрепленными в качестве основных результатов. Все другие совпадения из органического запроса будут возвращены ниже закрепленных результатов.

Возможны несколько правил в наборе правил, которые соответствуют одному запросу на основе правил. В этом случае правила применяются в следующем порядке:

Вы можете указать средства повторной сортировки, такие как rrf или text_similarity_reranker в запросе на основе правила, чтобы применить правила запросов к уже отсортированным результатам. Вот пример:

resp = client.search(
    index="my-index-000001",
    retriever={
        "rule": {
            "match_criteria": {
                "query_string": "puggles",
                "user_country": "us"
            },
            "ruleset_ids": [
                "my-ruleset"
            ],
            "retriever": {
                "rrf": {
                    "retrievers": [
                        {
                            "standard": {
                                "query": {
                                    "query_string": {
                                        "query": "pugs"
                                    }
                                }
                            }
                        },
                        {
                            "standard": {
                                "query": {
                                    "query_string": {
                                        "query": "puggles"
                                    }
                                }
                            }
                        }
                    ]
                }
            }
        }
    },
)
print(resp)

const response = await client.search({
  index: "my-index-000001",
  retriever: {
    rule: {
      match_criteria: {
        query_string: "puggles",
        user_country: "us",
      },
      ruleset_ids: ["my-ruleset"],
      retriever: {
        rrf: {
          retrievers: [
            {
              standard: {
                query: {
                  query_string: {
                    query: "pugs",
                  },
                },
              },
            },
            {
              standard: {
                query: {
                  query_string: {
                    query: "puggles",
                  },
                },
              },
            },
          ],
        },
      },
    },
  },
});
console.log(response);

GET my-index-000001/_search
{
  "retriever": {
    "rule": {
      "match_criteria": {
        "query_string": "puggles",
        "user_country": "us"
      },
      "ruleset_ids": [
        "my-ruleset"
      ],
      "retriever": {
        "rrf": {
          "retrievers": [
            {
              "standard": {
                "query": {
                  "query_string": {
                    "query": "pugs"
                  }
                }
              }
            },
            {
              "standard": {
                "query": {
                  "query_string": {
                    "query": "puggles"
                  }
                }
              }
            }
          ]
        }
      }
    }
  }
}

Это позволит применить правила закрепления и исключения запросов поверх содержимого, которое было повторно отсортировано с помощью RRF.