+ {__(
+ 'This setting controls which posts will be indexed with vector embedding data.',
+ 'elasticpress',
+ )}
+
+
{__('Modes', 'elasticpress')}
+
+
+ {__(
+ 'Automatic (Default): Posts are indexed based on taxonomy terms and post meta. Configure rules to include or exclude posts automatically.',
+ 'elasticpress',
+ )}
+
+
+ {__(
+ 'Manual: Editors will manually select which posts will qualify for vector embedding.',
+ 'elasticpress',
+ )}
+
+
+
+ {__(
+ 'Choose the mode that best fits your needs. If unsure, the automatic mode ensures consistent indexing based on predefined rules',
+ 'elasticpress',
+ )}
+
+ {__(
+ 'Include: If you specify terms or fields to include, only posts with those terms or fields will be included. All others will be excluded.',
+ 'elasticpress',
+ )}
+
+
+ {__(
+ 'Exclude: If you specify terms or fields to exclude, posts with those terms and fields will be left out, while all others will be included.',
+ 'elasticpress',
+ )}
+
+
+ {__(
+ 'Both Include & Exclude: If both are set, excluded terms and fields take priority — posts with those terms will always be left out, even if they match the included terms.',
+ 'elasticpress',
+ )}
+
+
+ {__(
+ 'If no rules are set, all posts are included by default.',
+ 'elasticpress',
+ )}
+
+
+
+
+
+ )}
+
+ )}
+ {embeddable && (
+
+
+
+ )}
+
+ );
+};
diff --git a/assets/js/embeddings/config.js b/assets/js/embeddings/config.js
new file mode 100644
index 0000000000..78187cf91d
--- /dev/null
+++ b/assets/js/embeddings/config.js
@@ -0,0 +1,11 @@
+/**
+ * Window dependencies.
+ */
+const {
+ settings: { postTypeConfig, chunkSize, chunkOverlap },
+ indexablePostTypes,
+ apiUrl,
+ embeddingsFiltered,
+} = window.epVectorEmbeddings;
+
+export { postTypeConfig, chunkSize, chunkOverlap, indexablePostTypes, apiUrl, embeddingsFiltered };
diff --git a/assets/js/embeddings/index.js b/assets/js/embeddings/index.js
new file mode 100644
index 0000000000..a09a726b4d
--- /dev/null
+++ b/assets/js/embeddings/index.js
@@ -0,0 +1,51 @@
+/**
+ * WordPress dependencies.
+ */
+import { createRoot, render, WPElement } from '@wordpress/element';
+import { __ } from '@wordpress/i18n';
+
+/**
+ * Internal dependencies.
+ */
+import { SettingsScreenProvider } from '../settings-screen';
+import { VectorEmbeddingsProvider } from './provider';
+import PostTypesList from './apps/settings';
+import { apiUrl, postTypeConfig, chunkSize, chunkOverlap, embeddingsFiltered } from './config';
+
+/**
+ * Styles.
+ */
+import './style.css';
+
+/**
+ * App component.
+ *
+ * @returns {WPElement}
+ */
+const App = () => {
+ return (
+
+
+
+
+
+ );
+};
+
+/**
+ * Root element.
+ */
+const el = document.getElementById('ep-vector-embeddings');
+
+/**
+ * Render.
+ */
+if (typeof createRoot === 'function') {
+ const root = createRoot(el);
+
+ root.render();
+} else {
+ render(, el);
+}
diff --git a/assets/js/embeddings/provider.js b/assets/js/embeddings/provider.js
new file mode 100644
index 0000000000..3faa78e5b3
--- /dev/null
+++ b/assets/js/embeddings/provider.js
@@ -0,0 +1,144 @@
+/**
+ * WordPress dependencies.
+ */
+import apiFetch from '@wordpress/api-fetch';
+import { createContext, WPElement, useContext, useState } from '@wordpress/element';
+
+/**
+ * Vector Embeddings context.
+ */
+const Context = createContext();
+
+/**
+ * Vector Embeddings app.
+ *
+ * @param {object} props Component props.
+ * @param {string} props.apiUrl Settings Update API URL.
+ * @param {Function} props.children Component children.
+ * @param {object} props.postTypeConfig Post Type Configurations.
+ * @param {object} props.indexablePostTypes Indexable Post Types.
+ * @param {number} props.chunkSize Chunk Size.
+ * @param {number} props.chunkOverlap Chunk Overlap.
+ * @param {boolean} props.embeddingsFiltered Whether embeddings are filtered.
+ *
+ * @returns {WPElement} Element.
+ */
+export const VectorEmbeddingsProvider = ({
+ apiUrl,
+ children,
+ postTypeConfig,
+ indexablePostTypes,
+ chunkSize,
+ chunkOverlap,
+ embeddingsFiltered,
+}) => {
+ const [isBusy, setIsBusy] = useState(false);
+ const [currentSettings, setCurrentSettings] = useState({
+ ...{ postTypeConfig, indexablePostTypes, chunkSize, chunkOverlap, embeddingsFiltered },
+ });
+
+ const setEmbeddingForPostType = (postType, taxonomy, key, value) => {
+ setCurrentSettings((prevConfig) => {
+ const postTypeConfig = prevConfig.postTypeConfig.find(
+ (config) => config.key === postType,
+ );
+
+ let updatedConfig;
+
+ // the following keys are nested within the taxonomy object.
+ const taxonomyKeys = ['termsInclude', 'termsExclude', 'enabled'];
+
+ // check if we're updating a nested taxonomy value
+ const updatingTaxonomy = taxonomy && taxonomyKeys.includes(key);
+
+ if (updatingTaxonomy) {
+ updatedConfig = {
+ ...postTypeConfig,
+ taxonomies: {
+ ...postTypeConfig.taxonomies,
+ [taxonomy]: {
+ ...postTypeConfig.taxonomies[taxonomy],
+ [key]: value,
+ },
+ },
+ };
+ } else {
+ // Update other postType-level properties
+ updatedConfig = {
+ ...postTypeConfig,
+ [key]: value,
+ };
+ }
+
+ return {
+ ...prevConfig,
+ postTypeConfig: prevConfig.postTypeConfig.map((item) =>
+ item.key === postType ? { ...item, ...updatedConfig } : item,
+ ),
+ };
+ });
+ };
+
+ const setChunkSize = (value) => {
+ setCurrentSettings((prevConfig) => ({
+ ...prevConfig,
+ chunkSize: value,
+ }));
+ };
+
+ const setChunkOverlap = (value) => {
+ setCurrentSettings((prevConfig) => ({
+ ...prevConfig,
+ chunkOverlap: value,
+ }));
+ };
+
+ /**
+ * Save settings.
+ *
+ * @returns {void}
+ */
+ const save = async () => {
+ setIsBusy(true);
+
+ try {
+ await apiFetch({
+ body: JSON.stringify(currentSettings),
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ method: 'POST',
+ url: apiUrl,
+ });
+ } catch (e) {
+ console.error(e); // eslint-disable-line no-console
+ throw e;
+ } finally {
+ setIsBusy(false);
+ }
+ };
+
+ // eslint-disable-next-line react/jsx-no-constructed-context-values
+ const contextValue = {
+ currentSettings,
+ isBusy,
+ save,
+ setEmbeddingForPostType,
+ setChunkOverlap,
+ setChunkSize,
+ };
+
+ /**
+ * Render.
+ */
+ return {children};
+};
+
+/**
+ * Use the API Search context.
+ *
+ * @returns {object} API Search Context.
+ */
+export const useVectorEmbeddingSettings = () => {
+ return useContext(Context);
+};
diff --git a/assets/js/embeddings/style.css b/assets/js/embeddings/style.css
new file mode 100644
index 0000000000..130675d6c8
--- /dev/null
+++ b/assets/js/embeddings/style.css
@@ -0,0 +1,36 @@
+/* add visual indicator to active tab */
+.ep-vector-embedding-settings__tabs__tab--active {
+ background: #f0f0f0;
+ font-weight: 500;
+}
+
+/* * the container for the entire tabs component */
+.ep-vector-embedding-settings__tabs {
+
+ @media screen and (max-width: 782px) {
+ flex-direction: column;
+ }
+ display: flex;
+}
+
+.ep-vector-embedding-settings__tabs .components-tab-panel__tabs button {
+ border-left: 5px solid transparent;
+}
+
+.ep-vector-embedding-settings__tabs > *:first-child {
+ padding-right: 30px;
+ width: 50%;
+}
+
+.ep-vector-embedding-settings__tabs > * {
+
+ @media screen and (max-width: 782px) {
+ width: 100%;
+ }
+ width: 800px;
+}
+
+.ep-vector-embedding-settings__post-types-list .components-notice {
+
+ margin-bottom: 20px;
+}
diff --git a/bin/setup-e2e-env.sh b/bin/setup-e2e-env.sh
index 126657e0e9..9fda3a5323 100755
--- a/bin/setup-e2e-env.sh
+++ b/bin/setup-e2e-env.sh
@@ -9,6 +9,8 @@ EP_CREDENTIALS=""
EP_INDEX_PREFIX=""
WP_VERSION=""
WC_VERSION=""
+CF_ACCESS_CLIENT_ID=""
+CF_ACCESS_CLIENT_SECRET=""
for opt in "$@"; do
case $opt in
@@ -30,6 +32,12 @@ for opt in "$@"; do
-wc=*|--wc-version=*)
WC_VERSION="${opt#*=}"
;;
+ --cf-access-client-id=*)
+ CF_ACCESS_CLIENT_ID="${opt#*=}"
+ ;;
+ --cf-access-client-secret=*)
+ CF_ACCESS_CLIENT_SECRET="${opt#*=}"
+ ;;
-h|--help|*)
DISPLAY_HELP=1
;;
@@ -95,6 +103,14 @@ if [ ! -z $EP_INDEX_PREFIX ]; then
./bin/wp-env-cli tests-wordpress "wp --allow-root config set EP_INDEX_PREFIX ${EP_INDEX_PREFIX}"
fi
+if [ ! -z $CF_ACCESS_CLIENT_ID ]; then
+ ./bin/wp-env-cli tests-wordpress "wp --allow-root config set CF_ACCESS_CLIENT_ID ${CF_ACCESS_CLIENT_ID}"
+fi
+
+if [ ! -z $CF_ACCESS_CLIENT_SECRET ]; then
+ ./bin/wp-env-cli tests-wordpress "wp --allow-root config set CF_ACCESS_CLIENT_SECRET ${CF_ACCESS_CLIENT_SECRET}"
+fi
+
if [ ! -z $ACF_PRO_LICENSE_KEY ]; then
./bin/wp-env-cli tests-wordpress "composer --working-dir=./wp-content config http-basic.connect.advancedcustomfields.com ${ACF_PRO_LICENSE_KEY} https://elasticpress.test"
MAX_RETRIES=3
diff --git a/elasticpress.php b/elasticpress.php
index a6bcdd86cc..1134ab5831 100644
--- a/elasticpress.php
+++ b/elasticpress.php
@@ -202,6 +202,23 @@ function register_indexable_posts() {
new Feature\Terms\Terms()
);
+ Features::factory()->register_feature(
+ new Feature\VectorEmbeddings\VectorEmbeddings()
+ );
+
+ Features::factory()->register_feature(
+ new Feature\SemanticSearch\SemanticSearch()
+ );
+
+ Features::factory()->register_feature(
+ new Feature\AISearchSummary()
+ );
+
+ /**
+ * Ensure ElasticPress takes precedence over add-ons that ship the same features.
+ */
+ FeaturePrecedence::factory();
+
/**
* Register search algorithms
*/
diff --git a/includes/classes/Feature/AISearchSummary.php b/includes/classes/Feature/AISearchSummary.php
new file mode 100644
index 0000000000..2b11222b48
--- /dev/null
+++ b/includes/classes/Feature/AISearchSummary.php
@@ -0,0 +1,650 @@
+ '',
+ 'api_url' => 'https://api.openai.com/v1/chat/completions',
+ 'chat_model' => 'gpt-5-mini',
+ 'number_of_posts' => 5,
+ 'prompt' => "You are an assistant in a website and you need to reply to a user search. If you do not know the answer, reply saying you could not find any results. Your answer should come formatted in HTML, but not as a full HTML page, just wrap everything in a div with the 'epio-response' class. Also, do not wrap it with ```html``` tags.
+
+The following JSON object contains the URL and the page content. You should use it as context:
+
+{posts}",
+ ];
+
+ /**
+ * Initialize feature setting its config
+ */
+ public function __construct() {
+ $this->slug = 'ai_search_summary';
+
+ $this->requires_feature = 'vector_embeddings';
+
+ parent::__construct();
+ }
+
+ /**
+ * Sets i18n strings.
+ */
+ public function set_i18n_strings(): void {
+ $this->title = esc_html__( 'AI Search Summary', 'elasticpress' );
+
+ $this->summary = '
' . __( 'Use the AI Search Summary block in your search results page to display an AI-generated summary of the search results.', 'elasticpress' ) . '
';
+ }
+
+ /**
+ * Setup all feature hooks
+ */
+ public function setup() {
+ add_action( 'init', [ $this, 'register_block' ] );
+
+ // Register REST routes.
+ add_action( 'rest_api_init', [ $this, 'setup_endpoint' ] );
+
+ add_filter( 'ep_query_logger_allowed_log_types', [ $this, 'add_ai_search_summary_to_allowed_log_types' ] );
+ }
+
+ /**
+ * Pre-handle feature activation
+ *
+ * @since 5.4.0
+ * @return void
+ */
+ public function pre_handle_feature_activation() {
+ $this->setup_failures_count();
+ }
+
+ /**
+ * Register block
+ */
+ public function register_block() {
+ /**
+ * Registering it here so translation works
+ *
+ * @see https://core.trac.wordpress.org/ticket/54797#comment:20
+ */
+ wp_register_script(
+ 'ep-ai-search-summary-block-script',
+ EP_URL . 'dist/blocks/ai-search-summary-block-script.js',
+ Utils\get_asset_info( 'ai-search-summary-block-script.js', 'dependencies' ),
+ Utils\get_asset_info( 'ai-search-summary-block-script.js', 'version' ),
+ true
+ );
+
+ wp_set_script_translations( 'ep-ai-search-summary-block-script', 'elasticpress' );
+
+ register_block_type_from_metadata(
+ EP_PATH . 'assets/js/blocks/ai-search-summary',
+ [
+ 'render_callback' => [ $this, 'render_block' ],
+ ]
+ );
+
+ wp_register_script(
+ 'ep-ai-search-summary-block-frontend-script',
+ EP_URL . 'dist/blocks/ai-search-summary-block-frontend-script.js',
+ Utils\get_asset_info( 'ai-search-summary-block-frontend-script', 'dependencies' ),
+ Utils\get_asset_info( 'ai-search-summary-block-frontend-script', 'version' ),
+ true
+ );
+
+ wp_localize_script(
+ 'ep-ai-search-summary-block-frontend-script',
+ 'epAISearchSummary',
+ [
+ 'searchQuery' => ! empty( $_GET['s'] ) ? sanitize_text_field( wp_unslash( $_GET['s'] ) ) : '', // phpcs:ignore WordPress.Security.NonceVerification.Recommended
+ 'restApiEndpoint' => 'elasticpress/v1/ai-search-summary',
+ ]
+ );
+
+ wp_enqueue_style(
+ 'ep-ai-search-summary-block-frontend-style',
+ EP_URL . 'dist/blocks/ai-search-summary-block-frontend-script.css',
+ [],
+ Utils\get_asset_info( 'ai-search-summary-block-frontend-script', 'version' )
+ );
+ }
+
+ /**
+ * Render block
+ *
+ * @param array $attributes Block attributes
+ * @return string
+ */
+ public function render_block( $attributes ) {
+ /**
+ * Filters whether the AI Search Summary block should be displayed.
+ *
+ * This filter allows developers to control the visibility of the AI Search Summary block.
+ * By default, the block is displayed if there is a non-empty search query.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_should_display_block
+ * @param {bool} $should_display Whether the AI Search Summary block should be displayed.
+ * @return {bool} Filtered value indicating whether the AI Search Summary block should be displayed.
+ */
+ $should_display = apply_filters( 'ep_ai_search_summary_should_display_block', ! empty( get_search_query() ), $attributes );
+
+ if ( ! $should_display ) {
+ return '';
+ }
+
+ $attributes = array_merge(
+ $attributes,
+ [ 'class' => 'wp-block-elasticpress-ai-search-summary' ],
+ );
+
+ /**
+ * Filters the HTML tag to be used as the block title.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_block_title_tag
+ * @param {string} $content The content to be filtered.
+ * @return {string} The filtered content.
+ */
+ $title_tag = apply_filters( 'ep_ai_search_summary_block_title_tag', 'h2', $attributes );
+
+ /**
+ * Filters the HTML tag to be used as the bottom text.
+ *
+ * This filter allows modification of the content before it is rendered.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_block_title_tag
+ * @param {string} $content The content to be filtered.
+ * @return {string} The filtered content.
+ */
+ $note_tag = apply_filters( 'ep_ai_search_summary_block_note_tag', 'p', $attributes );
+
+ // Render block
+ ob_start();
+
+ $wrapper_attributes = get_block_wrapper_attributes( $attributes );
+ ?>
+ >
+
+ < class="ep-ai-search-summary--title">>
+
+
+
+ < class="ep-ai-search-summary--note">>
+
+
+ register_routes();
+ }
+
+ /**
+ * Given the user search term/query, get related posts for context, and then get the AI response
+ *
+ * @param string $search_term Search term
+ * @param null|array $search_vectors Search term vectors
+ * @return string|\WP_Error
+ */
+ public function get_ai_response( $search_term, $search_vectors = null ) {
+ if ( ! $search_term ) {
+ return '';
+ }
+
+ $is_valid_search_term = $this->validate_search_term( $search_term );
+
+ /**
+ * Filter to determine if a search term is valid for the AI Search Summary feature.
+ *
+ * This filter allows customization of the validation logic for search terms
+ * used in the AI Search Summary feature. Developers can use this filter to override the
+ * default validation behavior.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_is_valid_search_term
+ * @param {bool} $is_valid_search_term Whether the search term is valid. Default is determined by internal logic.
+ * @param {string} $search_term The search term being validated.
+ * @return {bool} Whether the search term is valid.
+ */
+ if ( ! apply_filters( 'ep_ai_search_summary_is_valid_search_term', $is_valid_search_term, $search_term ) ) {
+ /**
+ * Filter the response for an invalid search term in the AI Search Summary feature.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_invalid_search_term_response
+ * @param {string} $response The response to return for an invalid search term. Default is an empty string.
+ * @param {string} $search_term The invalid search term that triggered the response.
+ * @return {\WP_Error} Response.
+ */
+ return apply_filters( 'ep_ai_search_summary_invalid_search_term_response', new \WP_Error( 'ep-ai-search-summary-invalid-search-term', '' ), $search_term );
+ }
+
+ /**
+ * Filters the AI response before it is returned.
+ *
+ * This filter allows developers to short-circuit the AI response generated by the AI Search Summary feature.
+ * Use this if you want to cache responses based on search terms.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_pre_response
+ * @param {null} $response The AI response. Default null.
+ * @param {string} $search_term The search term provided by the user.
+ * @param {array|null} $search_vectors The search term vectors, if available.
+ * @return {string|null} The filtered AI response.
+ */
+ $response = apply_filters( 'ep_ai_search_summary_pre_response', null, $search_term, $search_vectors );
+ if ( null !== $response ) {
+ return (string) $response;
+ }
+
+ $vector_embeddings = \ElasticPress\Features::factory()->get_registered_feature( 'vector_embeddings' );
+ $post_vectors = $vector_embeddings->get_indexables()['post'];
+
+ $results = $this->get_results( $search_term, $search_vectors );
+
+ $posts_representations = [];
+ foreach ( $results as $post_id ) {
+ $posts_representations[] = [
+ 'url' => get_permalink( $post_id ),
+ 'content' => implode( '', $post_vectors->get_post_chunks( $post_id ) ),
+ ];
+ }
+
+ $prompt = $this->get_prompt( $posts_representations );
+ $response = $this->ai_api_request( $prompt, $search_term );
+
+ /**
+ * Fires after receiving the response for a RAG (Retrieval-Augmented Generation) post request.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_post_response
+ * @param array|\WP_error $response The response from the RAG post request.
+ * @param string $search_term The search term.
+ * @param array $search_vectors The search vectors used for the RAG request.
+ * @param string $prompt The prompt.
+ */
+ do_action( 'ep_ai_search_summary_post_response', $response, $search_term, $search_vectors, $prompt );
+
+ return $response;
+ }
+
+ /**
+ * Get the posts to be used as context
+ *
+ * @param string $search_term Search term
+ * @param null|array $search_vectors Search term vectors
+ * @return array
+ */
+ protected function get_results( $search_term, $search_vectors = null ) {
+ $args = [
+ 's' => $search_term,
+ 'posts_per_page' => (int) $this->get_setting( 'number_of_posts' ),
+ 'fields' => 'ids',
+ ];
+
+ if ( $search_vectors ) {
+ $args['ep_vectors'] = array_map( 'floatval', $search_vectors );
+ }
+
+ /**
+ * Filters the query args for the AI search results.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_results_query_args
+ * @param {array} $args The query args.
+ * @return {array} The query args.
+ */
+ $args = apply_filters( 'ep_ai_search_results_query_args', $args );
+
+ $posts_query = new \WP_Query( $args );
+
+ return (array) $posts_query->posts;
+ }
+
+ /**
+ * Generate vectors for the search term
+ *
+ * @param string $search_term The search term
+ * @return array
+ */
+ public function get_search_term_vectors( $search_term ) {
+ $vector_embeddings = \ElasticPress\Features::factory()->get_registered_feature( 'vector_embeddings' );
+
+ return $vector_embeddings->generate_embedding( $search_term );
+ }
+
+ /**
+ * Generate the prompt for the AI model
+ *
+ * @param array $posts_representations The posts to be used as context
+ * @return string
+ */
+ public function get_prompt( $posts_representations ) {
+ $posts_representations_str = wp_json_encode( $posts_representations );
+
+ $default_prompt = $this->get_setting( 'prompt' );
+
+ /**
+ * Filters the AI system prompt before it goes to the request.
+ *
+ * This filter allows developers to change the AI prompt set in the plugin settings.
+ * Use this if you want to conditionally manipulate the prompt or implement more sophisticated logic.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_prompt
+ * @param {string} $prompt The prompt as set in the plugin settings.
+ * @return {string} The prompt for the AI model.
+ */
+ $prompt = apply_filters( 'ep_ai_search_summary_prompt', $default_prompt );
+
+ return str_replace( '{posts}', $posts_representations_str, $prompt );
+ }
+
+ /**
+ * Send a request to the AI API
+ *
+ * @param string $prompt Prompt for the AI model
+ * @param string $search_term Search query
+ * @return string|\WP_Error
+ */
+ public function ai_api_request( $prompt, $search_term ) {
+ $headers = [
+ 'Authorization' => 'Bearer ' . $this->get_setting( 'api_key' ),
+ 'Content-Type' => 'application/json',
+ ];
+
+ $body = [
+ 'model' => $this->get_setting( 'chat_model' ),
+ 'messages' => [
+ [
+ 'role' => 'system',
+ 'content' => $prompt,
+ ],
+ [
+ 'role' => 'system',
+ /**
+ * Filters the system prompt formatting for AI search summary.
+ *
+ * This filter allows customization of the system prompt that formats the AI response.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_system_prompt_formatting
+ * @param {string} $system_prompt The default system prompt formatting string.
+ * @param {string} $prompt The main system prompt being processed. By default, the one set in the plugin settings.
+ * @param {string} $search_term The search term used in the query.
+ * @return {string} The modified system prompt formatting string.
+ */
+ 'content' => apply_filters(
+ 'ep_ai_search_summary_system_prompt_formatting',
+ __( 'Send your response as a JSON object with the following keys: "response" (the asnwer, in HTML format) and "references" (an array of objects with the URLs you used to build the response, having "url" and "title" as attributes). Do not wrap the response in any other tags or limiters like "```json". Make sure the JSON object returned is properly escaped. Do not append the list of URLs used to the "response" value, as it will be displayed using the values in "references".', 'elasticpress' ),
+ $prompt,
+ $search_term
+ ),
+ ],
+ [
+ 'role' => 'user',
+ /**
+ * Filters the user prompt for the AI search summary.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_user_prompt
+ * @param {string} $search_term The search term to be used as the user prompt.
+ * @return {string} The filtered search term.
+ */
+ 'content' => apply_filters( 'ep_ai_search_summary_user_prompt', $search_term ),
+ ],
+ ],
+ ];
+
+ $url = $this->get_setting( 'api_url' );
+
+ /**
+ * Filter the options for the post request.
+ *
+ * @hook ep_ai_search_summary_request_options
+ * @since 5.4.0
+ *
+ * @param {array} $options The options for the request.
+ * @param {string} $url The URL for the request.
+ *
+ * @return {array} The options for the request.
+ */
+ $options = apply_filters(
+ 'ep_ai_search_summary_request_options',
+ [
+ 'headers' => $headers,
+ 'body' => wp_json_encode( $body ),
+ 'timeout' => 60, // phpcs:ignore WordPressVIPMinimum.Performance.RemoteRequestTimeout.timeout_timeout
+ ],
+ $url
+ );
+
+ $response = $this->send_request_and_log( $url, $options, 'AI Search Summary', 'ai_search_summary' );
+ if ( is_wp_error( $response ) ) {
+ return new \WP_Error( 'ep_ai_search_summary_request_failed', __( 'An error occurred. Try again later.', 'elasticpress' ) );
+ }
+
+ $code = wp_remote_retrieve_response_code( $response );
+ if ( 200 !== $code ) {
+ return new \WP_Error( 'ep_ai_search_summary_non_200_code_' . $code, __( 'An error occurred. Try again later.', 'elasticpress' ) );
+ }
+
+ $body = wp_remote_retrieve_body( $response );
+ $body = json_decode( $body, true );
+ return isset( $body['choices'], $body['choices'][0], $body['choices'][0]['message'], $body['choices'][0]['message']['content'] )
+ ? $body['choices'][0]['message']['content']
+ : new \WP_Error( 'ep_ai_search_summary_unformatted_response', __( 'An error occurred. Try again later.', 'elasticpress' ) );
+ }
+
+ /**
+ * Set the `settings_schema` attribute
+ */
+ public function set_settings_schema() {
+ $this->settings_schema = [
+ [
+ 'key' => 'api_key',
+ 'label' => __( 'OpenAI API Key', 'elasticpress' ),
+ 'help' => sprintf(
+ wp_kses(
+ /* translators: 1: OpenAI sign up URL, 2: OpenAI API keys URL */
+ __( 'Don\'t have an OpenAI account yet? Sign up for one in order to get your API key. If you already have an account, generate an API key.', 'elasticpress' ),
+ [
+ 'a' => [
+ 'href' => [],
+ 'title' => [],
+ ],
+ 'br' => [],
+ ]
+ ),
+ esc_url( 'https://platform.openai.com/signup' ),
+ esc_url( 'https://platform.openai.com/api-keys' )
+ ),
+ 'type' => 'text',
+ 'default' => $this->default_settings['api_key'],
+ ],
+ [
+ 'key' => 'api_url',
+ 'help' => __( 'OpenAI Chat Completion API Url', 'elasticpress' ),
+ 'label' => __( 'OpenAI Chat Completion API Url', 'elasticpress' ),
+ 'type' => 'text',
+ 'default' => $this->default_settings['api_url'],
+ ],
+ [
+ 'key' => 'chat_model',
+ 'help' => __( 'OpenAI Chat model', 'elasticpress' ),
+ 'label' => __( 'The name of the chat model to use', 'elasticpress' ),
+ 'type' => 'text',
+ 'default' => $this->default_settings['chat_model'],
+ ],
+ [
+ 'key' => 'number_of_posts',
+ 'label' => __( 'Number of posts', 'elasticpress' ),
+ 'help' => __( 'Number of posts to be used in the context building', 'elasticpress' ),
+ 'type' => 'number',
+ 'default' => $this->default_settings['number_of_posts'],
+ ],
+ [
+ 'key' => 'prompt',
+ 'label' => __( 'AI Prompt', 'elasticpress' ),
+ 'help' => __( 'The {posts} string will be replaced.', 'elasticpress' ),
+ 'type' => 'textarea',
+ 'default' => $this->default_settings['prompt'],
+ ],
+ ];
+ }
+
+ /**
+ * Tell user whether requirements for feature are met or not.
+ *
+ * @return FeatureRequirementsStatus Requirements object
+ */
+ public function requirements_status() {
+ $status = new \ElasticPress\FeatureRequirementsStatus( 1 );
+
+ // Vector support was added in Elasticsearch 7.0.
+ $es_version = \ElasticPress\Elasticsearch::factory()->get_elasticsearch_version();
+ if ( $es_version && version_compare( $es_version, '7.0', '<' ) ) {
+ $status->code = 2;
+ $status->message = esc_html__( 'You need to have Elasticsearch with version >7.0.', 'elasticpress' );
+ }
+
+ if ( $this->should_disable_after_failures() ) {
+ $status = $this->update_requirements_status( $status );
+ }
+
+ return $status;
+ }
+
+ /**
+ * Add AI Search Summary to the allowed log types.
+ *
+ * @param array $allowed_log_types The allowed log types.
+ * @return array The allowed log types.
+ */
+ public function add_ai_search_summary_to_allowed_log_types( $allowed_log_types ) {
+ $allowed_log_types['ai_search_summary'] = [ $this, 'is_query_error' ];
+
+ return $allowed_log_types;
+ }
+
+ /**
+ * Check if the request is an error.
+ *
+ * @param array $query The query.
+ * @return boolean Whether the request is an error.
+ */
+ public function is_query_error( $query ) {
+ if ( is_wp_error( $query['request'] ) ) {
+ return true;
+ }
+
+ $response_code = wp_remote_retrieve_response_code( $query['request'] );
+
+ return ( $response_code < 200 || $response_code > 299 );
+ }
+
+ /**
+ * Validates the provided search term.
+ *
+ * This function checks the validity of the given search term
+ * to ensure it meets the required criteria for processing.
+ *
+ * @param string $search_term The search term to validate.
+ * @return bool True if the search term is valid, false otherwise.
+ */
+ protected function validate_search_term( string $search_term ): bool {
+ $attack_patterns = [
+ // Instruction override patterns
+ '/ignore previous (instructions|rule|prompt)/i',
+ '/disregard (your|all|previous) (instructions|prompt)/i',
+ '/forget (your|all) (instructions|prompt)/i',
+
+ // Delimiter exploitation patterns
+ '/\<\/?system\>/i',
+ '/\<\/?admin\>/i',
+ '/\<\/?prompt\>/i',
+ '/\<\/?instructions?\>/i',
+
+ // Jailbreak attempts
+ '/DAN|Do Anything Now/i',
+ '/you are a helpful assistant that only responds/i',
+ '/you are in developer mode/i',
+
+ // Role play exploitation
+ '/pretend to be/i',
+ '/act as if/i',
+ '/you are now/i',
+
+ // Payload embedding attempts
+ '/\{\{[^}]+\}\}/i',
+ '/\[\[[^]]+\]\]/i',
+ '/```(system|exec|prompt)/i',
+
+ // Coding context breaking
+ '/`\/\/ignore previous code`/i',
+ '/\/\*\s*ignore previous\s*\*\//i',
+ ];
+
+ /**
+ * Filter the attack patterns used in the AI Search Summary feature.
+ *
+ * @since 5.4.0
+ * @hook ep_ai_search_summary_attack_patterns
+ * @param {array} $attack_patterns The array of attack patterns.
+ * @return {array} The modified array of attack patterns.
+ */
+ $attack_patterns = apply_filters( 'ep_ai_search_summary_attack_patterns', $attack_patterns );
+
+ foreach ( $attack_patterns as $pattern ) {
+ if ( preg_match( $pattern, $search_term ) ) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/includes/classes/Feature/SemanticSearch/SearchAlgorithm/Hybrid.php b/includes/classes/Feature/SemanticSearch/SearchAlgorithm/Hybrid.php
new file mode 100644
index 0000000000..40b2d506f2
--- /dev/null
+++ b/includes/classes/Feature/SemanticSearch/SearchAlgorithm/Hybrid.php
@@ -0,0 +1,82 @@
+is_search() ) {
+ return $formatted_args;
+ }
+
+ $query_embedding = $this->get_search_term_vector( $args, $query->query_vars['s'] );
+ if ( empty( $query_embedding ) ) {
+ return $formatted_args;
+ }
+
+ $semantic_search_feature = \ElasticPress\Features::factory()->get_registered_feature( 'semantic_search' );
+
+ return [
+ 'from' => $formatted_args['from'],
+ 'size' => $formatted_args['size'],
+ 'post_filter' => $formatted_args['post_filter'],
+ 'min_score' => $semantic_search_feature->get_min_score(),
+ 'query' => $formatted_args['query'],
+ 'knn' => [
+ 'field' => 'chunks.vector',
+ 'query_vector' => $query_embedding,
+ 'num_candidates' => 200,
+ 'k' => (int) $formatted_args['size'],
+ ],
+ ];
+ }
+}
diff --git a/includes/classes/Feature/SemanticSearch/SearchAlgorithm/Knn.php b/includes/classes/Feature/SemanticSearch/SearchAlgorithm/Knn.php
new file mode 100644
index 0000000000..9a9bff0a92
--- /dev/null
+++ b/includes/classes/Feature/SemanticSearch/SearchAlgorithm/Knn.php
@@ -0,0 +1,81 @@
+is_search() ) {
+ return $formatted_args;
+ }
+
+ $query_embedding = $this->get_search_term_vector( $args, $query->query_vars['s'] );
+ if ( empty( $query_embedding ) ) {
+ return $formatted_args;
+ }
+
+ $semantic_search_feature = \ElasticPress\Features::factory()->get_registered_feature( 'semantic_search' );
+
+ return [
+ 'from' => $formatted_args['from'],
+ 'size' => $formatted_args['size'],
+ 'post_filter' => $formatted_args['post_filter'],
+ 'min_score' => $semantic_search_feature->get_min_score(),
+ 'knn' => [
+ 'field' => 'chunks.vector',
+ 'query_vector' => $query_embedding,
+ 'num_candidates' => 200,
+ 'k' => (int) $formatted_args['size'],
+ ],
+ ];
+ }
+}
diff --git a/includes/classes/Feature/SemanticSearch/SearchAlgorithm/KnnCosine.php b/includes/classes/Feature/SemanticSearch/SearchAlgorithm/KnnCosine.php
new file mode 100644
index 0000000000..8508d30649
--- /dev/null
+++ b/includes/classes/Feature/SemanticSearch/SearchAlgorithm/KnnCosine.php
@@ -0,0 +1,99 @@
+is_search() ) {
+ return $formatted_args;
+ }
+
+ $query_embedding = $this->get_search_term_vector( $args, $query->query_vars['s'] );
+ if ( empty( $query_embedding ) ) {
+ return $formatted_args;
+ }
+
+ $semantic_search_feature = \ElasticPress\Features::factory()->get_registered_feature( 'semantic_search' );
+
+ return [
+ 'from' => $formatted_args['from'],
+ 'size' => $formatted_args['size'],
+ 'post_filter' => $formatted_args['post_filter'],
+ 'min_score' => $semantic_search_feature->get_min_score(),
+ 'query' => [
+ 'bool' => [
+ 'must' => [
+ [
+ 'nested' => [
+ 'path' => 'chunks',
+ 'query' => [
+ 'script_score' => [
+ 'query' => [
+ 'match_all' => (object) [],
+ ],
+ 'script' => [
+ 'source' => 'cosineSimilarity(params.query_vector, "chunks.vector") + 1.0',
+ 'params' => [
+ 'query_vector' => $query_embedding,
+ ],
+ ],
+ ],
+ ],
+ ],
+ ],
+ ],
+ ],
+ ],
+ ];
+ }
+}
diff --git a/includes/classes/Feature/SemanticSearch/SearchAlgorithm/SearchAlgorithm.php b/includes/classes/Feature/SemanticSearch/SearchAlgorithm/SearchAlgorithm.php
new file mode 100644
index 0000000000..ebe0b771dd
--- /dev/null
+++ b/includes/classes/Feature/SemanticSearch/SearchAlgorithm/SearchAlgorithm.php
@@ -0,0 +1,77 @@
+get_raw_query( $indexable_slug, $search_term, $search_fields, $query_vars );
+ }
+
+ /**
+ * Given a search term, gets its vector embedding
+ *
+ * @param array $query_args The query args
+ * @param string $search_term The search term
+ * @return array
+ */
+ public function get_search_term_vector( $query_args, $search_term = '' ) {
+ if ( isset( $query_args['ep_vectors'] ) ) {
+ return $query_args['ep_vectors'];
+ }
+
+ if ( ! empty( $query_args['ep_facet_adding_agg_filters'] ) ) {
+ return '{{ep_search_term_vectors_placeholder}}';
+ }
+
+ $vector_embeddings = \ElasticPress\Features::factory()->get_registered_feature( 'vector_embeddings' );
+ if ( 'epio' === $vector_embeddings->get_setting( 'ep_embeddings_generator' ) ) {
+ return '{{ep_search_term_vectors_placeholder}}';
+ }
+
+ $autosuggest = \ElasticPress\Features::factory()->get_registered_feature( 'autosuggest' );
+ if ( $autosuggest->is_active() ) {
+ $autosuggest_placeholder = apply_filters( 'ep_autosuggest_query_placeholder', 'ep_autosuggest_placeholder' );
+ if ( $autosuggest_placeholder === $search_term ) {
+ return '{{ep_search_term_vectors_placeholder}}';
+ }
+ }
+
+ $search_term_vector = $vector_embeddings->generate_embedding( $search_term );
+ if ( is_wp_error( $search_term_vector ) ) {
+ return [];
+ }
+
+ return array_map( 'floatval', $search_term_vector );
+ }
+}
diff --git a/includes/classes/Feature/SemanticSearch/SemanticSearch.php b/includes/classes/Feature/SemanticSearch/SemanticSearch.php
new file mode 100644
index 0000000000..1fe327c02f
--- /dev/null
+++ b/includes/classes/Feature/SemanticSearch/SemanticSearch.php
@@ -0,0 +1,449 @@
+ 'hybrid_knn',
+ 'search_min_score' => 0.7,
+ ];
+
+ /**
+ * The algorithms supported by the feature.
+ *
+ * @var array $algorithms.
+ */
+ protected $algorithms = [];
+
+ /**
+ * Initialize feature setting it's config
+ */
+ public function __construct() {
+ $this->slug = 'semantic_search';
+
+ $this->requires_feature = 'vector_embeddings';
+
+ /*
+ * The default algorithm (Hybrid) is not available on Elasticsearch < 8,
+ * so an unavailable value can end up stored when the defaults are merged
+ * in on save. Hooked here rather than in setup() so it also applies
+ * while the feature is inactive: the settings dashboard round-trips
+ * stored values on save, and the REST schema rejects algorithms that
+ * are not available.
+ */
+ add_filter( 'ep_sanitize_feature_settings', [ $this, 'fix_search_algorithm_version' ] );
+
+ parent::__construct();
+ }
+
+ /**
+ * Fix the search algorithm version if it is not available.
+ *
+ * Replaces a `search_algorithm_version` being saved with the default when
+ * it is not one of the algorithms available on the current Elasticsearch
+ * version.
+ *
+ * @since 5.4.0
+ * @param array $settings The settings to be saved.
+ * @return array The sanitized settings.
+ */
+ public function fix_search_algorithm_version( $settings ) {
+ if ( empty( $settings[ $this->slug ]['search_algorithm_version'] ) ) {
+ return $settings;
+ }
+
+ // Without a known Elasticsearch version the available algorithms can't be determined.
+ if ( ! \ElasticPress\Elasticsearch::factory()->get_elasticsearch_version() ) {
+ return $settings;
+ }
+
+ if ( ! in_array( $settings[ $this->slug ]['search_algorithm_version'], $this->get_algorithm_slugs(), true ) ) {
+ $settings[ $this->slug ]['search_algorithm_version'] = $this->get_default_algorithm();
+ }
+
+ return $settings;
+ }
+
+ /**
+ * Tell user whether requirements for feature are met or not.
+ *
+ * @return FeatureRequirementsStatus Requirements object
+ */
+ public function requirements_status() {
+ $status = new FeatureRequirementsStatus( 1 );
+
+ $es_version = \ElasticPress\Elasticsearch::factory()->get_elasticsearch_version();
+
+ // Vector support was added in Elasticsearch 7.0.
+ if ( $es_version && version_compare( $es_version, '7.0', '<' ) ) {
+ $status->code = 2;
+ $status->message = esc_html__( 'You need to have Elasticsearch with version >7.0.', 'elasticpress' );
+ }
+
+ if ( $es_version && version_compare( $es_version, '7.0', '>' ) && version_compare( $es_version, '8.0', '<' ) ) {
+ $status->code = 1;
+ $status->message = esc_html__( 'With Elasticsearch version 7, only the "kNN Cosine" algorithm is available.', 'elasticpress' );
+ }
+
+ return $status;
+ }
+
+ /**
+ * Sets i18n strings.
+ *
+ * @return void
+ * @since 5.4.0
+ */
+ public function set_i18n_strings(): void {
+ $this->title = esc_html__( 'Semantic Search', 'elasticpress' );
+
+ $this->summary = __( 'Enable kNN (k-Nearest Neighbors) search and choose which vector search algorithm to use. Requires the Vector Embeddings feature to be enabled.', 'elasticpress' );
+ }
+
+ /**
+ * Pre-handle feature activation
+ *
+ * @since 5.4.0
+ * @return void
+ */
+ public function pre_handle_feature_activation() {
+ $vector_embeddings = \ElasticPress\Features::factory()->get_registered_feature( 'vector_embeddings' );
+ if ( ! $vector_embeddings->is_active() ) {
+ return;
+ }
+
+ if ( ! $this->is_active() ) {
+ return;
+ }
+
+ $this->register_algorithms();
+
+ add_filter( 'ep_feature_requirements_status_message', [ $this, 'filter_search_algorithm_requirements_status_message' ], 10, 2 );
+ add_filter( 'ep_feature_requirements_status_message', [ $this, 'filter_temp_disabled_features_status_message' ], 10, 2 );
+ add_filter( 'ep_feature_requirements_status_code', [ $this, 'maybe_disable_autosuggest_and_instant_results' ], 10, 2 );
+ }
+
+ /**
+ * Connects the Module with WordPress using Hooks and/or Filters.
+ *
+ * @return void
+ */
+ public function setup() {
+ // In older versions of ElasticPress, the algorithms were not set in the pre_handle_feature_activation method.
+ $this->register_algorithms();
+
+ add_filter( 'ep_post_search_algorithm', [ $this, 'get_search_algorithm_version' ] );
+
+ $vector_embeddings = \ElasticPress\Features::factory()->get_registered_feature( 'vector_embeddings' );
+ $is_epio = 'epio' === $vector_embeddings->get_setting( 'ep_embeddings_generator' );
+ $search_algorithm = \ElasticPress\Indexables::factory()->get( 'post' )->get_search_algorithm( '', [], [] );
+
+ if ( $is_epio && in_array( $search_algorithm, $this->algorithms, true ) ) {
+ add_filter( 'ep_query_request_args', [ $this, 'add_vector_embeddings_header' ], 10, 6 );
+ add_action( 'wp_enqueue_scripts', [ $this, 'add_autosuggest_http_header' ] );
+ }
+ }
+
+ /**
+ * Maybe set the algorithms
+ *
+ * This only instantiates the algorithm objects for the feature. Registering
+ * them globally is left to `register_algorithms()`, which must only happen
+ * while the feature is active.
+ *
+ * @return void
+ */
+ protected function maybe_set_algorithms() {
+ if ( ! empty( $this->algorithms ) ) {
+ return;
+ }
+
+ $this->algorithms = [
+ new SearchAlgorithm\KnnCosine(),
+ ];
+
+ $es_version = \ElasticPress\Elasticsearch::factory()->get_elasticsearch_version();
+
+ if ( version_compare( $es_version, '8.0', '>=' ) ) {
+ $this->algorithms[] = new SearchAlgorithm\Hybrid();
+ $this->algorithms[] = new SearchAlgorithm\Knn();
+ }
+ }
+
+ /**
+ * Register the feature's algorithms with the global registry.
+ *
+ * @since 5.4.0
+ * @return void
+ */
+ protected function register_algorithms() {
+ $this->maybe_set_algorithms();
+
+ foreach ( $this->algorithms as $algorithm ) {
+ \ElasticPress\SearchAlgorithms::factory()->register( $algorithm );
+ }
+ }
+
+ /**
+ * Set the `settings_schema` attribute
+ */
+ public function set_settings_schema() {
+ $this->maybe_set_algorithms();
+
+ $algorithm_options = [];
+ foreach ( $this->algorithms as $algorithm ) {
+ $algorithm_options[] = [
+ 'label' => $algorithm->get_name() . ' ' . $algorithm->get_description() . '',
+ 'value' => $algorithm->get_slug(),
+ ];
+ }
+
+ $this->settings_schema = [
+ [
+ 'default' => $this->get_default_algorithm(),
+ 'key' => 'search_algorithm_version',
+ 'label' => __( 'Search algorithm', 'elasticpress' ),
+ 'options' => $algorithm_options,
+ 'type' => 'radio',
+ ],
+ [
+ 'key' => 'search_min_score',
+ 'label' => __( 'Minimum score', 'elasticpress' ),
+ 'help' => __( 'The minimum score to be used by kNN searches. Input a number between 0 and 1.', 'elasticpress' ),
+ 'type' => 'number',
+ 'default' => $this->default_settings['search_min_score'],
+ ],
+ ];
+ }
+
+ /**
+ * Get the slugs of the search algorithms supported by the feature.
+ *
+ * @since 5.4.0
+ * @return string[] Array of algorithm slugs.
+ */
+ protected function get_algorithm_slugs() {
+ $this->maybe_set_algorithms();
+
+ return array_map(
+ function ( $algorithm ) {
+ return $algorithm->get_slug();
+ },
+ $this->algorithms
+ );
+ }
+
+ /**
+ * Get the default search algorithm slug.
+ *
+ * Falls back to the first available algorithm when the preferred default
+ * (Hybrid) is not supported by the current Elasticsearch version.
+ *
+ * @since 5.4.0
+ * @return string The default algorithm slug.
+ */
+ protected function get_default_algorithm() {
+ $available = $this->get_algorithm_slugs();
+ $preferred = $this->default_settings['search_algorithm_version'];
+
+ if ( in_array( $preferred, $available, true ) ) {
+ return $preferred;
+ }
+
+ return ! empty( $available ) ? reset( $available ) : $preferred;
+ }
+
+ /**
+ * Get the currently selected search algorithm slug.
+ *
+ * Hooked to `ep_post_search_algorithm` while the feature is active. If the
+ * stored selection is not a currently available algorithm, the default is
+ * used instead.
+ *
+ * @since 5.4.0
+ * @param string $search_algorithm The fallback search algorithm slug.
+ * @return string The search algorithm slug.
+ */
+ public function get_search_algorithm_version( $search_algorithm ) {
+ $version = $this->get_setting( 'search_algorithm_version' );
+
+ if ( ! in_array( $version, $this->get_algorithm_slugs(), true ) ) {
+ $version = $this->get_default_algorithm();
+ }
+
+ return $version;
+ }
+
+ /**
+ * Get the min_score setting.
+ *
+ * @return float
+ */
+ public function get_min_score() {
+ /**
+ * Filters the minimum score for KNN (k-Nearest Neighbors) search.
+ *
+ * @since 5.4.0
+ * @param {float} $min_score The minimum score for KNN search. Default is retrieved from the 'search_min_score' setting.
+ * @return {float} The minimum score for KNN search.
+ */
+ return (float) apply_filters( 'ep_semantic_search_min_score', $this->get_setting( 'search_min_score' ) );
+ }
+
+ /**
+ * Add the vector embeddings header to the request arguments.
+ *
+ * @param array $request_args The request arguments.
+ * @param string $path The path of the request.
+ * @param string $index The index of the request.
+ * @param string $type The type of the request.
+ * @param array $query The query of the request.
+ * @param array $query_args The query arguments of the request.
+ * @return array The request arguments.
+ */
+ public function add_vector_embeddings_header( $request_args, $path, $index, $type, $query, $query_args ) {
+ $request_args['headers']['EP-Vector-Embeddings-Search-Term'] = $query_args['s'] ? rawurlencode( $query_args['s'] ) : '';
+
+ return $request_args;
+ }
+
+ /**
+ * Add the vector embeddings header to the request arguments.
+ *
+ * @return void
+ */
+ public function add_autosuggest_http_header() {
+ wp_add_inline_script(
+ 'elasticpress-autosuggest',
+ "const epAutosuggestFetchOptions = (fetchOptions) => {
+ fetchOptions.headers['EP-Vector-Embeddings-Search-Term'] = fetchOptions.headers['EP-Search-Term'];
+ return fetchOptions;
+ };
+ wp.hooks.addFilter('ep.Autosuggest.fetchOptions', 'myTheme/epAutosuggestFetchOptions', epAutosuggestFetchOptions);",
+ 'before'
+ );
+ }
+
+ /**
+ * Filter the Semantic Search feature requirements status message
+ *
+ * Warns that the selected kNN algorithm is incompatible with Autosuggest
+ * and Instant Results when either of those features is active.
+ *
+ * @since 5.4.0
+ * @param string|array $message The message to display
+ * @param FeatureRequirementsStatus $status The feature requirements status object
+ * @return string|array The message to display
+ */
+ public function filter_search_algorithm_requirements_status_message( $message, $status ) {
+ $feature = $status->get_feature();
+ if ( ! $feature || 'semantic_search' !== $feature->slug ) {
+ return $message;
+ }
+
+ $autosuggest = \ElasticPress\Features::factory()->get_registered_feature( 'autosuggest' );
+ $autosuggest_active = $autosuggest && $autosuggest->is_active();
+ $instant_results = \ElasticPress\Features::factory()->get_registered_feature( 'instant-results' );
+ $instant_results_active = $instant_results && $instant_results->is_active();
+ if ( ! $autosuggest_active && ! $instant_results_active ) {
+ return $message;
+ }
+
+ $algorithms_list = array_map(
+ function ( $algorithm ) {
+ return '' . $algorithm->get_name() . '';
+ },
+ $this->algorithms
+ );
+
+ $message = (array) $message;
+ $message[] = wp_sprintf(
+ esc_html__( 'Please note that Semantic Search algorithms (%l) are not compatible with the Autosuggest and Instant Results features. Autosuggest and Instant Results will be disabled while those algorithms are selected.', 'elasticpress' ),
+ $algorithms_list
+ );
+ return $message;
+ }
+
+ /**
+ * Maybe disable Autosuggest and Instant Results features
+ *
+ * @since 5.4.0
+ * @param int $code The code of the feature requirements status
+ * @param FeatureRequirementsStatus $status The feature requirements status object
+ * @return int The new code of the feature requirements status
+ */
+ public function maybe_disable_autosuggest_and_instant_results( $code, $status ) {
+ if ( ! $this->should_disable_autosuggest_and_instant_results( $status->get_feature() ) ) {
+ return $code;
+ }
+
+ return defined( '\ElasticPress\FeatureRequirementsStatus::TEMPORARILY_DISABLED' )
+ ? FeatureRequirementsStatus::TEMPORARILY_DISABLED
+ : 2;
+ }
+
+ /**
+ * Filter the temporarily disabled features status message
+ *
+ * @since 5.4.0
+ * @param string|array $message The message to display
+ * @param FeatureRequirementsStatus $status The feature requirements status object
+ * @return string|array The message to display
+ */
+ public function filter_temp_disabled_features_status_message( $message, $status ) {
+ if ( ! $this->should_disable_autosuggest_and_instant_results( $status->get_feature() ) ) {
+ return $message;
+ }
+
+ $message = (array) $message;
+ $message[] = esc_html__( 'This feature is temporarily disabled because it is incompatible with Semantic Search algorithms.', 'elasticpress' );
+ return $message;
+ }
+
+ /**
+ * Check if Autosuggest and Instant Results features should be temporarily disabled
+ *
+ * @since 5.4.0
+ * @param Feature $feature The feature object
+ * @return bool True if the feature should be disabled, false otherwise
+ */
+ protected function should_disable_autosuggest_and_instant_results( $feature ) {
+ if ( ! $feature || ! isset( $feature->slug ) || ! in_array( $feature->slug, [ 'autosuggest', 'instant-results' ], true ) ) {
+ return false;
+ }
+
+ if ( ! $this->is_active() ) {
+ return false;
+ }
+
+ return in_array( $this->get_search_algorithm_version( '' ), $this->get_algorithm_slugs(), true );
+ }
+}
diff --git a/includes/classes/Feature/VectorEmbeddings/Indexable.php b/includes/classes/Feature/VectorEmbeddings/Indexable.php
new file mode 100644
index 0000000000..8045540c5c
--- /dev/null
+++ b/includes/classes/Feature/VectorEmbeddings/Indexable.php
@@ -0,0 +1,185 @@
+feature = $feature;
+ }
+
+ /**
+ * Add a vector field to the Elasticsearch mapping.
+ *
+ * @param array $mapping Current mapping.
+ * @param bool $quantization Whether to use quantization for the vector field. Default false.
+ * @return array
+ */
+ public function add_vector_mapping_field( array $mapping, bool $quantization = true ): array {
+ $es_version = Elasticsearch::factory()->get_elasticsearch_version();
+
+ if ( ! isset( $mapping['mappings'], $mapping['mappings']['properties'] ) ) {
+ _doing_it_wrong(
+ __METHOD__,
+ esc_html__( 'The mapping is not valid.', 'elasticpress' ),
+ 'ElasticPress 5.4.0'
+ );
+ return $mapping;
+ }
+
+ // Don't add the field if it already exists.
+ if ( isset( $mapping['mappings']['properties']['chunks'], $mapping['mappings']['properties']['ep_embeddings_control'] ) ) {
+ return $mapping;
+ }
+
+ // Add the default vector field mapping.
+ $mapping['mappings']['properties'] = array_merge(
+ $mapping['mappings']['properties'],
+ [
+ 'ep_embeddings_control' => [
+ 'properties' => [
+ 'is_processing' => [
+ 'type' => 'boolean',
+ ],
+ 'errors' => [
+ 'type' => 'text',
+ ],
+ 'text_chunks' => [
+ 'type' => 'text',
+ ],
+ ],
+ ],
+ 'chunks' => [
+ 'type' => 'nested',
+ 'properties' => [
+ 'vector' => [
+ 'type' => 'dense_vector',
+ 'dims' => $this->feature->get_dimensions(),
+ ],
+ ],
+ ],
+ ]
+ );
+
+ // Add extra vector fields for newer versions of Elasticsearch.
+ if ( version_compare( $es_version, '8.0', '>=' ) ) {
+ // The index (true or false, default true) and similarity (l2_norm, dot_product or cosine) fields
+ // were added in 8.0. The similarity field must be set if index is true.
+ $mapping['mappings']['properties']['chunks']['properties']['vector'] = array_merge(
+ $mapping['mappings']['properties']['chunks']['properties']['vector'],
+ [
+ 'index' => true,
+ 'similarity' => 'cosine',
+ ]
+ );
+
+ // The element_type field was added in 8.6. This can be either float (default) or byte.
+ if ( version_compare( $es_version, '8.6', '>=' ) ) {
+ $mapping['mappings']['properties']['chunks']['properties']['vector']['element_type'] = 'float';
+ }
+
+ // The int8_hnsw type was added in 8.12.
+ if ( $quantization && version_compare( $es_version, '8.12', '>=' ) ) {
+ // This is supposed to result in better performance but slightly less accurate results.
+ // See https://www.elastic.co/guide/en/elasticsearch/reference/8.13/knn-search.html#knn-search-quantized-example.
+ // Can test with this on and off and compare results to see what works best.
+ $mapping['mappings']['properties']['chunks']['properties']['vector']['index_options']['type'] = 'int8_hnsw';
+ }
+ }
+
+ return $mapping;
+ }
+
+ /**
+ * Add the embedding data to the post vector sync args.
+ *
+ * @param array $args The current sync args (an Elasticsearch document)
+ * @param array $embeddings The embeddings to add to the sync args
+ * @return array
+ */
+ public function add_chunks_field_value( array $args, array $embeddings ): array {
+ // If we still don't have embeddings, return early.
+ if ( empty( $embeddings ) ) {
+ return $args;
+ }
+
+ // Add the embeddings data to the sync args.
+ $args['chunks'] = [];
+
+ foreach ( $embeddings as $embedding ) {
+ $args['chunks'][] = [
+ 'vector' => array_map( 'floatval', $embedding ),
+ ];
+ }
+
+ return $args;
+ }
+
+ /**
+ * Determine the way to send the text chunks to the Elasticsearch server.
+ *
+ * Depending on the size of the text chunks, it can either be sent using the index action args
+ * (the JSON object where we determine the index to be used, etc.) or as a regular field in the Elasticsearch.
+ * To avoid overhead, we prefer to send it as an index action arg, but sometimes it is just too big for it.
+ *
+ * @param array $text_chunks The text chunks
+ * @return string The method. Can be 'index_action_args' or 'es_doc_field'.
+ */
+ protected function get_text_chunks_sending_method( $text_chunks ) {
+ $post_chunks_size = mb_strlen( wp_json_encode( $text_chunks ), '8bit' );
+
+ /**
+ * Filter to determine the threshold size for the text chunks to be sent as an index action arg.
+ *
+ * @hook ep_embeddings_sending_method_limit
+ * @since 5.4.0
+ *
+ * @param {int} $size The size limit in bytes. Defaults to 200kb.
+ * @return {int} The new $size value.
+ */
+ $size_limit = apply_filters( 'ep_embeddings_sending_method_limit', 200 * KB_IN_BYTES );
+
+ $method = $post_chunks_size < $size_limit ? 'index_action_args' : 'es_doc_field';
+
+ /**
+ * Filter to determine the method to be used to send the text chunks.
+ *
+ * Unless you are implementing a custom solution, return should be either 'index_action_args' or 'es_doc_field'.
+ *
+ * @hook ep_embeddings_sending_method
+ * @since 5.4.0
+ *
+ * @param {string} $method The method to be used.
+ * @param {int} $text_chunks The text chunks being analyzed.
+ * @param {int} $post_chunks_size The determined size of the text chunks.
+ * @param {int} $size_limit The size limit in bytes. Defaults to 200kb.
+ * @return {string} The new $method value.
+ */
+ return apply_filters( 'ep_embeddings_sending_method', $method, $text_chunks, $post_chunks_size, $size_limit );
+ }
+}
diff --git a/includes/classes/Feature/VectorEmbeddings/Indexables/Post/Post.php b/includes/classes/Feature/VectorEmbeddings/Indexables/Post/Post.php
new file mode 100644
index 0000000000..1d52e343bb
--- /dev/null
+++ b/includes/classes/Feature/VectorEmbeddings/Indexables/Post/Post.php
@@ -0,0 +1,548 @@
+settings_page = new Settings();
+ $this->settings_page->setup();
+
+ // Alter post and term mapping to store our vector embeddings
+ add_filter( 'ep_post_mapping', [ $this, 'add_post_vector_field_mapping' ] );
+
+ $generator = $this->feature->get_setting( 'ep_embeddings_generator' );
+ if ( 'external' === $generator ) {
+ return;
+ }
+
+ add_action( 'init', [ $this, 'register_meta' ], 20 );
+ add_action( 'enqueue_block_editor_assets', [ $this, 'enqueue_block_editor_assets' ] );
+
+ add_action( 'post_submitbox_misc_actions', [ $this, 'output_embedding_exclude_setting' ] );
+ add_action( 'attachment_submitbox_misc_actions', [ $this, 'output_embedding_exclude_setting' ], 15 );
+
+ add_action( 'edit_post', [ $this, 'save_embedding_exclude_meta' ] );
+ add_action( 'edit_attachment', [ $this, 'save_embedding_exclude_meta' ] );
+
+ if ( 'epio' === $generator ) {
+ add_filter( 'ep_bulk_index_action_args', [ $this, 'maybe_add_chunks_to_bulk_index_action_args' ], 10, 2 );
+ add_filter( 'ep_post_sync_args_post_prepare_meta', [ $this, 'maybe_add_chunks_to_text_chunks_fields' ], 10, 2 );
+ add_filter( 'ep_doc_status', [ $this, 'maybe_set_doc_status' ], 10, 3 );
+ add_filter( 'ep_embeddings_dimensions', [ $this, 'set_epio_dimensions' ] );
+ } else {
+ add_filter( 'ep_post_sync_args_post_prepare_meta', [ $this, 'add_vector_field_to_post_sync' ], 10, 2 );
+ }
+ }
+
+ /**
+ * Add our vector field mapping to the Elasticsearch post index.
+ *
+ * @param array $mapping Current mapping.
+ * @return array
+ */
+ public function add_post_vector_field_mapping( array $mapping ): array {
+ return $this->add_vector_mapping_field( $mapping );
+ }
+
+ /**
+ * Registers post meta for exclude from vector embeddings.
+ *
+ * @return void
+ */
+ public function register_meta() {
+ register_post_meta(
+ '',
+ 'ep_embedding_exclude',
+ [
+ 'show_in_rest' => true,
+ 'single' => true,
+ 'type' => 'boolean',
+ ]
+ );
+
+ register_post_meta(
+ '',
+ 'ep_embedding_include',
+ [
+ 'show_in_rest' => true,
+ 'single' => true,
+ 'type' => 'boolean',
+ ]
+ );
+ }
+
+ /**
+ * Enqueue block editor assets.
+ */
+ public function enqueue_block_editor_assets() {
+ global $post;
+
+ if ( ! $post instanceof \WP_Post ) {
+ return;
+ }
+
+ if ( ! $post->post_type || ! post_type_supports( $post->post_type, 'custom-fields' ) ) {
+ return;
+ }
+
+ if ( ! $this->settings_page->is_post_type_embeddable( $post->post_type ) ) {
+ return;
+ }
+
+ wp_enqueue_script(
+ 'ep-embeddings-editor',
+ EP_URL . 'dist/js/embeddings-editor-script.js',
+ Utils\get_asset_info( 'embeddings-editor-script', 'dependencies' ),
+ Utils\get_asset_info( 'embeddings-editor-script', 'version' ),
+ true
+ );
+
+ wp_localize_script(
+ 'ep-embeddings-editor',
+ 'epEmbeddingsEditor',
+ [
+ 'postTypeConfig' => $this->settings_page->get_post_type_config( $post->post_type ),
+ ]
+ );
+
+ wp_set_script_translations( 'ep-embeddings-editor', 'elasticpress' );
+ }
+
+ /**
+ * Outputs the checkbox to exclude a post from embedding.
+ *
+ * @param WP_Post $post Post object.
+ */
+ public function output_embedding_exclude_setting( $post ) {
+ $indexable = \ElasticPress\Indexables::factory()->get( 'post' );
+ if ( ! $indexable->sync_manager->is_post_indexable( $post->ID ) ) {
+ return;
+ }
+
+ ?>
+
+ >
+
+
+ post_type ) : ?>
+
+
+
+
+
+
+
+ should_add_vector_field_to_post( $post['ID'] ) ) {
+ return $args;
+ }
+
+ $post_chunks = $this->get_post_chunks( $post['ID'] );
+ if ( 'index_action_args' === $this->get_text_chunks_sending_method( $post_chunks ) ) {
+ $args['epio-content-chunks'] = $post_chunks;
+ }
+
+ return $args;
+ }
+
+ /**
+ * Add text chunks to their field in the post sync args.
+ *
+ * @param array $args Current sync args.
+ * @param int $post_id Post ID being synced.
+ * @return array
+ */
+ public function maybe_add_chunks_to_text_chunks_fields( array $args, int $post_id ) {
+ if ( ! $this->should_add_vector_field_to_post( $post_id ) ) {
+ return $args;
+ }
+
+ $args['ep_embeddings_control'] = [
+ 'is_processing' => true,
+ 'errors' => [],
+ 'text_chunks' => [],
+ ];
+
+ $post_chunks = $this->get_post_chunks( $post_id );
+ if ( 'es_doc_field' === $this->get_text_chunks_sending_method( $post_chunks ) ) {
+ $args['ep_embeddings_control']['text_chunks'] = $post_chunks;
+ }
+
+ return $args;
+ }
+
+ /**
+ * Change the doc status indicator depending on the Vector Embeddings process status
+ *
+ * @param array $status The status array containing status, message and explanation
+ * @param int $post_id The post ID being checked
+ * @param array|false $es_doc The Elasticsearch document
+ * @return array
+ */
+ public function maybe_set_doc_status( array $status, int $post_id, $es_doc ): array {
+ if ( ! isset( $es_doc['ep_embeddings_control'] ) ) {
+ return $status;
+ }
+
+ if ( ! empty( $es_doc['ep_embeddings_control']['is_processing'] ) ) {
+ $status = [
+ 'status' => 'warning',
+ 'message' => esc_html__( 'Processing vector embeddings', 'elasticpress' ),
+ 'explanation' => esc_html__( 'Vector embeddings are still being processed.', 'elasticpress' ),
+ ];
+ }
+
+ if ( ! empty( $es_doc['ep_embeddings_control']['errors'] ) ) {
+ $errors_list = '