Skip to content

armgit / solr

Public Imported from GitHub
0

Apache Solr open-source search software

SOLR-18187: Document enrichment with LLMs (#4259)

Nicolò Rinaldi0e018d0f5078
diff --git a/changelog/unreleased/SOLR-18187-llm-document-enrichment.yml b/changelog/unreleased/SOLR-18187-llm-document-enrichment.yml
new file mode 100644
index 00000000000..dc856698514
--- /dev/null
+++ b/changelog/unreleased/SOLR-18187-llm-document-enrichment.yml
@@ -0,0 +1,7 @@
+title: Add DocumentEnrichmentUpdateProcessorFactory for LLM-based document enrichment at index time
+type: added # added, changed, fixed, deprecated, removed, dependency_update, security, other
+authors:
+- name: Nicolò Rinaldi, Anna Ruggero, Alessandro Benedetti
+links:
+ - name: SOLR-18187
+ url: https://issues.apache.org/jira/browse/SOLR-18187
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index fe7d4d6d756..c551e65d395 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -451,11 +451,14 @@ ktor-client-serialization-json = { module = "io.ktor:ktor-serialization-kotlinx-
ktor-server-cio = { module = "io.ktor:ktor-server-cio" }
ktor-server-core = { module = "io.ktor:ktor-server-core" }
ktor-server-htmlBuilder = { module = "io.ktor:ktor-server-html-builder" }
+langchain4j-anthropic = { module = "dev.langchain4j:langchain4j-anthropic" }
langchain4j-bom = { module = "dev.langchain4j:langchain4j-bom", version.ref = "langchain4j-bom" }
langchain4j-cohere = { module = "dev.langchain4j:langchain4j-cohere" }
langchain4j-core = { module = "dev.langchain4j:langchain4j-core" }
+langchain4j-google-ai-gemini = { module = "dev.langchain4j:langchain4j-google-ai-gemini" }
langchain4j-hugging-face = { module = "dev.langchain4j:langchain4j-hugging-face" }
langchain4j-mistral-ai = { module = "dev.langchain4j:langchain4j-mistral-ai" }
+langchain4j-ollama = { module = "dev.langchain4j:langchain4j-ollama" }
langchain4j-open-ai = { module = "dev.langchain4j:langchain4j-open-ai" }
lmax-disruptor = { module = "com.lmax:disruptor", version.ref = "lmax-disruptor" }
locationtech-spatial4j = { module = "org.locationtech.spatial4j:spatial4j", version.ref = "spatial4j" }
diff --git a/solr/licenses/langchain4j-anthropic-1.17.0.jar.sha1 b/solr/licenses/langchain4j-anthropic-1.17.0.jar.sha1
new file mode 100644
index 00000000000..714f5117abb
--- /dev/null
+++ b/solr/licenses/langchain4j-anthropic-1.17.0.jar.sha1
@@ -0,0 +1 @@
+6503765600e9db594e98428b94b3ae232271589e
diff --git a/solr/licenses/langchain4j-google-ai-gemini-1.17.0.jar.sha1 b/solr/licenses/langchain4j-google-ai-gemini-1.17.0.jar.sha1
new file mode 100644
index 00000000000..d2dce24e428
--- /dev/null
+++ b/solr/licenses/langchain4j-google-ai-gemini-1.17.0.jar.sha1
@@ -0,0 +1 @@
+adecffc79ff2689e853dce39750574fbff200dcb
diff --git a/solr/licenses/langchain4j-ollama-1.17.0.jar.sha1 b/solr/licenses/langchain4j-ollama-1.17.0.jar.sha1
new file mode 100644
index 00000000000..67bc0a99209
--- /dev/null
+++ b/solr/licenses/langchain4j-ollama-1.17.0.jar.sha1
@@ -0,0 +1 @@
+c1f7d6c322bcafcb101eca269de972295c9a3a96
diff --git a/solr/modules/language-models/build.gradle b/solr/modules/language-models/build.gradle
index 375a219f936..b7dd0373753 100644
--- a/solr/modules/language-models/build.gradle
+++ b/solr/modules/language-models/build.gradle
@@ -28,9 +28,12 @@ dependencies {
implementation libs.apache.lucene.core
implementation libs.langchain4j.core
+ runtimeOnly libs.langchain4j.anthropic
runtimeOnly libs.langchain4j.cohere
+ runtimeOnly libs.langchain4j.google.ai.gemini
runtimeOnly libs.langchain4j.hugging.face
runtimeOnly libs.langchain4j.mistral.ai
+ runtimeOnly libs.langchain4j.ollama
runtimeOnly libs.langchain4j.open.ai
implementation libs.slf4j.api
diff --git a/solr/modules/language-models/gradle.lockfile b/solr/modules/language-models/gradle.lockfile
index 38034aa07eb..9117b4fc141 100644
--- a/solr/modules/language-models/gradle.lockfile
+++ b/solr/modules/language-models/gradle.lockfile
@@ -43,13 +43,16 @@ com.tdunning:t-digest:3.3=jarValidation,runtimeClasspath,runtimeLibs,solrPlatfor
commons-cli:commons-cli:1.11.0=jarValidation,runtimeClasspath,runtimeLibs,solrPlatformLibs,testRuntimeClasspath
commons-codec:commons-codec:1.22.0=jarValidation,runtimeClasspath,runtimeLibs,solrPlatformLibs,testRuntimeClasspath
commons-io:commons-io:2.22.0=compileClasspath,jarValidation,runtimeClasspath,runtimeLibs,solrPlatformLibs,testCompileClasspath,testRuntimeClasspath
+dev.langchain4j:langchain4j-anthropic:1.17.0=jarValidation,runtimeClasspath,runtimeLibs,testRuntimeClasspath
dev.langchain4j:langchain4j-bom:1.17.0=compileClasspath,jarValidation,runtimeClasspath,runtimeLibs,testCompileClasspath,testRuntimeClasspath
dev.langchain4j:langchain4j-cohere:1.17.0-beta27=jarValidation,runtimeClasspath,runtimeLibs,testRuntimeClasspath
dev.langchain4j:langchain4j-core:1.17.0=compileClasspath,jarValidation,runtimeClasspath,runtimeLibs,testCompileClasspath,testRuntimeClasspath
+dev.langchain4j:langchain4j-google-ai-gemini:1.17.0=jarValidation,runtimeClasspath,runtimeLibs,testRuntimeClasspath
dev.langchain4j:langchain4j-http-client-jdk:1.17.0=jarValidation,runtimeClasspath,runtimeLibs,testRuntimeClasspath
dev.langchain4j:langchain4j-http-client:1.17.0=jarValidation,runtimeClasspath,runtimeLibs,testRuntimeClasspath
dev.langchain4j:langchain4j-hugging-face:1.17.0-beta27=jarValidation,runtimeClasspath,runtimeLibs,testRuntimeClasspath
dev.langchain4j:langchain4j-mistral-ai:1.17.0=jarValidation,runtimeClasspath,runtimeLibs,testRuntimeClasspath
+dev.langchain4j:langchain4j-ollama:1.17.0=jarValidation,runtimeClasspath,runtimeLibs,testRuntimeClasspath
dev.langchain4j:langchain4j-open-ai:1.17.0=jarValidation,runtimeClasspath,runtimeLibs,testRuntimeClasspath
io.dropwizard.metrics:metrics-core:4.2.39=jarValidation,runtimeClasspath,runtimeLibs,solrPlatformLibs,testRuntimeClasspath
io.github.eisop:dataflow-errorprone:3.41.0-eisop1=annotationProcessor,errorprone,testAnnotationProcessor
diff --git a/solr/modules/language-models/src/java/org/apache/solr/languagemodels/model/SolrLargeLanguageModel.java b/solr/modules/language-models/src/java/org/apache/solr/languagemodels/model/SolrLargeLanguageModel.java
new file mode 100644
index 00000000000..2a4dbacf70e
--- /dev/null
+++ b/solr/modules/language-models/src/java/org/apache/solr/languagemodels/model/SolrLargeLanguageModel.java
@@ -0,0 +1,208 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.languagemodels.model;
+
+import dev.langchain4j.data.message.UserMessage;
+import dev.langchain4j.model.chat.ChatModel;
+import dev.langchain4j.model.chat.request.ChatRequest;
+import dev.langchain4j.model.chat.request.ResponseFormat;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Method;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.Objects;
+import org.apache.lucene.util.Accountable;
+import org.apache.lucene.util.RamUsageEstimator;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.core.SolrResourceLoader;
+import org.apache.solr.languagemodels.LanguageModelException;
+import org.apache.solr.languagemodels.store.rest.LargeLanguageModelStore;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This object wraps a {@link dev.langchain4j.model.chat.ChatModel} given a prompt and a {@link
+ * ResponseFormat}. It's meant to be used as a managed resource with the {@link
+ * LargeLanguageModelStore}
+ */
+public class SolrLargeLanguageModel extends SolrLanguageModel implements Accountable {
+ private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+ private static final long BASE_RAM_BYTES =
+ RamUsageEstimator.shallowSizeOfInstance(SolrLargeLanguageModel.class);
+
+ private static final String THINKING_BUDGET_TOKENS = "thinkingBudgetTokens";
+ private static final String RANDOM_SEED = "randomSeed";
+
+ private final ChatModel chatModel;
+ private final int hashCode;
+
+ public static SolrLargeLanguageModel getInstance(
+ SolrResourceLoader solrResourceLoader,
+ String className,
+ String name,
+ Map<String, Object> params)
+ throws LanguageModelException {
+ try {
+ /*
+ * The idea here is to build a {@link dev.langchain4j.model.chat.ChatModel} using inversion
+ * of control.
+ * Each model has its own list of parameters we don't know beforehand, but each {@link dev.langchain4j.model.chat.ChatModel} class
+ * has its own builder that uses setters with the same name of the parameter in input.
+ * */
+ ChatModel chatModel;
+ Class<?> modelClass = solrResourceLoader.findClass(className, ChatModel.class);
+ var builder = modelClass.getMethod("builder").invoke(null);
+ if (params != null) {
+ /*
+ * This block of code has the responsibility of instantiate a {@link
+ * dev.langchain4j.model.chat.ChatModel} using the params provided. Classes have
+ * params of the specific implementation of {@link
+ * dev.langchain4j.model.chat.ChatModel}, which is not known beforehand. So we benefit of
+ * the design choice in langchain4j that each subclass implementing {@link
+ * dev.langchain4j.model.chat.ChatModel} uses setters with the same name of the
+ * param.
+ */
+ for (String paramName : params.keySet()) {
+ /*
+ * When a param is not primitive, we need to instantiate the object explicitly and then call the
+ * setter method.
+ * N.B. when adding support to new models, pay attention to all the parameters they
+ * support, some of them may require to be handled in here as separate switch cases
+ */
+ switch (paramName) {
+ case TIMEOUT_PARAM ->
+ builder
+ .getClass()
+ .getMethod(paramName, Duration.class)
+ .invoke(builder, Duration.ofSeconds((Long) params.get(paramName)));
+
+ case MAX_RETRIES_PARAM, THINKING_BUDGET_TOKENS, RANDOM_SEED ->
+ builder
+ .getClass()
+ .getMethod(paramName, Integer.class)
+ .invoke(builder, ((Long) params.get(paramName)).intValue());
+
+ /*
+ * For primitive params if there's only one setter available, we call it.
+ * If there's choice we default to the string one
+ */
+ default -> {
+ ArrayList<Method> paramNameMatches = new ArrayList<>();
+ for (var method : builder.getClass().getMethods()) {
+ if (paramName.equals(method.getName()) && method.getParameterCount() == 1) {
+ paramNameMatches.add(method);
+ }
+ }
+ if (paramNameMatches.size() == 1) {
+ paramNameMatches.getFirst().invoke(builder, params.get(paramName));
+ } else {
+ try {
+ builder
+ .getClass()
+ .getMethod(paramName, String.class)
+ .invoke(builder, params.get(paramName).toString());
+ } catch (NoSuchMethodException e) {
+ log.error("Parameter {} not supported by model {}", paramName, className);
+ throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, e.getMessage(), e);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Always enforce strict schema adherence where supported. For Anthropic and Google it's
+ // enabled by default
+ if (!"dev.langchain4j.model.anthropic.AnthropicChatModel".equals(className)
+ && !"dev.langchain4j.model.googleai.GoogleAiGeminiChatModel".equals(className)) {
+ try {
+ builder.getClass().getMethod("strictJsonSchema", Boolean.class).invoke(builder, true);
+ } catch (NoSuchMethodException ignored) {
+ log.debug(
+ "Model {} does not have strictJsonSchema param, structured output is not enforced",
+ className);
+ }
+ }
+ chatModel = (ChatModel) builder.getClass().getMethod("build").invoke(builder);
+ return new SolrLargeLanguageModel(name, chatModel, params);
+ } catch (final Exception e) {
+ throw new LanguageModelException("Model loading failed for " + className, e);
+ }
+ }
+
+ public SolrLargeLanguageModel(String name, ChatModel chatModel, Map<String, Object> params) {
+ super(name, params);
+ this.chatModel = chatModel;
+ this.hashCode = calculateHashCode();
+ }
+
+ /**
+ * Sends a structured chat request to the language model and returns the raw text response.
+ *
+ * @param prompt the user prompt to send to the language model
+ * @param responseFormat the format specification that instructs the model to produce structured
+ * JSON output
+ * @return the raw text response from the language model
+ */
+ public String generate(String prompt, ResponseFormat responseFormat) {
+ ChatRequest chatRequest =
+ ChatRequest.builder()
+ .responseFormat(responseFormat)
+ .messages(UserMessage.from(prompt))
+ .build();
+ return chatModel.chat(chatRequest).aiMessage().text();
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + "(name=" + getName() + ")";
+ }
+
+ @Override
+ public long ramBytesUsed() {
+ return BASE_RAM_BYTES
+ + RamUsageEstimator.sizeOfObject(name)
+ + RamUsageEstimator.sizeOfObject(chatModel);
+ }
+
+ @Override
+ public int hashCode() {
+ return hashCode;
+ }
+
+ private int calculateHashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = (prime * result) + Objects.hashCode(name);
+ result = (prime * result) + Objects.hashCode(chatModel);
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) return true;
+ if (!(obj instanceof SolrLargeLanguageModel)) return false;
+ final SolrLargeLanguageModel other = (SolrLargeLanguageModel) obj;
+ return Objects.equals(chatModel, other.chatModel) && Objects.equals(name, other.name);
+ }
+
+ @Override
+ public String getModelClassName() {
+ return chatModel.getClass().getName();
+ }
+}
diff --git a/solr/modules/language-models/src/java/org/apache/solr/languagemodels/store/rest/LargeLanguageModelStore.java b/solr/modules/language-models/src/java/org/apache/solr/languagemodels/store/rest/LargeLanguageModelStore.java
new file mode 100644
index 00000000000..a42755a2f1f
--- /dev/null
+++ b/solr/modules/language-models/src/java/org/apache/solr/languagemodels/store/rest/LargeLanguageModelStore.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.languagemodels.store.rest;
+
+import java.util.Map;
+import net.jcip.annotations.ThreadSafe;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.core.SolrCore;
+import org.apache.solr.core.SolrResourceLoader;
+import org.apache.solr.languagemodels.model.SolrLargeLanguageModel;
+import org.apache.solr.rest.ManagedResourceObserver;
+import org.apache.solr.rest.ManagedResourceStorage;
+
+/** Managed Resource for the Solr large language model, exposed via REST */
+@ThreadSafe
+public class LargeLanguageModelStore extends ManagedLanguageModelStore<SolrLargeLanguageModel> {
+ /** the model store rest endpoint */
+ public static final String REST_END_POINT = "/schema/large-language-model-store";
+
+ public static void registerManagedLargeLanguageModelStore(
+ SolrResourceLoader solrResourceLoader, ManagedResourceObserver managedResourceObserver) {
+ solrResourceLoader
+ .getManagedResourceRegistry()
+ .registerManagedResource(
+ REST_END_POINT, LargeLanguageModelStore.class, managedResourceObserver);
+ }
+
+ public static LargeLanguageModelStore getManagedModelStore(SolrCore core) {
+ return (LargeLanguageModelStore) core.getRestManager().getManagedResource(REST_END_POINT);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ protected SolrLargeLanguageModel fromModelMap(
+ SolrResourceLoader solrResourceLoader, Map<String, Object> modelMap) {
+ return SolrLargeLanguageModel.getInstance(
+ solrResourceLoader,
+ (String) modelMap.get(CLASS_KEY),
+ (String) modelMap.get(NAME_KEY),
+ (Map<String, Object>) modelMap.get(PARAMS_KEY));
+ }
+
+ public LargeLanguageModelStore(
+ String resourceId, SolrResourceLoader loader, ManagedResourceStorage.StorageIO storageIO)
+ throws SolrException {
+ super(resourceId, loader, storageIO);
+ }
+}
diff --git a/solr/modules/language-models/src/java/org/apache/solr/languagemodels/update/processor/DocumentEnrichmentUpdateProcessor.java b/solr/modules/language-models/src/java/org/apache/solr/languagemodels/update/processor/DocumentEnrichmentUpdateProcessor.java
new file mode 100644
index 00000000000..5315ee8f5eb
--- /dev/null
+++ b/solr/modules/language-models/src/java/org/apache/solr/languagemodels/update/processor/DocumentEnrichmentUpdateProcessor.java
@@ -0,0 +1,159 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.solr.languagemodels.update.processor;
+
+import dev.langchain4j.model.chat.request.ResponseFormat;
+import dev.langchain4j.model.chat.request.json.JsonArraySchema;
+import dev.langchain4j.model.chat.request.json.JsonBooleanSchema;
+import dev.langchain4j.model.chat.request.json.JsonIntegerSchema;
+import dev.langchain4j.model.chat.request.json.JsonNumberSchema;
+import dev.langchain4j.model.chat.request.json.JsonObjectSchema;
+import dev.langchain4j.model.chat.request.json.JsonSchemaElement;
+import dev.langchain4j.model.chat.request.json.JsonStringSchema;
+import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+import java.util.List;
+import java.util.Map;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.common.SolrInputDocument;
+import org.apache.solr.common.SolrInputField;
+import org.apache.solr.common.util.Utils;
+import org.apache.solr.languagemodels.model.SolrLargeLanguageModel;
+import org.apache.solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory;
+import org.apache.solr.request.SolrQueryRequest;
+import org.apache.solr.schema.IndexSchema;
+import org.apache.solr.schema.SchemaField;
+import org.apache.solr.update.AddUpdateCommand;
+import org.apache.solr.update.processor.UpdateRequestProcessor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DocumentEnrichmentUpdateProcessor extends UpdateRequestProcessor {
+ private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
+ private final IndexSchema schema;
+ private final List<String> inputFields;
+ private final String outputField;
+ private final String prompt;
+ private final SolrLargeLanguageModel largeLanguageModel;
+ private final boolean multiValued;
+ private final ResponseFormat responseFormat;
+
+ public DocumentEnrichmentUpdateProcessor(
+ List<String> inputFields,
+ String outputField,
+ String prompt,
+ SolrLargeLanguageModel largeLanguageModel,
+ boolean multiValued,
+ ResponseFormat responseFormat,
+ SolrQueryRequest req,
+ UpdateRequestProcessor next) {
+ super(next);
+ this.schema = req.getSchema();
+ this.inputFields = inputFields;
+ this.outputField = outputField;
+ this.prompt = prompt;
+ this.largeLanguageModel = largeLanguageModel;
+ this.multiValued = multiValued;
+ this.responseFormat = responseFormat;
+ }
+
+ /**
+ * @param cmd the update command in input containing the Document to process
+ * @throws IOException If there is a low-level I/O error
+ */
+ @Override
+ public void processAdd(AddUpdateCommand cmd) throws IOException {
+ SolrInputDocument doc = cmd.getSolrInputDocument();
+
+ // Collect all field values; skip enrichment if any declared field is null or empty
+ String injectedPrompt = prompt;
+ for (String fieldName : inputFields) {
+ SolrInputField field = doc.get(fieldName);
+ if (isNullOrEmpty(field)) {
+ super.processAdd(cmd);
+ return;
+ }
+ injectedPrompt = injectedPrompt.replace("{" + fieldName + "}", field.getValue().toString());
+ }
+
+ try {
+ // as for now, only a plain text as prompt is sent to the model (no support for
+ // tools/skills/agents)
+ // chatModel.chat returns the parsed value from the structured JSON response
+ Object returnValue =
+ Utils.fromJSONString(largeLanguageModel.generate(injectedPrompt, responseFormat));
+ // Guardrails for OllamaChatModel, since it doesn't support strict JSON structured output mode
+ if (!(returnValue instanceof Map<?, ?> map)
+ || !map.containsKey(DocumentEnrichmentUpdateProcessorFactory.JSON_FIELD_PROPERTY)) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR,
+ "LLM was not able to format the response correctly: " + returnValue);
+ }
+ Object generatedFieldValue =
+ map.get(DocumentEnrichmentUpdateProcessorFactory.JSON_FIELD_PROPERTY);
+ JsonSchemaElement structuredOutputType =
+ ((JsonObjectSchema) responseFormat.jsonSchema().rootElement())
+ .properties()
+ .get(DocumentEnrichmentUpdateProcessorFactory.JSON_FIELD_PROPERTY);
+ boolean typeOk =
+ switch (structuredOutputType) {
+ case JsonStringSchema outputType -> generatedFieldValue instanceof String;
+ case JsonIntegerSchema outputType ->
+ generatedFieldValue instanceof Integer || generatedFieldValue instanceof Long;
+ case JsonNumberSchema outputType -> generatedFieldValue instanceof Number;
+ case JsonBooleanSchema outputType -> generatedFieldValue instanceof Boolean;
+ case JsonArraySchema outputType -> generatedFieldValue instanceof List;
+ default -> true;
+ };
+ if (!typeOk) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR,
+ "LLM returned wrong value type: expected "
+ + structuredOutputType.getClass().getSimpleName()
+ + " but got "
+ + generatedFieldValue.getClass().getSimpleName());
+ }
+ if (multiValued && generatedFieldValue instanceof List<?> generatedFieldValueList) {
+ for (Object item : generatedFieldValueList) {
+ doc.addField(outputField, item);
+ }
+ } else {
+ doc.setField(outputField, generatedFieldValue);
+ }
+ } catch (RuntimeException largeLanguageModelFailure) {
+ if (log.isErrorEnabled()) {
+ SchemaField uniqueKeyField = schema.getUniqueKeyField();
+ String uniqueKeyFieldName = uniqueKeyField.getName();
+ log.error(
+ "Could not process fields {} for the document with {}: {}",
+ inputFields,
+ uniqueKeyFieldName,
+ doc.getFieldValue(uniqueKeyFieldName),
+ largeLanguageModelFailure);
+ }
+ }
+ super.processAdd(cmd);
+ }
+
+ protected boolean isNullOrEmpty(SolrInputField inputFieldContent) {
+ return (inputFieldContent == null
+ || inputFieldContent.getValue() == null
+ || inputFieldContent.getValue().toString().isEmpty());
+ }
+}
diff --git a/solr/modules/language-models/src/java/org/apache/solr/languagemodels/update/processor/factory/DocumentEnrichmentUpdateProcessorFactory.java b/solr/modules/language-models/src/java/org/apache/solr/languagemodels/update/processor/factory/DocumentEnrichmentUpdateProcessorFactory.java
new file mode 100644
index 00000000000..c1c514b4de7
--- /dev/null
+++ b/solr/modules/language-models/src/java/org/apache/solr/languagemodels/update/processor/factory/DocumentEnrichmentUpdateProcessorFactory.java
@@ -0,0 +1,342 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.solr.languagemodels.update.processor.factory;
+
+import dev.langchain4j.model.chat.request.ResponseFormat;
+import dev.langchain4j.model.chat.request.ResponseFormatType;
+import dev.langchain4j.model.chat.request.json.JsonArraySchema;
+import dev.langchain4j.model.chat.request.json.JsonBooleanSchema;
+import dev.langchain4j.model.chat.request.json.JsonIntegerSchema;
+import dev.langchain4j.model.chat.request.json.JsonNumberSchema;
+import dev.langchain4j.model.chat.request.json.JsonObjectSchema;
+import dev.langchain4j.model.chat.request.json.JsonSchema;
+import dev.langchain4j.model.chat.request.json.JsonSchemaElement;
+import dev.langchain4j.model.chat.request.json.JsonStringSchema;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.common.params.RequiredSolrParams;
+import org.apache.solr.common.params.SolrParams;
+import org.apache.solr.common.util.NamedList;
+import org.apache.solr.core.SolrCore;
+import org.apache.solr.core.SolrResourceLoader;
+import org.apache.solr.languagemodels.model.SolrLargeLanguageModel;
+import org.apache.solr.languagemodels.store.rest.LargeLanguageModelStore;
+import org.apache.solr.languagemodels.update.processor.DocumentEnrichmentUpdateProcessor;
+import org.apache.solr.request.SolrQueryRequest;
+import org.apache.solr.response.SolrQueryResponse;
+import org.apache.solr.rest.ManagedResource;
+import org.apache.solr.rest.ManagedResourceObserver;
+import org.apache.solr.schema.BoolField;
+import org.apache.solr.schema.DatePointField;
+import org.apache.solr.schema.DenseVectorField;
+import org.apache.solr.schema.DoublePointField;
+import org.apache.solr.schema.FieldType;
+import org.apache.solr.schema.FloatPointField;
+import org.apache.solr.schema.IndexSchema;
+import org.apache.solr.schema.IntPointField;
+import org.apache.solr.schema.LongPointField;
+import org.apache.solr.schema.NestPathField;
+import org.apache.solr.schema.SchemaField;
+import org.apache.solr.schema.StrField;
+import org.apache.solr.schema.TextField;
+import org.apache.solr.schema.UUIDField;
+import org.apache.solr.update.processor.UpdateRequestProcessor;
+import org.apache.solr.update.processor.UpdateRequestProcessorFactory;
+import org.apache.solr.util.plugin.SolrCoreAware;
+
+/**
+ * Generate the content of {@code outputField} based on other fields specified as {@code
+ * inputField}s.
+ *
+ * <p>The following validation rules are applied:
+ *
+ * <ul>
+ * <li>At least one {@code inputField} must be declared.
+ * <li>Exactly one of {@code prompt} or {@code promptFile} must be provided.
+ * <li>Every declared {@code inputField} must have a corresponding {@code {fieldName}} placeholder
+ * in the prompt.
+ * <li>Every {@code {placeholder}} in the prompt must correspond to a declared {@code inputField}.
+ * <li>One and only one {@code outputField} is allowed.
+ * </ul>
+ *
+ * <pre class="prettyprint" >
+ * &lt;processor class=&quot;solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory&quot;&gt;
+ * &lt;str name=&quot;inputField&quot;&gt;title_field&lt;/str&gt;
+ * &lt;str name=&quot;inputField&quot;&gt;body_field&lt;/str&gt;
+ * &lt;str name=&quot;outputField&quot;&gt;enriched_field&lt;/str&gt;
+ * &lt;str name=&quot;prompt&quot;&gt;Title: {title_field}. Body: {body_field}.&lt;/str&gt; // or &lt;str name=&quot;promptFile&quot;&gt;prompt.txt&lt;/str&gt;
+ * &lt;str name=&quot;model&quot;&gt;model-name&lt;/str&gt;
+ * &lt;/processor&gt;
+ * </pre>
+ *
+ * <p>Multiple {@code inputField} values can also be declared as an array using {@code arr}:
+ *
+ * <pre class="prettyprint" >
+ * &lt;arr name=&quot;inputField&quot;&gt;
+ * &lt;str&gt;title_field&lt;/str&gt;
+ * &lt;str&gt;body_field&lt;/str&gt;
+ * &lt;/arr&gt;
+ * </pre>
+ */
+public class DocumentEnrichmentUpdateProcessorFactory extends UpdateRequestProcessorFactory
+ implements SolrCoreAware, ManagedResourceObserver {
+ private static final String INPUT_FIELD_PARAM = "inputField";
+ private static final String OUTPUT_FIELD_PARAM = "outputField";
+ private static final String PROMPT = "prompt";
+ private static final String PROMPT_FILE = "promptFile";
+ private static final String MODEL_NAME = "model";
+ private static final String JSON_SCHEMA_NAME = "output";
+ public static final String JSON_FIELD_PROPERTY = "value";
+ private static final Pattern PLACEHOLDER_PATTERN = Pattern.compile("\\{([^}]+)\\}");
+
+ private List<String> inputFields;
+ private String outputField;
+ private String promptText;
+ private String promptFile;
+ private String modelName;
+
+ @Override
+ public void init(final NamedList<?> args) {
+ Collection<String> fieldNames = args.removeConfigArgs(INPUT_FIELD_PARAM);
+ if (fieldNames.isEmpty()) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR, "At least one 'inputField' must be provided");
+ }
+ inputFields = List.copyOf(fieldNames);
+
+ Collection<String> outputFields = args.removeConfigArgs(OUTPUT_FIELD_PARAM);
+ if (outputFields.size() != 1) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR,
+ "Exactly one 'outputField' must be provided, but found: "
+ + (outputFields.isEmpty() ? "None" : outputFields));
+ }
+ outputField = outputFields.iterator().next();
+
+ SolrParams params = args.toSolrParams();
+ RequiredSolrParams required = params.required();
+ modelName = required.get(MODEL_NAME);
+
+ String inlinePrompt = params.get(PROMPT);
+ String promptFilePath = params.get(PROMPT_FILE);
+
+ if (inlinePrompt == null && promptFilePath == null) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR, "Either 'prompt' or 'promptFile' must be provided");
+ }
+ if (inlinePrompt != null && promptFilePath != null) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR,
+ "Only one of 'prompt' or 'promptFile' must be provided, not both");
+ }
+ if (inlinePrompt != null) {
+ validatePromptPlaceholders(inlinePrompt, inputFields);
+ this.promptText = inlinePrompt;
+ }
+ this.promptFile = promptFilePath;
+ }
+
+ @Override
+ public void inform(SolrCore core) {
+ final SolrResourceLoader solrResourceLoader = core.getResourceLoader();
+ LargeLanguageModelStore.registerManagedLargeLanguageModelStore(solrResourceLoader, this);
+ if (promptFile != null) {
+ try (InputStream is = solrResourceLoader.openResource(promptFile)) {
+ promptText = new String(is.readAllBytes(), StandardCharsets.UTF_8).trim();
+ } catch (IOException e) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR, "Cannot read prompt file: " + promptFile, e);
+ }
+ validatePromptPlaceholders(promptText, inputFields);
+ }
+ }
+
+ @Override
+ public void onManagedResourceInitialized(NamedList<?> args, ManagedResource res)
+ throws SolrException {
+ if (res instanceof LargeLanguageModelStore store) {
+ store.loadStoredModels();
+ }
+ }
+
+ @Override
+ public UpdateRequestProcessor getInstance(
+ SolrQueryRequest req, SolrQueryResponse rsp, UpdateRequestProcessor next) {
+ IndexSchema latestSchema = req.getCore().getLatestSchema();
+
+ for (String fieldName : inputFields) {
+ if (!latestSchema.isDynamicField(fieldName) && !latestSchema.hasExplicitField(fieldName)) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR, "undefined field: \"" + fieldName + "\"");
+ }
+ }
+
+ final SchemaField outputFieldSchema = latestSchema.getField(outputField);
+
+ ResponseFormat responseFormat = getJsonSchema(outputFieldSchema);
+ boolean multiValued = outputFieldSchema.multiValued();
+
+ LargeLanguageModelStore store = LargeLanguageModelStore.getManagedModelStore(req.getCore());
+ SolrLargeLanguageModel largeLanguageModel = store.getModel(modelName);
+ if (largeLanguageModel == null) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR,
+ "The model configured in the Update Request Processor '"
+ + modelName
+ + "' can't be found in the store: "
+ + LargeLanguageModelStore.REST_END_POINT);
+ }
+
+ return new DocumentEnrichmentUpdateProcessor(
+ inputFields,
+ outputField,
+ promptText,
+ largeLanguageModel,
+ multiValued,
+ responseFormat,
+ req,
+ next);
+ }
+
+ /**
+ * Builds a {@link ResponseFormat} that instructs the model to return a JSON object {@code
+ * {"value": ...}} whose value type matches the Solr field type. For multivalued fields the value
+ * is wrapped in a {@link JsonArraySchema} nested inside the root {@link JsonObjectSchema}.
+ *
+ * <p>For example, a single-valued {@code string} field (e.g. {@code StrField}) produces a schema
+ * requiring output of the form:
+ *
+ * <pre>{@code
+ * {"value": "some example string"}
+ * }</pre>
+ *
+ * <p>while a multivalued {@code int} field (e.g. {@code IntPointField}) produces a schema
+ * requiring output of the form:
+ *
+ * <pre>{@code
+ * {"value": [1, 2, 3]}
+ * }</pre>
+ *
+ * <p>Nesting {@link JsonArraySchema} inside a {@link JsonObjectSchema} property is supported by
+ * all langchain4j providers that implement structured outputs with {@link JsonObjectSchema}
+ * (OpenAI, Azure OpenAI, Google AI, Gemini, Mistral, Ollama, Amazon Bedrock, Watsonx).
+ */
+ static ResponseFormat getJsonSchema(SchemaField schemaField) {
+ JsonSchemaElement valueElement = toJsonSchemaElement(schemaField.getType());
+ JsonSchemaElement valueSchema =
+ schemaField.multiValued()
+ ? JsonArraySchema.builder().items(valueElement).build()
+ : valueElement;
+ return ResponseFormat.builder()
+ .type(ResponseFormatType.JSON)
+ .jsonSchema(
+ JsonSchema.builder()
+ .name(JSON_SCHEMA_NAME)
+ .rootElement(
+ JsonObjectSchema.builder()
+ .addProperty(JSON_FIELD_PROPERTY, valueSchema)
+ .required(JSON_FIELD_PROPERTY)
+ .build())
+ .build())
+ .build();
+ }
+
+ private static JsonSchemaElement toJsonSchemaElement(FieldType fieldType) {
+ SolrException unsupportedFieldTypeException =
+ new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR,
+ "field type is not supported by Document Enrichment: "
+ + fieldType.getClass().getSimpleName());
+
+ return switch (fieldType) {
+ // first check unsupported types and throw SolrException
+ case DenseVectorField f -> throw unsupportedFieldTypeException;
+ case UUIDField f -> throw unsupportedFieldTypeException;
+ case NestPathField f -> throw unsupportedFieldTypeException;
+
+ // build JsonSchemaElement for supported types
+ case StrField f -> new JsonStringSchema();
+ case TextField f -> new JsonStringSchema();
+ case DatePointField f -> new JsonStringSchema();
+
+ case IntPointField f -> new JsonIntegerSchema();
+ case LongPointField f -> new JsonIntegerSchema();
+
+ case FloatPointField f -> new JsonNumberSchema();
+ case DoublePointField f -> new JsonNumberSchema();
+
+ case BoolField f -> new JsonBooleanSchema();
+
+ // fall-back to SolrException
+ default -> throw unsupportedFieldTypeException;
+ };
+ }
+
+ private static void validatePromptPlaceholders(String prompt, List<String> inputFields) {
+ Set<String> promptPlaceholders = new HashSet<>();
+ Matcher matcher = PLACEHOLDER_PATTERN.matcher(prompt);
+ while (matcher.find()) {
+ promptPlaceholders.add(matcher.group(1));
+ }
+
+ Set<String> fieldsWithoutPlaceholderInPrompt = new HashSet<>(inputFields);
+ fieldsWithoutPlaceholderInPrompt.removeAll(promptPlaceholders);
+ if (!fieldsWithoutPlaceholderInPrompt.isEmpty()) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR,
+ "prompt is missing placeholders for inputField(s): " + fieldsWithoutPlaceholderInPrompt);
+ }
+
+ Set<String> placeholdersInPromptWithoutField = new HashSet<>(promptPlaceholders);
+ placeholdersInPromptWithoutField.removeAll(new HashSet<>(inputFields));
+ if (!placeholdersInPromptWithoutField.isEmpty()) {
+ throw new SolrException(
+ SolrException.ErrorCode.SERVER_ERROR,
+ "prompt contains placeholders not declared as inputField(s): "
+ + placeholdersInPromptWithoutField);
+ }
+ }
+
+ public List<String> getInputFields() {
+ return inputFields;
+ }
+
+ public String getOutputField() {
+ return outputField;
+ }
+
+ public String getPrompt() {
+ return promptText;
+ }
+
+ public String getModelName() {
+ return modelName;
+ }
+
+ public String getPromptFile() {
+ return promptFile;
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/largeLanguageModelExamples/anthropic-model.json b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/anthropic-model.json
new file mode 100644
index 00000000000..88e58edcf47
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/anthropic-model.json
@@ -0,0 +1,13 @@
+{
+ "class": "dev.langchain4j.model.anthropic.AnthropicChatModel",
+ "name": "anthropic-1",
+ "params": {
+ "baseUrl": "https://api.anthropic.com/v1",
+ "apiKey": "apiKey-anthropic",
+ "modelName": "claude-3-5-haiku-latest",
+ "timeout": 60,
+ "logRequests": true,
+ "logResponses": true,
+ "maxRetries": 5
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/largeLanguageModelExamples/dummy-model-ambiguous.json b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/dummy-model-ambiguous.json
new file mode 100644
index 00000000000..d7e0e2b9878
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/dummy-model-ambiguous.json
@@ -0,0 +1,8 @@
+{
+ "class": "org.apache.solr.languagemodels.model.DummyChatModel",
+ "name": "dummy-1",
+ "params": {
+ "response": "enriched content",
+ "ambiguousTypeParam": 10
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/largeLanguageModelExamples/dummy-model-unsupported.json b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/dummy-model-unsupported.json
new file mode 100644
index 00000000000..36905c9d1ca
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/dummy-model-unsupported.json
@@ -0,0 +1,8 @@
+{
+ "class": "org.apache.solr.languagemodels.model.DummyChatModel",
+ "name": "dummy-1",
+ "params": {
+ "response": "enriched content",
+ "unsupportedParam": 10
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/largeLanguageModelExamples/dummy-model.json b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/dummy-model.json
new file mode 100644
index 00000000000..b8d6b5c2051
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/dummy-model.json
@@ -0,0 +1,7 @@
+{
+ "class": "org.apache.solr.languagemodels.model.DummyChatModel",
+ "name": "dummy-1",
+ "params": {
+ "response": "{\"value\": \"enriched content\"}"
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/largeLanguageModelExamples/exception-throwing-model.json b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/exception-throwing-model.json
new file mode 100644
index 00000000000..8c395470122
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/exception-throwing-model.json
@@ -0,0 +1,6 @@
+{
+ "class": "org.apache.solr.languagemodels.model.ExceptionThrowingChatModel",
+ "name": "exception-throwing-model",
+ "params": {
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/largeLanguageModelExamples/gemini-model.json b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/gemini-model.json
new file mode 100644
index 00000000000..f075a1e402d
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/gemini-model.json
@@ -0,0 +1,12 @@
+{
+ "class": "dev.langchain4j.model.googleai.GoogleAiGeminiChatModel",
+ "name": "gemini-1",
+ "params": {
+ "apiKey": "apiKey-gemini",
+ "modelName": "gemini-2.0-flash",
+ "timeout": 60,
+ "logRequests": true,
+ "logResponses": true,
+ "maxRetries": 5
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/largeLanguageModelExamples/mistralai-model.json b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/mistralai-model.json
new file mode 100644
index 00000000000..ac75dbf1a2b
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/mistralai-model.json
@@ -0,0 +1,13 @@
+{
+ "class": "dev.langchain4j.model.mistralai.MistralAiChatModel",
+ "name": "mistralai-1",
+ "params": {
+ "baseUrl": "https://api.mistral.ai/v1",
+ "apiKey": "apiKey-mistralAI",
+ "modelName": "mistral-small-latest",
+ "timeout": 60,
+ "logRequests": true,
+ "logResponses": true,
+ "maxRetries": 5
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/largeLanguageModelExamples/not-a-chat-model.json b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/not-a-chat-model.json
new file mode 100644
index 00000000000..f223c61fb35
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/not-a-chat-model.json
@@ -0,0 +1,7 @@
+{
+ "class": "com.example.NonExistentChatModel",
+ "name": "not-a-field-generation-model-1",
+ "params": {
+ "apiKey": "test-api-key"
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/largeLanguageModelExamples/ollama-model.json b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/ollama-model.json
new file mode 100644
index 00000000000..bb6f8081efe
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/ollama-model.json
@@ -0,0 +1,11 @@
+{
+ "class": "dev.langchain4j.model.ollama.OllamaChatModel",
+ "name": "ollama-1",
+ "params": {
+ "baseUrl": "http://localhost:11434",
+ "modelName": "llama3.2",
+ "timeout": 60,
+ "logRequests": true,
+ "logResponses": true
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/largeLanguageModelExamples/openai-model.json b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/openai-model.json
new file mode 100644
index 00000000000..74ffde65e3b
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/largeLanguageModelExamples/openai-model.json
@@ -0,0 +1,13 @@
+{
+ "class": "dev.langchain4j.model.openai.OpenAiChatModel",
+ "name": "openai-1",
+ "params": {
+ "baseUrl": "https://api.openai.com/v1",
+ "apiKey": "apiKey-openAI",
+ "modelName": "gpt-5.4-nano",
+ "timeout": 60,
+ "logRequests": true,
+ "logResponses": true,
+ "maxRetries": 5
+ }
+}
diff --git a/solr/modules/language-models/src/test-files/solr/collection1/conf/prompt-multi-field.txt b/solr/modules/language-models/src/test-files/solr/collection1/conf/prompt-multi-field.txt
new file mode 100644
index 00000000000..65c2f125e36
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/solr/collection1/conf/prompt-multi-field.txt
@@ -0,0 +1 @@
+Title: {string_field}. Body: {body_field}.
\ No newline at end of file
diff --git a/solr/modules/language-models/src/test-files/solr/collection1/conf/prompt-no-placeholder.txt b/solr/modules/language-models/src/test-files/solr/collection1/conf/prompt-no-placeholder.txt
new file mode 100644
index 00000000000..c43c5399dc0
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/solr/collection1/conf/prompt-no-placeholder.txt
@@ -0,0 +1 @@
+Summarize this content without the placeholder.
\ No newline at end of file
diff --git a/solr/modules/language-models/src/test-files/solr/collection1/conf/prompt.txt b/solr/modules/language-models/src/test-files/solr/collection1/conf/prompt.txt
new file mode 100644
index 00000000000..502449a5cf5
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/solr/collection1/conf/prompt.txt
@@ -0,0 +1 @@
+Summarize this content: {string_field}
\ No newline at end of file
diff --git a/solr/modules/language-models/src/test-files/solr/collection1/conf/schema-language-models.xml b/solr/modules/language-models/src/test-files/solr/collection1/conf/schema-language-models.xml
index ef93fbc057d..8a405cf747e 100644
--- a/solr/modules/language-models/src/test-files/solr/collection1/conf/schema-language-models.xml
+++ b/solr/modules/language-models/src/test-files/solr/collection1/conf/schema-language-models.xml
@@ -25,7 +25,11 @@
<fieldType name="knn_vector_byte_encoding" class="solr.DenseVectorField" vectorDimension="4" similarityFunction="cosine" vectorEncoding="BYTE"/>
<fieldType name="high_dimensional_float_knn_vector" class="solr.DenseVectorField" vectorDimension="2048" similarityFunction="cosine" vectorEncoding="FLOAT32"/>
<fieldType name="high_dimensional_byte_knn_vector" class="solr.DenseVectorField" vectorDimension="2048" similarityFunction="cosine" vectorEncoding="BYTE"/>
- <fieldType name="plong" class="solr.LongPointField" useDocValuesAsStored="false"/>
+ <fieldType name="plong" class="solr.LongPointField" useDocValuesAsStored="false"/>
+ <fieldType name="pint" class="solr.IntPointField" useDocValuesAsStored="false"/>
+ <fieldType name="pfloat" class="solr.FloatPointField" useDocValuesAsStored="false"/>
+ <fieldType name="pdouble" class="solr.DoublePointField" useDocValuesAsStored="false"/>
+ <fieldType name="pdate" class="solr.DatePointField" useDocValuesAsStored="false"/>
<dynamicField name="*_s" type="string" indexed="true" stored="true" />
<dynamicField name="*_vector1024" type="knn_vector" indexed="true" stored="true" />
@@ -36,11 +40,49 @@
<field name="2048_byte_vector" type="high_dimensional_byte_knn_vector" indexed="true" stored="true" />
<field name="2048_float_vector" type="high_dimensional_float_knn_vector" indexed="true" stored="true" />
<field name="string_field" type="string" indexed="true" stored="true" multiValued="false" required="false"/>
+ <field name="output_sortable_text" type="sortable_text_type" indexed="true" stored="true" multiValued="false"/>
+ <field name="body_field" type="string" indexed="true" stored="true" multiValued="false" required="false"/>
+ <field name="tags_field" type="string" indexed="true" stored="true" multiValued="true" required="false"/>
+ <field name="processor_output_field" type="string" indexed="true" stored="true" multiValued="false" required="false"/>
+ <field name="processor_output_field_multi" type="string" indexed="true" stored="true" multiValued="true" required="false"/>
+
+ <!-- single-valued output fields for each supported type -->
+ <field name="output_long" type="plong" indexed="true" stored="true" multiValued="false"/>
+ <field name="output_int" type="pint" indexed="true" stored="true" multiValued="false"/>
+ <field name="output_float" type="pfloat" indexed="true" stored="true" multiValued="false"/>
+ <field name="output_double" type="pdouble" indexed="true" stored="true" multiValued="false"/>
+ <field name="output_boolean" type="boolean" indexed="true" stored="true" multiValued="false"/>
+ <field name="output_date" type="pdate" indexed="true" stored="true" multiValued="false"/>
+
+ <!-- multivalued output fields for each supported type -->
+ <field name="output_long_multi" type="plong" indexed="true" stored="true" multiValued="true"/>
+ <field name="output_int_multi" type="pint" indexed="true" stored="true" multiValued="true"/>
+ <field name="output_float_multi" type="pfloat" indexed="true" stored="true" multiValued="true"/>
+ <field name="output_double_multi" type="pdouble" indexed="true" stored="true" multiValued="true"/>
+ <field name="output_boolean_multi" type="boolean" indexed="true" stored="true" multiValued="true"/>
+ <field name="output_date_multi" type="pdate" indexed="true" stored="true" multiValued="true"/>
+
+ <!-- output fields for an unsupported type -->
+ <field name="output_binary" type="binary" indexed="true" stored="true" multiValued="false"/>
+
+ <!-- output fields for types that would be implicitly supported via class inheritance, but are intentionally disabled -->
+ <field name="output_uuid" type="uuid_type" indexed="true" stored="true" multiValued="false"/>
+ <field name="output_nest_path" type="nest_path_type" indexed="true" stored="true" multiValued="false"/>
<field name="_version_" type="plong" indexed="true" stored="true" multiValued="false" />
<field name="_text_" type="text_general" indexed="true" stored="false" multiValued="true"/>
<copyField source="*" dest="_text_"/>
<field name="vectorised" type="boolean" indexed="true" stored="false" docValues="true" default="false"/>
+ <field name="enriched" type="boolean" indexed="true" stored="false" docValues="true" default="false"/>
+
+ <fieldType name="binary" class="solr.BinaryField"/>
+ <fieldType name="uuid_type" class="solr.UUIDField"/>
+ <fieldType name="nest_path_type" class="solr.NestPathField"/>
+ <fieldType name="sortable_text_type" class="solr.SortableTextField">
+ <analyzer>
+ <tokenizer class="solr.WhitespaceTokenizerFactory"/>
+ </analyzer>
+ </fieldType>
<fieldType name="text_general" class="solr.TextField" positionIncrementGap="100" multiValued="true">
<analyzer type="index">
diff --git a/solr/modules/language-models/src/test-files/solr/collection1/conf/solrconfig-document-enrichment.xml b/solr/modules/language-models/src/test-files/solr/collection1/conf/solrconfig-document-enrichment.xml
new file mode 100644
index 00000000000..f8d0df95009
--- /dev/null
+++ b/solr/modules/language-models/src/test-files/solr/collection1/conf/solrconfig-document-enrichment.xml
@@ -0,0 +1,258 @@
+<?xml version="1.0" ?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
+ license agreements. See the NOTICE file distributed with this work for additional
+ information regarding copyright ownership. The ASF licenses this file to
+ You under the Apache License, Version 2.0 (the "License"); you may not use
+ this file except in compliance with the License. You may obtain a copy of
+ the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
+ by applicable law or agreed to in writing, software distributed under the
+ License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+ OF ANY KIND, either express or implied. See the License for the specific
+ language governing permissions and limitations under the License. -->
+
+<config>
+ <luceneMatchVersion>${tests.luceneMatchVersion:LATEST}</luceneMatchVersion>
+ <dataDir>${solr.data.dir:}</dataDir>
+ <directoryFactory name="DirectoryFactory"
+ class="${solr.directoryFactory:solr.MockDirectoryFactory}" />
+ <schemaFactory class="ClassicIndexSchemaFactory" />
+
+ <requestDispatcher>
+ <requestParsers />
+ </requestDispatcher>
+
+ <query>
+ <filterCache class="solr.CaffeineCache" size="4096"
+ initialSize="2048" autowarmCount="0" />
+ </query>
+ <requestHandler name="/select" class="solr.SearchHandler" />
+
+ <updateHandler class="solr.DirectUpdateHandler2">
+ <autoCommit>
+ <maxTime>15000</maxTime>
+ <openSearcher>false</openSearcher>
+ </autoCommit>
+ <autoSoftCommit>
+ <maxTime>1000</maxTime>
+ </autoSoftCommit>
+ <updateLog>
+ <str name="dir">${solr.data.dir:}</str>
+ </updateLog>
+ </updateHandler>
+
+ <requestHandler name="/query" class="solr.SearchHandler">
+ <lst name="defaults">
+ <str name="echoParams">explicit</str>
+ <str name="wt">json</str>
+ <str name="indent">true</str>
+ <str name="df">id</str>
+ </lst>
+ </requestHandler>
+
+ <updateRequestProcessorChain name="documentEnrichment">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">processor_output_field</str>
+ <str name="prompt">Summarize this content: {string_field}</str>
+ <str name="model">dummy-1</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentArrInputField">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <arr name="inputField">
+ <str>string_field</str>
+ <str>body_field</str>
+ </arr>
+ <str name="outputField">processor_output_field</str>
+ <str name="prompt">Title: {string_field}. Body: {body_field}.</str>
+ <str name="model">dummy-1</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="failingDocumentEnrichment">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">processor_output_field</str>
+ <str name="prompt">Summarize this content: {string_field}</str>
+ <str name="model">exception-throwing-model</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentForPartialUpdates">
+ <processor class="solr.DistributedUpdateProcessorFactory"/>
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">processor_output_field</str>
+ <str name="prompt">Summarize this content: {string_field}</str>
+ <str name="model">dummy-1</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentMultiField">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="inputField">body_field</str>
+ <str name="outputField">processor_output_field</str>
+ <str name="prompt">Title: {string_field}. Body: {body_field}.</str>
+ <str name="model">dummy-1</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentMultivaluedString">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">processor_output_field_multi</str>
+ <str name="prompt">Extract tags from: {string_field}</str>
+ <str name="model">dummy-multivalued-1</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="failingDocumentEnrichmentMultiField">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="inputField">body_field</str>
+ <str name="outputField">processor_output_field</str>
+ <str name="prompt">Title: {string_field}. Body: {body_field}.</str>
+ <str name="model">exception-throwing-model</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentSingleLong">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_long</str>
+ <str name="prompt">Extract a number from: {string_field}</str>
+ <str name="model">dummy-long</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentSingleInt">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_int</str>
+ <str name="prompt">Extract a number from: {string_field}</str>
+ <str name="model">dummy-int</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentSingleFloat">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_float</str>
+ <str name="prompt">Extract a number from: {string_field}</str>
+ <str name="model">dummy-float</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentSingleDouble">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_double</str>
+ <str name="prompt">Extract a number from: {string_field}</str>
+ <str name="model">dummy-double</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentSingleBoolean">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_boolean</str>
+ <str name="prompt">Is this true or false: {string_field}</str>
+ <str name="model">dummy-boolean</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentSingleDate">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_date</str>
+ <str name="prompt">Extract a date from: {string_field}</str>
+ <str name="model">dummy-date</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentMultivaluedLong">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_long_multi</str>
+ <str name="prompt">Extract numbers from: {string_field}</str>
+ <str name="model">dummy-long-multi</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentMultivaluedInt">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_int_multi</str>
+ <str name="prompt">Extract numbers from: {string_field}</str>
+ <str name="model">dummy-int-multi</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentMultivaluedFloat">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_float_multi</str>
+ <str name="prompt">Extract numbers from: {string_field}</str>
+ <str name="model">dummy-float-multi</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentMultivaluedDouble">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_double_multi</str>
+ <str name="prompt">Extract numbers from: {string_field}</str>
+ <str name="model">dummy-double-multi</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentMultivaluedBoolean">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_boolean_multi</str>
+ <str name="prompt">Extract boolean values from: {string_field}</str>
+ <str name="model">dummy-boolean-multi</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentMultivaluedDate">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">output_date_multi</str>
+ <str name="prompt">Extract dates from: {string_field}</str>
+ <str name="model">dummy-date-multi</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+ <updateRequestProcessorChain name="documentEnrichmentMultivaluedInput">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">tags_field</str>
+ <str name="outputField">processor_output_field</str>
+ <str name="prompt">Classify these tags: {tags_field}</str>
+ <str name="model">dummy-1</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+
+</config>
diff --git a/solr/modules/language-models/src/test/org/apache/solr/languagemodels/TestLanguageModelBase.java b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/TestLanguageModelBase.java
index 433d019a076..99d241fdde5 100644
--- a/solr/modules/language-models/src/test/org/apache/solr/languagemodels/TestLanguageModelBase.java
+++ b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/TestLanguageModelBase.java
@@ -26,6 +26,7 @@ import java.util.Arrays;
import java.util.List;
import org.apache.commons.io.file.PathUtils;
import org.apache.solr.common.SolrInputDocument;
+import org.apache.solr.languagemodels.store.rest.LargeLanguageModelStore;
import org.apache.solr.languagemodels.store.rest.TextToVectorModelStore;
import org.apache.solr.util.RestTestBase;
import org.slf4j.Logger;
@@ -40,10 +41,13 @@ public class TestLanguageModelBase extends RestTestBase {
public static final String TEXT_TO_VECTOR_MODEL_FILE_NAME =
"_schema_text-to-vector-model-store.json";
+ public static final String LARGE_LANGUAGE_MODEL_FILE_NAME =
+ "_schema_large-language-model-store.json";
protected static final String COLLECTION = "collection1";
protected static final String CONF_DIR = COLLECTION + "/conf";
protected static Path textToVectorModelStoreFile = null;
+ protected static Path largeLanguageModelStoreFile = null;
protected static String IDField = "id";
protected static String vectorField = "vector";
@@ -62,10 +66,12 @@ public class TestLanguageModelBase extends RestTestBase {
tmpSolrHome = createTempDir();
tmpConfDir = tmpSolrHome.resolve(CONF_DIR);
PathUtils.copyDirectory(TEST_PATH(), tmpSolrHome.toAbsolutePath());
+ final Path largeLanguageModelStore = tmpConfDir.resolve(LARGE_LANGUAGE_MODEL_FILE_NAME);
final Path textToVectorModelStore = tmpConfDir.resolve(TEXT_TO_VECTOR_MODEL_FILE_NAME);
if (isPersistent) {
textToVectorModelStoreFile = textToVectorModelStore;
+ largeLanguageModelStoreFile = largeLanguageModelStore;
}
if (Files.exists(textToVectorModelStore)) {
@@ -75,6 +81,17 @@ public class TestLanguageModelBase extends RestTestBase {
Files.delete(textToVectorModelStore);
}
+ if (Files.exists(largeLanguageModelStore)) {
+
+ if (log.isInfoEnabled()) {
+ log.info(
+ "remove large language model store config file in {}",
+ largeLanguageModelStore.toAbsolutePath());
+ }
+
+ Files.delete(largeLanguageModelStore);
+ }
+
System.setProperty("managed.schema.mutable", "true");
}
@@ -104,6 +121,35 @@ public class TestLanguageModelBase extends RestTestBase {
assertJPut(TextToVectorModelStore.REST_END_POINT, multipleModels, "/responseHeader/status==0");
}
+ public static void loadLargeLanguageModel(String fileName, String status) throws Exception {
+ final URL url =
+ TestLanguageModelBase.class.getResource("/largeLanguageModelExamples/" + fileName);
+ final String model = Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8);
+
+ assertJPut(LargeLanguageModelStore.REST_END_POINT, model, "/responseHeader/status==" + status);
+ }
+
+ public static void loadLargeLanguageModel(String fileName, String status, String message)
+ throws Exception {
+ final URL url =
+ TestLanguageModelBase.class.getResource("/largeLanguageModelExamples/" + fileName);
+ final String model = Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8);
+
+ assertJPut(
+ LargeLanguageModelStore.REST_END_POINT,
+ model,
+ "/responseHeader/status==" + status,
+ message);
+ }
+
+ public static void loadLargeLanguageModel(String fileName) throws Exception {
+ final URL url =
+ TestLanguageModelBase.class.getResource("/largeLanguageModelExamples/" + fileName);
+ final String model = Files.readString(Path.of(url.toURI()), StandardCharsets.UTF_8);
+
+ assertJPut(LargeLanguageModelStore.REST_END_POINT, model, "/responseHeader/status==0");
+ }
+
protected static void prepareIndex() throws Exception {
List<SolrInputDocument> docsToIndex = prepareDocs();
for (SolrInputDocument doc : docsToIndex) {
diff --git a/solr/modules/language-models/src/test/org/apache/solr/languagemodels/model/DummyChatModel.java b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/model/DummyChatModel.java
new file mode 100644
index 00000000000..89feb4b59e6
--- /dev/null
+++ b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/model/DummyChatModel.java
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.languagemodels.model;
+
+import dev.langchain4j.data.message.AiMessage;
+import dev.langchain4j.data.message.UserMessage;
+import dev.langchain4j.model.chat.ChatModel;
+import dev.langchain4j.model.chat.request.ChatRequest;
+import dev.langchain4j.model.chat.response.ChatResponse;
+
+/**
+ * A deterministic {@link ChatModel} for testing. It returns a fixed response string regardless of
+ * the input, allowing tests to assert exact enriched-field values without real API calls.
+ *
+ * <p>The builder also exposes {@code unsupported} and {@code ambiguous} setter methods to exercise
+ * the reflection-based parameter handling in {@link SolrLargeLanguageModel#getInstance}.
+ */
+public class DummyChatModel implements ChatModel {
+
+ /** The text of the last prompt received by any instance. Useful for test assertions. */
+ public static String lastReceivedPrompt;
+
+ private final String response;
+
+ public DummyChatModel(String response) {
+ this.response = response;
+ }
+
+ @Override
+ public ChatResponse chat(ChatRequest chatRequest) {
+ lastReceivedPrompt = ((UserMessage) chatRequest.messages().getFirst()).singleText();
+ return ChatResponse.builder().aiMessage(AiMessage.from(response)).build();
+ }
+
+ public static DummyChatModelBuilder builder() {
+ return new DummyChatModelBuilder();
+ }
+
+ public static class DummyChatModelBuilder {
+ private String response = "dummy response";
+ private int intValue;
+
+ public DummyChatModelBuilder() {}
+
+ public DummyChatModelBuilder response(String response) {
+ this.response = response;
+ return this;
+ }
+
+ /** Intentionally has no String overload so the reflection code raises a BAD_REQUEST error. */
+ public DummyChatModelBuilder unsupportedParam(Integer input) {
+ return this;
+ }
+
+ /** Two overloads make this param "ambiguous": the reflection code should default to String. */
+ public DummyChatModelBuilder ambiguousTypeParam(int input) {
+ this.intValue = input;
+ return this;
+ }
+
+ public DummyChatModelBuilder ambiguousTypeParam(String input) {
+ this.intValue = Integer.valueOf(input);
+ return this;
+ }
+
+ public DummyChatModel build() {
+ return new DummyChatModel(this.response);
+ }
+ }
+}
diff --git a/solr/modules/language-models/src/test/org/apache/solr/languagemodels/model/DummyChatModelTest.java b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/model/DummyChatModelTest.java
new file mode 100644
index 00000000000..70cd5d8e7a9
--- /dev/null
+++ b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/model/DummyChatModelTest.java
@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.languagemodels.model;
+
+import dev.langchain4j.data.message.UserMessage;
+import dev.langchain4j.model.chat.request.ChatRequest;
+import org.apache.solr.SolrTestCase;
+import org.junit.Test;
+
+public class DummyChatModelTest extends SolrTestCase {
+
+ @Test
+ public void constructAndChat() throws Exception {
+ assertEquals(
+ "hello world",
+ new DummyChatModel("hello world")
+ .chat(ChatRequest.builder().messages(UserMessage.from("any input")).build())
+ .aiMessage()
+ .text());
+ assertEquals(
+ "fixed response",
+ new DummyChatModel("fixed response")
+ .chat(ChatRequest.builder().messages(UserMessage.from("another input")).build())
+ .aiMessage()
+ .text());
+ assertEquals(
+ "dummy response",
+ DummyChatModel.builder()
+ .build()
+ .chat(ChatRequest.builder().messages(UserMessage.from("default")).build())
+ .aiMessage()
+ .text());
+ }
+}
diff --git a/solr/modules/language-models/src/test/org/apache/solr/languagemodels/model/ExceptionThrowingChatModel.java b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/model/ExceptionThrowingChatModel.java
new file mode 100644
index 00000000000..0873b8ced42
--- /dev/null
+++ b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/model/ExceptionThrowingChatModel.java
@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.languagemodels.model;
+
+import dev.langchain4j.model.chat.ChatModel;
+import dev.langchain4j.model.chat.request.ChatRequest;
+import dev.langchain4j.model.chat.response.ChatResponse;
+
+/**
+ * A {@link ChatModel} that always throws a {@link RuntimeException}. Used to verify that {@link
+ * org.apache.solr.languagemodels.update.processor.DocumentEnrichmentUpdateProcessor} handles
+ * chat-model failures gracefully (logs the error and continues indexing without the enriched
+ * field).
+ */
+public class ExceptionThrowingChatModel implements ChatModel {
+
+ @Override
+ public ChatResponse chat(ChatRequest chatRequest) {
+ throw new RuntimeException("Failed to enrich");
+ }
+
+ public static ExceptionThrowingChatModelBuilder builder() {
+ return new ExceptionThrowingChatModelBuilder();
+ }
+
+ public static class ExceptionThrowingChatModelBuilder {
+
+ public ExceptionThrowingChatModelBuilder() {}
+
+ public ExceptionThrowingChatModel build() {
+ return new ExceptionThrowingChatModel();
+ }
+ }
+}
diff --git a/solr/modules/language-models/src/test/org/apache/solr/languagemodels/store/rest/TestLargeLanguageModelManager.java b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/store/rest/TestLargeLanguageModelManager.java
new file mode 100644
index 00000000000..bb785d90719
--- /dev/null
+++ b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/store/rest/TestLargeLanguageModelManager.java
@@ -0,0 +1,245 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.languagemodels.store.rest;
+
+import org.apache.solr.common.util.NamedList;
+import org.apache.solr.core.SolrResourceLoader;
+import org.apache.solr.languagemodels.TestLanguageModelBase;
+import org.apache.solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory;
+import org.apache.solr.rest.ManagedResource;
+import org.apache.solr.rest.ManagedResourceStorage;
+import org.apache.solr.rest.RestManager;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class TestLargeLanguageModelManager extends TestLanguageModelBase {
+
+ @BeforeClass
+ public static void init() throws Exception {
+ setupTest("solrconfig-document-enrichment.xml", "schema-language-models.xml", false, false);
+ }
+
+ @AfterClass
+ public static void cleanup() throws Exception {
+ afterTest();
+ }
+
+ @Test
+ public void test() throws Exception {
+ final SolrResourceLoader loader = new SolrResourceLoader(tmpSolrHome);
+
+ final RestManager.Registry registry = loader.getManagedResourceRegistry();
+ assertNotNull(
+ "Expected a non-null RestManager.Registry from the SolrResourceLoader!", registry);
+
+ final String resourceId = "/schema/mstore1";
+ registry.registerManagedResource(
+ resourceId, LargeLanguageModelStore.class, new DocumentEnrichmentUpdateProcessorFactory());
+
+ final NamedList<String> initArgs = new NamedList<>();
+
+ final RestManager restManager = new RestManager();
+ restManager.init(loader, initArgs, new ManagedResourceStorage.InMemoryStorageIO());
+
+ final ManagedResource res = restManager.getManagedResource(resourceId);
+ assertTrue(res instanceof LargeLanguageModelStore);
+ assertEquals(res.getResourceId(), resourceId);
+ }
+
+ @Test
+ public void testRestManagerEndpoints() throws Exception {
+ assertJQ("/schema/managed", "/responseHeader/status==0");
+
+ final String openAiClassName = "dev.langchain4j.model.openai.OpenAiChatModel";
+
+ // success
+ String model =
+ "{ name:\"test-model-1\", class:\""
+ + openAiClassName
+ + "\","
+ + "params:{"
+ + "baseUrl:\"https://api.openai.com/v1\","
+ + "apiKey:\"testApiKey2\","
+ + "modelName:\"gpt-4o-mini\","
+ + "logRequests:true,"
+ + "logResponses:false"
+ + "}}";
+ assertJPut(LargeLanguageModelStore.REST_END_POINT, model, "/responseHeader/status==0");
+
+ // success — multiple models in one PUT
+ final String multipleModels =
+ "[{ name:\"test-model-2\", class:\""
+ + openAiClassName
+ + "\","
+ + "params:{baseUrl:\"https://api.openai.com/v1\","
+ + "apiKey:\"testApiKey3\","
+ + "modelName:\"gpt-4o-mini\","
+ + "logRequests:true,"
+ + "logResponses:false"
+ + "}}\n"
+ + ",{ name:\"test-model-3\", class:\""
+ + openAiClassName
+ + "\","
+ + "params:{baseUrl:\"https://api.openai.com/v1\","
+ + "apiKey:\"testApiKey4\","
+ + "modelName:\"gpt-4o-mini\","
+ + "logRequests:true,"
+ + "logResponses:false"
+ + "}}]";
+ assertJPut(LargeLanguageModelStore.REST_END_POINT, multipleModels, "/responseHeader/status==0");
+
+ final String qryResult = JQ(LargeLanguageModelStore.REST_END_POINT);
+ assertTrue(
+ qryResult.contains("\"name\":\"test-model-1\"")
+ && qryResult.contains("\"name\":\"test-model-2\"")
+ && qryResult.contains("\"name\":\"test-model-3\""));
+
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/name=='test-model-1'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[1]/name=='test-model-2'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[2]/name=='test-model-3'");
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/test-model-1");
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/test-model-2");
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/test-model-3");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models==[]");
+ }
+
+ @Test
+ public void loadLargeLanguageModel_openAi_shouldLoadModelConfig() throws Exception {
+ loadLargeLanguageModel("openai-model.json");
+
+ final String modelName = "openai-1";
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/name=='" + modelName + "'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT,
+ "/models/[0]/params/baseUrl=='https://api.openai.com/v1'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/apiKey=='apiKey-openAI'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/modelName=='gpt-5.4-nano'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/timeout==60");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logRequests==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logResponses==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/maxRetries==5");
+
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/" + modelName);
+ }
+
+ @Test
+ public void loadLargeLanguageModel_mistralAi_shouldLoadModelConfig() throws Exception {
+ loadLargeLanguageModel("mistralai-model.json");
+
+ final String modelName = "mistralai-1";
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/name=='" + modelName + "'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT,
+ "/models/[0]/params/baseUrl=='https://api.mistral.ai/v1'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/apiKey=='apiKey-mistralAI'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT,
+ "/models/[0]/params/modelName=='mistral-small-latest'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/timeout==60");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logRequests==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logResponses==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/maxRetries==5");
+
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/" + modelName);
+ }
+
+ @Test
+ public void loadLargeLanguageModel_anthropic_shouldLoadModelConfig() throws Exception {
+ loadLargeLanguageModel("anthropic-model.json");
+
+ final String modelName = "anthropic-1";
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/name=='" + modelName + "'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT,
+ "/models/[0]/params/baseUrl=='https://api.anthropic.com/v1'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/apiKey=='apiKey-anthropic'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT,
+ "/models/[0]/params/modelName=='claude-3-5-haiku-latest'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/timeout==60");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logRequests==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logResponses==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/maxRetries==5");
+
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/" + modelName);
+ }
+
+ @Test
+ public void loadLargeLanguageModel_ollama_shouldLoadModelConfig() throws Exception {
+ loadLargeLanguageModel("ollama-model.json");
+
+ final String modelName = "ollama-1";
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/name=='" + modelName + "'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT,
+ "/models/[0]/params/baseUrl=='http://localhost:11434'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/modelName=='llama3.2'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/timeout==60");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logRequests==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logResponses==true");
+
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/" + modelName);
+ }
+
+ @Test
+ public void loadLargeLanguageModel_gemini_shouldLoadModelConfig() throws Exception {
+ loadLargeLanguageModel("gemini-model.json");
+
+ final String modelName = "gemini-1";
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/name=='" + modelName + "'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/apiKey=='apiKey-gemini'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/modelName=='gemini-2.0-flash'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/timeout==60");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logRequests==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logResponses==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/maxRetries==5");
+
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/" + modelName);
+ }
+
+ @Test
+ public void loadLargeLanguageModel_dummyUnsupportedParam_shouldRaiseError() throws Exception {
+ loadLargeLanguageModel(
+ "dummy-model-unsupported.json",
+ "400",
+ "/error/msg=='org.apache.solr.languagemodels.LanguageModelException: Model loading failed for org.apache.solr.languagemodels.model.DummyChatModel'");
+ }
+
+ @Test
+ public void loadLargeLanguageModel_notAChatModel_shouldRaiseError() throws Exception {
+ loadLargeLanguageModel(
+ "not-a-chat-model.json",
+ "400",
+ "/error/msg=='org.apache.solr.languagemodels.LanguageModelException: Model loading failed for com.example.NonExistentChatModel'");
+ }
+
+ @Test
+ public void loadLargeLanguageModel_dummyAmbiguousParam_shouldDefaultToString() throws Exception {
+ loadLargeLanguageModel("dummy-model-ambiguous.json");
+
+ final String modelName = "dummy-1";
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/name=='" + modelName + "'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/ambiguousTypeParam==10");
+
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/" + modelName);
+ }
+}
diff --git a/solr/modules/language-models/src/test/org/apache/solr/languagemodels/store/rest/TestLargeLanguageModelManagerPersistence.java b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/store/rest/TestLargeLanguageModelManagerPersistence.java
new file mode 100644
index 00000000000..9d9e4084dac
--- /dev/null
+++ b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/store/rest/TestLargeLanguageModelManagerPersistence.java
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.languagemodels.store.rest;
+
+import org.apache.solr.languagemodels.TestLanguageModelBase;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class TestLargeLanguageModelManagerPersistence extends TestLanguageModelBase {
+
+ @Before
+ public void init() throws Exception {
+ setupTest("solrconfig-document-enrichment.xml", "schema-language-models.xml", false, true);
+ }
+
+ @After
+ public void cleanup() throws Exception {
+ afterTest();
+ }
+
+ @Test
+ public void testLargeLanguageModelStorePersistence() throws Exception {
+ // check store is empty at start
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/==[]");
+
+ // load a model
+ loadLargeLanguageModel("openai-model.json");
+
+ final String modelName = "openai-1";
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/name=='" + modelName + "'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT,
+ "/models/[0]/params/baseUrl=='https://api.openai.com/v1'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/apiKey=='apiKey-openAI'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/modelName=='gpt-5.4-nano'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/timeout==60");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logRequests==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logResponses==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/maxRetries==5");
+
+ // check persistence after reload
+ restTestHarness.reload();
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/name=='" + modelName + "'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT,
+ "/models/[0]/params/baseUrl=='https://api.openai.com/v1'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/apiKey=='apiKey-openAI'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/modelName=='gpt-5.4-nano'");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/timeout==60");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logRequests==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/logResponses==true");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/maxRetries==5");
+
+ // check persistence after restart
+ restartJetty();
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/[0]/name=='" + modelName + "'");
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT, "/models/[0]/params/modelName=='gpt-5.4-nano'");
+
+ // delete model and verify persistence of the empty state
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/" + modelName);
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/==[]");
+
+ restTestHarness.reload();
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/==[]");
+
+ restartJetty();
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models/==[]");
+ }
+}
diff --git a/solr/modules/language-models/src/test/org/apache/solr/languagemodels/store/rest/TestLargeLanguageModelStoreInitialization.java b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/store/rest/TestLargeLanguageModelStoreInitialization.java
new file mode 100644
index 00000000000..d95aa7034bd
--- /dev/null
+++ b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/store/rest/TestLargeLanguageModelStoreInitialization.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.languagemodels.store.rest;
+
+import org.apache.solr.languagemodels.TestLanguageModelBase;
+import org.junit.After;
+import org.junit.Test;
+
+public class TestLargeLanguageModelStoreInitialization extends TestLanguageModelBase {
+
+ @After
+ public void cleanUp() throws Exception {
+ afterTest();
+ }
+
+ @Test
+ public void largeLanguageModelStore_whenUpdateRequestComponentConfigured_shouldBeInitialized()
+ throws Exception {
+ setupTest("solrconfig-document-enrichment.xml", "schema-language-models.xml", false, false);
+
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/responseHeader/status==0");
+ assertJQ(LargeLanguageModelStore.REST_END_POINT, "/models==[]");
+ }
+
+ /*
+ * This test verifies that the LargeLanguageModelStore REST managed resource is not registered when the Solr core has
+ * no component that needs it.
+ * LargeLanguageModelStore isn't wired up unconditionally — it's registered on demand by
+ * DocumentEnrichmentUpdateProcessorFactory.inform() (DocumentEnrichmentUpdateProcessorFactory.java:165), which
+ * calls LargeLanguageModelStore.registerManagedLargeLanguageModelStore(...).
+ * That factory only gets instantiated if a solrconfig.xml actually declares an updateRequestProcessorChain using it.
+ */
+ @Test
+ public void largeLanguageModelStore_whenNoUpdateRequestProcessorChain_shouldNotBeInitialized()
+ throws Exception {
+ setupTest(
+ "solrconfig-language-models-no-components.xml", "schema-language-models.xml", false, false);
+ assertJQ(
+ LargeLanguageModelStore.REST_END_POINT,
+ "/responseHeader/status==400",
+ "/error/msg=='No REST managed resource registered for path "
+ + LargeLanguageModelStore.REST_END_POINT
+ + "'");
+ }
+}
diff --git a/solr/modules/language-models/src/test/org/apache/solr/languagemodels/update/processor/DocumentEnrichmentUpdateProcessorTest.java b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/update/processor/DocumentEnrichmentUpdateProcessorTest.java
new file mode 100644
index 00000000000..bc7838d7e8b
--- /dev/null
+++ b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/update/processor/DocumentEnrichmentUpdateProcessorTest.java
@@ -0,0 +1,811 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.languagemodels.update.processor;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.solr.client.solrj.RemoteSolrException;
+import org.apache.solr.client.solrj.SolrServerException;
+import org.apache.solr.client.solrj.request.SolrQuery;
+import org.apache.solr.client.solrj.request.UpdateRequest;
+import org.apache.solr.common.SolrInputDocument;
+import org.apache.solr.common.util.Utils;
+import org.apache.solr.languagemodels.TestLanguageModelBase;
+import org.apache.solr.languagemodels.model.DummyChatModel;
+import org.apache.solr.languagemodels.store.rest.LargeLanguageModelStore;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class DocumentEnrichmentUpdateProcessorTest extends TestLanguageModelBase {
+
+ @BeforeClass
+ public static void init() throws Exception {
+ setupTest("solrconfig-document-enrichment.xml", "schema-language-models.xml", false, false);
+ }
+
+ @AfterClass
+ public static void cleanup() throws Exception {
+ afterTest();
+ }
+
+ private String loadedModelId;
+ private final String processorOutputField = "processor_output_field";
+ private final String processorOutputFieldMulti = "processor_output_field_multi";
+ private final String processorOutputFieldValue = "enriched content";
+
+ @After
+ public void afterEachTest() throws Exception {
+ if (loadedModelId != null) {
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/" + loadedModelId);
+ loadedModelId = null;
+ }
+ }
+
+ private void loadTestLargeLanguageModel(String fileName, String modelId) throws Exception {
+ loadLargeLanguageModel(fileName);
+ loadedModelId = modelId;
+ }
+
+ private void loadDummyLargeLanguageModel(String modelId, String response) throws Exception {
+ Map<String, Object> model = new LinkedHashMap<>();
+ model.put("class", "org.apache.solr.languagemodels.model.DummyChatModel");
+ model.put("name", modelId);
+ model.put("params", Map.of("response", response));
+ assertJPut(
+ LargeLanguageModelStore.REST_END_POINT,
+ Utils.toJSONString(model),
+ "/responseHeader/status==0");
+ loadedModelId = modelId;
+ }
+
+ @Test
+ public void processAdd_inputField_shouldEnrichInputField() throws Exception {
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+
+ addWithChain(
+ sdoc("id", "99", "string_field", "Vegeta is the saiyan prince."), "documentEnrichment");
+ addWithChain(
+ sdoc("id", "98", "string_field", "Kakaroth is a saiyan grown up on planet Earth."),
+ "documentEnrichment");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/" + processorOutputField + "=='" + processorOutputFieldValue + "'",
+ "/response/docs/[1]/id=='98'",
+ "/response/docs/[1]/" + processorOutputField + "=='" + processorOutputFieldValue + "'");
+ }
+
+ /*
+ This test looks for the 'dummy-1' model, but such model is not loaded —
+ the model store is empty, so the update fails.
+ */
+ @Test
+ public void processAdd_modelNotFound_shouldThrowException() {
+ RuntimeException thrown =
+ assertThrows(
+ "model not found should throw an exception",
+ RemoteSolrException.class,
+ () ->
+ addWithChain(
+ sdoc("id", "99", "string_field", "Vegeta is the saiyan prince."),
+ "documentEnrichment"));
+ assertTrue(
+ thrown
+ .getMessage()
+ .contains(
+ "The model configured in the Update Request Processor 'dummy-1' can't be found in the store: /schema/large-language-model-store"));
+ }
+
+ @Test
+ public void processAdd_emptyInputField_shouldLogAndIndexWithNoEnrichedField() throws Exception {
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+ addWithChain(sdoc("id", "99", "string_field", ""), "documentEnrichment");
+ addWithChain(
+ sdoc("id", "98", "string_field", "Vegeta is the saiyan prince."), "documentEnrichment");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/" + processorOutputField + "==", // no enriched field for doc 99
+ "/response/docs/[1]/id=='98'",
+ "/response/docs/[1]/" + processorOutputField + "=='" + processorOutputFieldValue + "'");
+ }
+
+ @Test
+ public void processAdd_nullInputField_shouldLogAndIndexWithNoEnrichedField() throws Exception {
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+ addWithChain(
+ sdoc("id", "99", "string_field", "Vegeta is the saiyan prince."), "documentEnrichment");
+ assertU(adoc("id", "98")); // no string_field
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/" + processorOutputField + "=='" + processorOutputFieldValue + "'",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputField + "=="); // no enriched field for doc 98
+ }
+
+ @Test
+ public void processAdd_failingEnrichment_shouldLogAndIndexWithNoEnrichedField() throws Exception {
+ loadTestLargeLanguageModel("exception-throwing-model.json", "exception-throwing-model");
+ addWithChain(
+ sdoc("id", "99", "string_field", "Vegeta is the saiyan prince."),
+ "failingDocumentEnrichment");
+ addWithChain(
+ sdoc("id", "98", "string_field", "Kakaroth is a saiyan grown up on planet Earth."),
+ "failingDocumentEnrichment");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/" + processorOutputField + "==", // no enriched field for doc 99
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputField + "=="); // no enriched field for doc 98
+ }
+
+ @Test
+ public void processAtomicUpdate_shouldTriggerEnrichmentAndFetchTheStoredContent()
+ throws Exception {
+ // Verifies that when using a processor chain configured for partial updates
+ // (i.e., DistributedUpdateProcessorFactory before DocumentEnrichmentUpdateProcessorFactory),
+ // the system correctly retrieves the stored value of string_field and generates the
+ // enriched content for the document.
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+ assertU(adoc("id", "99", "string_field", "Vegeta is the saiyan prince."));
+ assertU(adoc("id", "98", "string_field", "Kakaroth is a saiyan grown up on planet Earth."));
+ assertU(commit());
+
+ SolrInputDocument atomicDoc = new SolrInputDocument();
+ atomicDoc.setField("id", "99");
+ atomicDoc.setField("enriched", Map.of("set", true));
+ addWithChain(atomicDoc, "documentEnrichmentForPartialUpdates");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/" + processorOutputField + "=='" + processorOutputFieldValue + "'",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputField + "==" // no enriched field for document 98
+ );
+ }
+
+ @Test
+ public void processAtomicUpdate_shouldReplaceExistingEnrichedFieldNotAppend() throws Exception {
+ // Verifies that when a document already contains an processorOutputField and string_field is
+ // modified via atomic update, the enriched content is recomputed and replaces the previous
+ // value rather than being appended.
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+ assertU(
+ adoc(
+ "id",
+ "99",
+ "string_field",
+ "Vegeta is the saiyan prince.",
+ processorOutputField,
+ "old content"));
+ addWithChain(
+ sdoc("id", "98", "string_field", "Kakaroth is a saiyan grown up on planet Earth."),
+ "documentEnrichment");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/" + processorOutputField + "=='old content'",
+ "/response/docs/[1]/id=='98'",
+ "/response/docs/[1]/" + processorOutputField + "=='" + processorOutputFieldValue + "'");
+
+ SolrInputDocument atomicDoc = new SolrInputDocument();
+ atomicDoc.setField("id", "99");
+ atomicDoc.setField(
+ "string_field", Map.of("set", "Vegeta is the saiyan prince from the Dragon Ball series."));
+ addWithChain(atomicDoc, "documentEnrichmentForPartialUpdates");
+ assertU(commit());
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/" + processorOutputField + "=='" + processorOutputFieldValue + "'",
+ "/response/docs/[1]/id=='98'",
+ "/response/docs/[1]/" + processorOutputField + "=='" + processorOutputFieldValue + "'");
+ }
+
+ // --- multi-field tests ---
+
+ @Test
+ public void processAdd_arrInputField_shouldEnrichDocument() throws Exception {
+ // Verifies that <arr name="inputField"> in solrconfig behaves identically to
+ // multiple <str name="inputField"> entries — both are accepted by removeConfigArgs.
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+
+ DummyChatModel.lastReceivedPrompt = null;
+
+ addWithChain(
+ sdoc(
+ "id",
+ "99",
+ "string_field",
+ "Vegeta is the saiyan prince.",
+ "body_field",
+ "He is very proud."),
+ "documentEnrichmentArrInputField");
+ addWithChain(
+ sdoc(
+ "id",
+ "98",
+ "string_field",
+ "Kakaroth is a saiyan.",
+ "body_field",
+ "He grew up on Earth."),
+ "documentEnrichmentArrInputField");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/" + processorOutputField + "=='" + processorOutputFieldValue + "'",
+ "/response/docs/[1]/id=='98'",
+ "/response/docs/[1]/" + processorOutputField + "=='" + processorOutputFieldValue + "'");
+ }
+
+ @Test
+ public void processAdd_multipleInputFields_allPresent_shouldEnrichDocumentWithBothFields()
+ throws Exception {
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+
+ DummyChatModel.lastReceivedPrompt = null;
+
+ addWithChain(
+ sdoc(
+ "id",
+ "99",
+ "string_field",
+ "Vegeta is the saiyan prince.",
+ "body_field",
+ "He is very proud."),
+ "documentEnrichmentMultiField");
+ addWithChain(
+ sdoc(
+ "id",
+ "98",
+ "string_field",
+ "Kakaroth is a saiyan.",
+ "body_field",
+ "He grew up on Earth."),
+ "documentEnrichmentMultiField");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/" + processorOutputField + "=='" + processorOutputFieldValue + "'",
+ "/response/docs/[1]/id=='98'",
+ "/response/docs/[1]/" + processorOutputField + "=='" + processorOutputFieldValue + "'");
+
+ // Verify both placeholders were substituted
+ assertEquals(
+ "Title: Kakaroth is a saiyan.. Body: He grew up on Earth..",
+ DummyChatModel.lastReceivedPrompt);
+ }
+
+ @Test
+ public void processAdd_multipleInputFields_firstFieldNull_shouldSkipEnrichment()
+ throws Exception {
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+
+ addWithChain(
+ sdoc("id", "99", "body_field", "He is very proud."), // string_field absent
+ "documentEnrichmentMultiField");
+ addWithChain(
+ sdoc("id", "98", "body_field", "He is very jealous."), // string_field absent
+ "documentEnrichmentMultiField");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/" + processorOutputField + "==",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputField + "==");
+ }
+
+ @Test
+ public void processAdd_multipleInputFields_secondFieldEmpty_shouldSkipEnrichment()
+ throws Exception {
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+
+ addWithChain(
+ sdoc("id", "99", "string_field", "Vegeta is the saiyan prince.", "body_field", ""),
+ "documentEnrichmentMultiField");
+ addWithChain(
+ sdoc("id", "98", "string_field", "Goku is the best saiyan.", "body_field", ""),
+ "documentEnrichmentMultiField");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/" + processorOutputField + "==",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputField + "==");
+ }
+
+ @Test
+ public void processAdd_multipleInputFields_bothFieldsAbsent_shouldSkipEnrichment()
+ throws Exception {
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+
+ addWithChain(sdoc("id", "99"), "documentEnrichmentMultiField");
+ addWithChain(sdoc("id", "98"), "documentEnrichmentMultiField");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/" + processorOutputField + "==",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputField + "==");
+ }
+
+ @Test
+ public void processAdd_multipleInputFields_failingModel_shouldLogAndSkipEnrichment()
+ throws Exception {
+ loadTestLargeLanguageModel("exception-throwing-model.json", "exception-throwing-model");
+
+ addWithChain(
+ sdoc(
+ "id",
+ "99",
+ "string_field",
+ "Vegeta is the saiyan prince.",
+ "body_field",
+ "He is very proud."),
+ "failingDocumentEnrichmentMultiField");
+ addWithChain(
+ sdoc(
+ "id",
+ "98",
+ "string_field",
+ "Kakaroth is a saiyan.",
+ "body_field",
+ "He grew up on Earth."),
+ "failingDocumentEnrichmentMultiField");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/" + processorOutputField + "==",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputField + "==");
+ }
+
+ @Test
+ public void processAdd_multivaluedInputField_shouldInterpolateCollectionAndEnrichDocument()
+ throws Exception {
+ // When an input field is multivalued, SolrInputField.getValue() returns the Collection,
+ // whose toString() is used for prompt interpolation (e.g. "[tag1, tag2, tag3]").
+ // Enrichment must proceed — the collection is non-null and non-empty.
+ loadTestLargeLanguageModel("dummy-model.json", "dummy-1");
+
+ DummyChatModel.lastReceivedPrompt = null;
+
+ addWithChain(sdoc("id", "98", "tags_field", "tag1"), "documentEnrichmentMultivaluedInput");
+
+ SolrInputDocument doc = new SolrInputDocument();
+ doc.addField("id", "99");
+ doc.addField("tags_field", "tag1");
+ doc.addField("tags_field", "tag2");
+ doc.addField("tags_field", "tag3");
+ addWithChain(doc, "documentEnrichmentMultivaluedInput");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/" + processorOutputField + "=='" + processorOutputFieldValue + "'",
+ "/response/docs/[1]/id=='98'",
+ "/response/docs/[1]/" + processorOutputField + "=='" + processorOutputFieldValue + "'");
+
+ assertEquals("Classify these tags: [tag1, tag2, tag3]", DummyChatModel.lastReceivedPrompt);
+ }
+
+ @Test
+ public void processAdd_multivaluedStringOutputField_emptyInput_shouldSkipEnrichment()
+ throws Exception {
+ loadDummyLargeLanguageModel("dummy-multivalued-1", "{\"value\": [\"tag1\", \"tag2\"]}");
+
+ addWithChain(sdoc("id", "99", "string_field", ""), "documentEnrichmentMultivaluedString");
+ addWithChain(sdoc("id", "98", "string_field", ""), "documentEnrichmentMultivaluedString");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputFieldMulti);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/" + processorOutputFieldMulti + "==",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputFieldMulti + "==");
+ }
+
+ // --- typed single-valued output field tests ---
+
+ @Test
+ public void processAdd_singleTypedOutputField_shouldPopulateValue() throws Exception {
+ record TypedCase(
+ String modelId, String response, String chain, String field, String expectedValue) {}
+ List<TypedCase> typedCases =
+ List.of(
+ new TypedCase(
+ "dummy-long",
+ "{\"value\": 3000000000}",
+ "documentEnrichmentSingleLong",
+ "output_long",
+ "3000000000"),
+ new TypedCase(
+ "dummy-int", "{\"value\": 7}", "documentEnrichmentSingleInt", "output_int", "7"),
+ new TypedCase(
+ "dummy-float",
+ "{\"value\": 1.5}",
+ "documentEnrichmentSingleFloat",
+ "output_float",
+ "1.5"),
+ new TypedCase(
+ "dummy-double",
+ "{\"value\": 1e308}",
+ "documentEnrichmentSingleDouble",
+ "output_double",
+ "1e308"),
+ new TypedCase(
+ "dummy-boolean",
+ "{\"value\": true}",
+ "documentEnrichmentSingleBoolean",
+ "output_boolean",
+ "true"),
+ new TypedCase(
+ "dummy-date",
+ "{\"value\": \"2024-01-15T00:00:00Z\"}",
+ "documentEnrichmentSingleDate",
+ "output_date",
+ "'2024-01-15T00:00:00Z'"));
+
+ for (TypedCase typedCase : typedCases) {
+ loadDummyLargeLanguageModel(typedCase.modelId(), typedCase.response());
+ addWithChain(sdoc("id", "99", "string_field", "some content"), typedCase.chain());
+ addWithChain(sdoc("id", "98", "string_field", "other content"), typedCase.chain());
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(typedCase.field());
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/" + typedCase.field() + "==" + typedCase.expectedValue(),
+ "/response/docs/[1]/id=='98'",
+ "/response/docs/[1]/" + typedCase.field() + "==" + typedCase.expectedValue());
+
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/" + typedCase.modelId());
+ loadedModelId = null;
+ }
+ }
+
+ // --- typed multivalued output field tests ---
+
+ @Test
+ public void processAdd_multivaluedTypedOutputField_shouldPopulateAllValues() throws Exception {
+ record TypeCaseMulti(
+ String modelId, String response, String chain, String field, List<String> expectedValues) {}
+ List<TypeCaseMulti> typedCaseMultis =
+ List.of(
+ new TypeCaseMulti(
+ "dummy-multivalued-1",
+ "{\"value\": [\"tag1\", \"tag2\"]}",
+ "documentEnrichmentMultivaluedString",
+ processorOutputFieldMulti,
+ List.of("'tag1'", "'tag2'")),
+ new TypeCaseMulti(
+ "dummy-long-multi",
+ "{\"value\": [1000000000, 2000000000, 3000000000]}",
+ "documentEnrichmentMultivaluedLong",
+ "output_long_multi",
+ List.of("1000000000", "2000000000", "3000000000")),
+ new TypeCaseMulti(
+ "dummy-int-multi",
+ "{\"value\": [1, 2]}",
+ "documentEnrichmentMultivaluedInt",
+ "output_int_multi",
+ List.of("1", "2")),
+ new TypeCaseMulti(
+ "dummy-float-multi",
+ "{\"value\": [1.5, 2.5]}",
+ "documentEnrichmentMultivaluedFloat",
+ "output_float_multi",
+ List.of("1.5", "2.5")),
+ new TypeCaseMulti(
+ "dummy-double-multi",
+ "{\"value\": [1e308, 1.1e308]}",
+ "documentEnrichmentMultivaluedDouble",
+ "output_double_multi",
+ List.of("1e308", "1.1e308")),
+ new TypeCaseMulti(
+ "dummy-boolean-multi",
+ "{\"value\": [true, false]}",
+ "documentEnrichmentMultivaluedBoolean",
+ "output_boolean_multi",
+ List.of("true", "false")),
+ new TypeCaseMulti(
+ "dummy-date-multi",
+ "{\"value\": [\"2024-01-15T00:00:00Z\", \"2025-06-30T00:00:00Z\"]}",
+ "documentEnrichmentMultivaluedDate",
+ "output_date_multi",
+ List.of("'2024-01-15T00:00:00Z'", "'2025-06-30T00:00:00Z'")));
+
+ for (TypeCaseMulti typedCase : typedCaseMultis) {
+ loadDummyLargeLanguageModel(typedCase.modelId(), typedCase.response());
+ addWithChain(sdoc("id", "99", "string_field", "some content"), typedCase.chain());
+ addWithChain(sdoc("id", "98", "string_field", "other content"), typedCase.chain());
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(typedCase.field());
+ List<String> assertions = new ArrayList<>();
+ assertions.add("/response/numFound==2]");
+ for (int docIdx = 0; docIdx < 2; docIdx++) {
+ String docId = docIdx == 0 ? "'99'" : "'98'";
+ assertions.add("/response/docs/[" + docIdx + "]/id==" + docId);
+ for (int i = 0; i < typedCase.expectedValues().size(); i++) {
+ assertions.add(
+ "/response/docs/["
+ + docIdx
+ + "]/"
+ + typedCase.field()
+ + "/["
+ + i
+ + "]=="
+ + typedCase.expectedValues().get(i));
+ }
+ }
+ assertJQ("/query" + query.toQueryString(), assertions.toArray(new String[0]));
+
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/" + typedCase.modelId());
+ loadedModelId = null;
+ }
+ }
+
+ // --- LLM response contract violation tests ---
+
+ @Test
+ public void processAdd_llmResponseMissingValueKey_shouldLogAndIndexWithNoEnrichedField()
+ throws Exception {
+ // Model returns valid JSON but without the required "value" key
+ loadDummyLargeLanguageModel("dummy-1", "{\"result\": \"some value\"}");
+
+ addWithChain(
+ sdoc("id", "99", "string_field", "Vegeta is the saiyan prince."), "documentEnrichment");
+ addWithChain(
+ sdoc("id", "98", "string_field", "Kakaroth is a saiyan grown up on planet Earth."),
+ "documentEnrichment");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/" + processorOutputField + "==",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputField + "==");
+ }
+
+ @Test
+ public void processAdd_llmResponseMalformedJson_shouldLogAndIndexWithNoEnrichedField()
+ throws Exception {
+ // Model returns a plain string that cannot be parsed as JSON
+ loadDummyLargeLanguageModel("dummy-1", "not valid json at all");
+
+ addWithChain(
+ sdoc("id", "99", "string_field", "Vegeta is the saiyan prince."), "documentEnrichment");
+ addWithChain(
+ sdoc("id", "98", "string_field", "Kakaroth is a saiyan grown up on planet Earth."),
+ "documentEnrichment");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputField);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/" + processorOutputField + "==",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputField + "==");
+ }
+
+ // --- field type incompatibility tests ---
+
+ @Test
+ public void processAdd_dateOutputField_malformedDateString_shouldFailToIndex() throws Exception {
+ // DatePointField requires a full ISO-8601 datetime string (e.g. "2024-01-15T00:00:00Z").
+ // A date-only string like "2024-01-15" (missing time component) cannot be parsed by
+ // DateMathParser and causes the update to fail.
+ // Unlike model exceptions (caught inside processAdd), this error occurs during Solr field
+ // conversion in super.processAdd() and propagates as a RemoteSolrException to the caller.
+ loadDummyLargeLanguageModel("dummy-date", "{\"value\": \"2024-01-15\"}");
+
+ assertThrows(
+ "date string without time component should fail to index",
+ RemoteSolrException.class,
+ () ->
+ addWithChain(
+ sdoc("id", "99", "string_field", "some content"), "documentEnrichmentSingleDate"));
+ }
+
+ @Test
+ public void processAdd_intOutputField_decimalResponse_shouldLogAndIndexWithNoEnrichedField()
+ throws Exception {
+ loadDummyLargeLanguageModel("dummy-int", "{\"value\": 3.7}");
+
+ addWithChain(sdoc("id", "99", "string_field", "some content"), "documentEnrichmentSingleInt");
+ addWithChain(sdoc("id", "98", "string_field", "other content"), "documentEnrichmentSingleInt");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery("output_int");
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/output_int==",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/output_int==");
+ }
+
+ @Test
+ public void processAdd_doubleOutputField_intResponse_shouldConvertAndIndex() throws Exception {
+ loadDummyLargeLanguageModel("dummy-double", "{\"value\": 3}");
+
+ addWithChain(
+ sdoc("id", "99", "string_field", "some content"), "documentEnrichmentSingleDouble");
+ addWithChain(
+ sdoc("id", "98", "string_field", "other content"), "documentEnrichmentSingleDouble");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery("output_double");
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/output_double==3.0",
+ "/response/docs/[1]/id=='98'",
+ "/response/docs/[1]/output_double==3.0");
+ }
+
+ @Test
+ public void processAdd_floatOutputField_doubleResponse_shouldRoundToFloatPrecision()
+ throws Exception {
+ loadDummyLargeLanguageModel("dummy-float", "{\"value\": 3.141592653589793}");
+
+ addWithChain(sdoc("id", "99", "string_field", "some content"), "documentEnrichmentSingleFloat");
+ addWithChain(
+ sdoc("id", "98", "string_field", "other content"), "documentEnrichmentSingleFloat");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery("output_float");
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "/response/docs/[0]/output_float==3.1415927",
+ "/response/docs/[1]/id=='98'",
+ "/response/docs/[1]/output_float==3.1415927");
+ }
+
+ // --- multivalued output field / scalar response test ---
+
+ @Test
+ public void processAdd_multivaluedOutputField_singleValuedLlmResponse_shouldSkipEnrichment()
+ throws Exception {
+ loadDummyLargeLanguageModel("dummy-multivalued-1", "{\"value\": \"a single string\"}");
+
+ addWithChain(
+ sdoc("id", "99", "string_field", "Vegeta is the saiyan prince."),
+ "documentEnrichmentMultivaluedString");
+ addWithChain(
+ sdoc("id", "98", "string_field", "Kakaroth is a saiyan grown up on planet Earth."),
+ "documentEnrichmentMultivaluedString");
+ assertU(commit());
+
+ final SolrQuery query = getEnrichmentQuery(processorOutputFieldMulti);
+
+ assertJQ(
+ "/query" + query.toQueryString(),
+ "/response/numFound==2]",
+ "/response/docs/[0]/id=='99'",
+ "!/response/docs/[0]/" + processorOutputFieldMulti + "==",
+ "/response/docs/[1]/id=='98'",
+ "!/response/docs/[1]/" + processorOutputFieldMulti + "==");
+ }
+
+ private SolrQuery getEnrichmentQuery(String enrichedFieldName) {
+ final SolrQuery query = new SolrQuery();
+ query.setQuery("*:*");
+ query.add("fl", "id," + enrichedFieldName);
+ query.add("sort", "id desc");
+ return query;
+ }
+
+ void addWithChain(SolrInputDocument document, String updateChain)
+ throws SolrServerException, IOException {
+ UpdateRequest req = new UpdateRequest();
+ req.add(document);
+ req.setParam("update.chain", updateChain);
+ solrTestRule.getSolrClient("collection1").request(req);
+ }
+}
diff --git a/solr/modules/language-models/src/test/org/apache/solr/languagemodels/update/processor/factory/DocumentEnrichmentUpdateProcessorFactoryTest.java b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/update/processor/factory/DocumentEnrichmentUpdateProcessorFactoryTest.java
new file mode 100644
index 00000000000..10c0137bd32
--- /dev/null
+++ b/solr/modules/language-models/src/test/org/apache/solr/languagemodels/update/processor/factory/DocumentEnrichmentUpdateProcessorFactoryTest.java
@@ -0,0 +1,459 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.languagemodels.update.processor.factory;
+
+import dev.langchain4j.model.chat.request.ResponseFormatType;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.common.params.ModifiableSolrParams;
+import org.apache.solr.common.util.NamedList;
+import org.apache.solr.core.SolrCore;
+import org.apache.solr.languagemodels.TestLanguageModelBase;
+import org.apache.solr.languagemodels.model.SolrLargeLanguageModel;
+import org.apache.solr.languagemodels.store.rest.LargeLanguageModelStore;
+import org.apache.solr.request.SolrQueryRequestBase;
+import org.apache.solr.update.processor.UpdateRequestProcessor;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class DocumentEnrichmentUpdateProcessorFactoryTest extends TestLanguageModelBase {
+
+ @BeforeClass
+ public static void init() throws Exception {
+ setupTest("solrconfig-document-enrichment.xml", "schema-language-models.xml", false, false);
+ }
+
+ @AfterClass
+ public static void cleanup() throws Exception {
+ afterTest();
+ }
+
+ SolrCore collection1;
+ private final String processorOutputField = "processor_output_field";
+ private final String processorOutputFieldMulti = "processor_output_field_multi";
+
+ @Before
+ public void setup() {
+ collection1 = solrTestRule.getCoreContainer().getCore("collection1");
+ }
+
+ @After
+ public void after() {
+ collection1.close();
+ }
+
+ @Test
+ public void init_fullArgs_shouldInitAllParams() {
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ initializeUpdateProcessorFactory(
+ List.of("string_field"), processorOutputField, null, "model1");
+
+ assertEquals(List.of("string_field"), factory.getInputFields());
+ assertEquals(processorOutputField, factory.getOutputField());
+ assertEquals("Summarize: {string_field}.", factory.getPrompt());
+ assertEquals("model1", factory.getModelName());
+ }
+
+ @Test
+ public void init_multipleInputFields_shouldInitAllFields() {
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ initializeUpdateProcessorFactory(
+ List.of("string_field", "body_field"), processorOutputField, null, "model1");
+
+ assertEquals(List.of("string_field", "body_field"), factory.getInputFields());
+ }
+
+ @Test
+ public void init_arrInputField_shouldInitAllFields() {
+ NamedList<Object> args = new NamedList<>();
+ args.add("inputField", new ArrayList<>(List.of("string_field", "body_field")));
+ args.add("outputField", processorOutputField);
+ args.add("prompt", "Title: {string_field}. Body: {body_field}.");
+ args.add("model", "model1");
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+ factory.init(args);
+
+ assertEquals(List.of("string_field", "body_field"), factory.getInputFields());
+ }
+
+ // when exception are thrown at init time, the helper function cannot be used
+ @Test
+ public void init_noInputField_shouldThrowExceptionWithDetailedMessage() {
+ NamedList<String> args = new NamedList<>();
+ args.add("outputField", processorOutputField);
+ args.add("prompt", "Summarize: {string_field}.");
+ args.add("model", "model1");
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+
+ SolrException e = assertThrows(SolrException.class, () -> factory.init(args));
+ assertEquals("At least one 'inputField' must be provided", e.getMessage());
+ }
+
+ @Test
+ public void init_nullOutputField_shouldThrowExceptionWithDetailedMessage() {
+ NamedList<String> args = new NamedList<>();
+ args.add("inputField", "string_field");
+ args.add("prompt", "Summarize: {string_field}");
+ args.add("model", "model1");
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+
+ SolrException e = assertThrows(SolrException.class, () -> factory.init(args));
+ assertEquals("Exactly one 'outputField' must be provided, but found: None", e.getMessage());
+ }
+
+ @Test
+ public void init_moreThanOneOutputField_shouldThrowExceptionWithDetailedMessage() {
+ NamedList<String> args = new NamedList<>();
+ args.add("inputField", "string_field");
+ args.add("outputField", processorOutputField);
+ args.add("outputField", "another_enriched_field");
+ args.add("prompt", "Summarize: {string_field}");
+ args.add("model", "model1");
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+ SolrException e = assertThrows(SolrException.class, () -> factory.init(args));
+ assertEquals(
+ "Exactly one 'outputField' must be provided, but found: ["
+ + processorOutputField
+ + ", another_enriched_field]",
+ e.getMessage());
+ }
+
+ @Test
+ public void init_neitherPromptNorPromptFile_shouldThrowExceptionWithDetailedMessage() {
+ NamedList<String> args = new NamedList<>();
+ args.add("inputField", "string_field");
+ args.add("outputField", processorOutputField);
+ args.add("model", "model1");
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+
+ SolrException e = assertThrows(SolrException.class, () -> factory.init(args));
+ assertEquals("Either 'prompt' or 'promptFile' must be provided", e.getMessage());
+ }
+
+ @Test
+ public void init_bothPromptAndPromptFile_shouldThrowExceptionWithDetailedMessage() {
+ NamedList<String> args = new NamedList<>();
+ args.add("inputField", "string_field");
+ args.add("outputField", processorOutputField);
+ args.add("prompt", "Summarize: {string_field}");
+ args.add("promptFile", "prompt.txt");
+ args.add("model", "model1");
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+
+ SolrException e = assertThrows(SolrException.class, () -> factory.init(args));
+ assertEquals("Only one of 'prompt' or 'promptFile' must be provided, not both", e.getMessage());
+ }
+
+ @Test
+ public void
+ init_promptMissingPlaceholderForDeclaredField_shouldThrowExceptionWithDetailedMessage() {
+ NamedList<String> args = new NamedList<>();
+ args.add("inputField", "string_field");
+ args.add("outputField", processorOutputField);
+ args.add("prompt", "Summarize:");
+ args.add("model", "model1");
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+
+ SolrException e = assertThrows(SolrException.class, () -> factory.init(args));
+ assertEquals(
+ "prompt is missing placeholders for inputField(s): [string_field]", e.getMessage());
+ }
+
+ @Test
+ public void
+ init_promptMissingOnePlaceholderOfMultipleFields_shouldThrowExceptionWithDetailedMessage() {
+ NamedList<String> args = new NamedList<>();
+ args.add("inputField", "string_field");
+ args.add("inputField", "body_field");
+ args.add("outputField", processorOutputField);
+ args.add("prompt", "Title: {string_field}.");
+ args.add("model", "model1");
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+
+ SolrException e = assertThrows(SolrException.class, () -> factory.init(args));
+ assertEquals("prompt is missing placeholders for inputField(s): [body_field]", e.getMessage());
+ }
+
+ @Test
+ public void
+ init_promptHasExtraPlaceholderNotDeclaredAsInputField_shouldThrowExceptionWithDetailedMessage() {
+ NamedList<String> args = new NamedList<>();
+ args.add("inputField", "string_field");
+ args.add("outputField", processorOutputField);
+ args.add("prompt", "Title: {string_field}. Extra: {unknown_field}.");
+ args.add("model", "model1");
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+
+ SolrException e = assertThrows(SolrException.class, () -> factory.init(args));
+ assertEquals(
+ "prompt contains placeholders not declared as inputField(s): [unknown_field]",
+ e.getMessage());
+ }
+
+ @Test
+ public void init_nullModel_shouldThrowExceptionWithDetailedMessage() {
+ NamedList<String> args = new NamedList<>();
+ args.add("inputField", "string_field");
+ args.add("outputField", processorOutputField);
+ args.add("prompt", "Summarize: {string_field}");
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+
+ SolrException e = assertThrows(SolrException.class, () -> factory.init(args));
+ assertEquals("Missing required parameter: model", e.getMessage());
+ }
+
+ @Test
+ public void init_promptFile_shouldLoadPromptFromFile() {
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ initializeUpdateProcessorFactory(
+ List.of("string_field"), processorOutputField, "prompt.txt", "model1");
+ factory.inform(collection1);
+
+ assertEquals("prompt.txt", factory.getPromptFile());
+ assertNotNull(factory.getPrompt());
+ assertTrue(factory.getPrompt().contains("{string_field}"));
+ }
+
+ @Test
+ public void init_promptFileMultiField_shouldLoadAndValidateBothPlaceholders() {
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ initializeUpdateProcessorFactory(
+ List.of("string_field", "body_field"),
+ processorOutputField,
+ "prompt-multi-field.txt",
+ "model1");
+ factory.inform(collection1);
+
+ assertNotNull(factory.getPrompt());
+ assertTrue(factory.getPrompt().contains("{string_field}"));
+ assertTrue(factory.getPrompt().contains("{body_field}"));
+ }
+
+ @Test
+ public void init_promptFileWithMissingPlaceholder_shouldThrowExceptionInInform() {
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ initializeUpdateProcessorFactory(
+ List.of("string_field"), processorOutputField, "prompt-no-placeholder.txt", "model1");
+
+ SolrException e = assertThrows(SolrException.class, () -> factory.inform(collection1));
+ assertEquals(
+ "prompt is missing placeholders for inputField(s): [string_field]", e.getMessage());
+ }
+
+ /* Following tests depend on a real solr schema and depend on BeforeClass-AfterClass methods */
+
+ @Test
+ public void init_notExistentOutputField_shouldThrowExceptionWithDetailedMessage()
+ throws Exception {
+ SolrException e =
+ assertThrows(
+ SolrException.class,
+ () ->
+ createUpdateProcessor(
+ List.of("string_field"), "notExistentOutput", null, collection1, "model1"));
+ assertEquals("undefined field: \"notExistentOutput\"", e.getMessage());
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/model1");
+ }
+
+ @Test
+ public void init_notExistentInputField_shouldThrowExceptionWithDetailedMessage()
+ throws Exception {
+ SolrException e =
+ assertThrows(
+ SolrException.class,
+ () ->
+ createUpdateProcessor(
+ List.of("notExistentInput"),
+ processorOutputField,
+ null,
+ collection1,
+ "model1"));
+ assertEquals("undefined field: \"notExistentInput\"", e.getMessage());
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/model1");
+ }
+
+ @Test
+ public void init_multipleInputFields_oneNotExistent_shouldThrowExceptionWithDetailedMessage()
+ throws Exception {
+ SolrException e =
+ assertThrows(
+ SolrException.class,
+ () ->
+ createUpdateProcessor(
+ List.of("string_field", "notExistentInput"),
+ processorOutputFieldMulti,
+ null,
+ collection1,
+ "model1"));
+ assertEquals("undefined field: \"notExistentInput\"", e.getMessage());
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/model1");
+ }
+
+ @Test
+ public void init_multivaluedStringOutputField_shouldNotThrowException() throws Exception {
+ UpdateRequestProcessor instance =
+ createUpdateProcessor(
+ List.of("string_field"), processorOutputFieldMulti, null, collection1, "model1");
+ assertNotNull(instance);
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/model1");
+ }
+
+ /* getJsonSchema tests for unsupported field types from the Solr documentation:
+ * - BinaryField: not supported
+ * - UUIDField, NestPathField, DenseVectorField: explicitly removed support for these fields since the Java classes
+ * extend some supported field types
+ * */
+
+ @Test
+ public void getJsonSchema_unsupportedFieldTypes_shouldThrowUnsupportedFieldTypeException() {
+ var cases =
+ Map.of(
+ "output_binary", "BinaryField",
+ "output_uuid", "UUIDField",
+ "output_nest_path", "NestPathField",
+ "vector", "DenseVectorField");
+ var schema = collection1.getLatestSchema();
+ cases.forEach(
+ (fieldName, expectedTypeName) -> {
+ var schemaField = schema.getField(fieldName);
+ SolrException e =
+ assertThrows(
+ SolrException.class,
+ () -> DocumentEnrichmentUpdateProcessorFactory.getJsonSchema(schemaField));
+ assertEquals(
+ "field type is not supported by Document Enrichment: " + expectedTypeName,
+ e.getMessage());
+ });
+ }
+
+ @Test
+ public void init_sortableTextOutputField_getJsonSchema_shouldProduceStringSchema() {
+ var schemaField = collection1.getLatestSchema().getField("output_sortable_text");
+ var responseFormat = DocumentEnrichmentUpdateProcessorFactory.getJsonSchema(schemaField);
+ assertNotNull(responseFormat);
+ assertEquals(ResponseFormatType.JSON, responseFormat.type());
+ assertNotNull(responseFormat.jsonSchema());
+ }
+
+ @Test
+ public void init_multivaluedStringOutputField_getJsonSchema_shouldProduceArraySchema() {
+ // verify the ResponseFormat is constructed correctly for the multivalued field
+ var schema = collection1.getLatestSchema();
+ var schemaField = schema.getField(processorOutputFieldMulti);
+ assertTrue(schemaField.multiValued());
+ var responseFormat = DocumentEnrichmentUpdateProcessorFactory.getJsonSchema(schemaField);
+ assertNotNull(responseFormat);
+ assertEquals(ResponseFormatType.JSON, responseFormat.type());
+ assertNotNull(responseFormat.jsonSchema());
+ }
+
+ @Test
+ public void init_singleValuedStringOutputField_getJsonSchema_shouldProduceStringSchema() {
+ var schema = collection1.getLatestSchema();
+ var schemaField = schema.getField(processorOutputField);
+ assertFalse(schemaField.multiValued());
+ var responseFormat = DocumentEnrichmentUpdateProcessorFactory.getJsonSchema(schemaField);
+ assertNotNull(responseFormat);
+ assertEquals(ResponseFormatType.JSON, responseFormat.type());
+ assertNotNull(responseFormat.jsonSchema());
+ }
+
+ @Test
+ public void init_dynamicInputField_shouldNotThrowException() throws Exception {
+ UpdateRequestProcessor instance =
+ createUpdateProcessor(List.of("text_s"), processorOutputField, null, collection1, "model1");
+ assertNotNull(instance);
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/model1");
+ }
+
+ @Test
+ public void init_multipleDynamicInputFields_shouldNotThrowException() throws Exception {
+ UpdateRequestProcessor instance =
+ createUpdateProcessor(
+ List.of("text_s", "body_field"), processorOutputField, null, collection1, "model1");
+ assertNotNull(instance);
+ restTestHarness.delete(LargeLanguageModelStore.REST_END_POINT + "/model1");
+ }
+
+ private UpdateRequestProcessor createUpdateProcessor(
+ List<String> inputFieldNames,
+ String outputFieldName,
+ String prompt,
+ SolrCore core,
+ String modelName)
+ throws Exception {
+
+ LargeLanguageModelStore.getManagedModelStore(core)
+ .addModel(new SolrLargeLanguageModel(modelName, null, null));
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ initializeUpdateProcessorFactory(inputFieldNames, outputFieldName, prompt, modelName);
+
+ ModifiableSolrParams params = new ModifiableSolrParams();
+ SolrQueryRequestBase req = new SolrQueryRequestBase(core, params) {};
+
+ return factory.getInstance(req, null, null);
+ }
+
+ private DocumentEnrichmentUpdateProcessorFactory initializeUpdateProcessorFactory(
+ List<String> inputFieldNames, String outputFieldName, String prompt, String modelName) {
+ NamedList<String> args = new NamedList<>();
+
+ for (String fieldName : inputFieldNames) {
+ args.add("inputField", fieldName);
+ }
+ args.add("outputField", outputFieldName);
+
+ if (prompt != null) {
+ args.add("promptFile", prompt);
+ } else {
+ args.add("prompt", "Summarize: {" + String.join("}. {", inputFieldNames) + "}.");
+ }
+
+ args.add("model", modelName);
+
+ DocumentEnrichmentUpdateProcessorFactory factory =
+ new DocumentEnrichmentUpdateProcessorFactory();
+ factory.init(args);
+ return factory;
+ }
+}
diff --git a/solr/solr-ref-guide/modules/configuration-guide/pages/update-request-processors.adoc b/solr/solr-ref-guide/modules/configuration-guide/pages/update-request-processors.adoc
index e1863246267..84a65feac0d 100644
--- a/solr/solr-ref-guide/modules/configuration-guide/pages/update-request-processors.adoc
+++ b/solr/solr-ref-guide/modules/configuration-guide/pages/update-request-processors.adoc
@@ -427,6 +427,10 @@ The {solr-javadocs}/modules/language-models/index.html[`language-models`] module
It uses external text to vectors language models to perform the vectorisation for each processed document.
For more information: xref:query-guide:text-to-vector.adoc[Update Request Processor]
+{solr-javadocs}/modules/language-models/org/apache/solr/languagemodels/update/processor/factory/DocumentEnrichmentUpdateProcessorFactory.html[DocumentEnrichmentUpdateProcessorFactory]:: Update processor that takes one or more fields and a given prompt in input and returns the output of an LLM as the value of a new field.
+It uses external Large Language Model services to perform the enrichment of each processed document.
+For more information: xref:indexing-guide:document-enrichment-with-llms.adoc[Document Enrichment documentation]
+
The {solr-javadocs}/modules/langid/index.html[`langid`] module provides::
{solr-javadocs}/modules/langid/org/apache/solr/update/processor/LangDetectLanguageIdentifierUpdateProcessorFactory.html[LangDetectLanguageIdentifierUpdateProcessorFactory]::: Identifies the language of a set of input fields using http://code.google.com/p/language-detection.
diff --git a/solr/solr-ref-guide/modules/indexing-guide/indexing-nav.adoc b/solr/solr-ref-guide/modules/indexing-guide/indexing-nav.adoc
index 9b50849716c..940225e8d4e 100644
--- a/solr/solr-ref-guide/modules/indexing-guide/indexing-nav.adoc
+++ b/solr/solr-ref-guide/modules/indexing-guide/indexing-nav.adoc
@@ -58,5 +58,6 @@
** xref:partial-document-updates.adoc[]
** xref:reindexing.adoc[]
** xref:language-detection.adoc[]
+** xref:document-enrichment-with-llms.adoc[]
** xref:de-duplication.adoc[]
** xref:content-streams.adoc[]
diff --git a/solr/solr-ref-guide/modules/indexing-guide/pages/document-enrichment-with-llms.adoc b/solr/solr-ref-guide/modules/indexing-guide/pages/document-enrichment-with-llms.adoc
new file mode 100644
index 00000000000..600268187ae
--- /dev/null
+++ b/solr/solr-ref-guide/modules/indexing-guide/pages/document-enrichment-with-llms.adoc
@@ -0,0 +1,534 @@
+= Document Enrichment with LLMs
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+This module brings the power of *Large Language Models* to Solr.
+
+More specifically, it enables calling an LLM at indexing time to enrich documents with additional/generated/extracted
+data. Given a prompt and a set of input fields, for each document, the LLM is invoked through
+https://github.com/langchain4j/langchain4j[LangChain4j], and the result is stored in an output field, which can support
+multiple types and may also be multivalued.
+
+_Without_ this module, the LLM calls to enrich documents must be done _outside_ Solr, before indexing.
+
+[IMPORTANT]
+====
+This module sends your documents off to some hosted service on the internet.
+There are cost, privacy, performance, and service availability implications on such a strong dependency that should be
+diligently examined before employing this module in a serious way.
+
+====
+
+At the moment, Solr supports a subset of the LLM providers available in LangChain4j.
+
+*Disclaimer*: Apache Solr is *in no way* affiliated to any of these corporations or services.
+
+If you want to add support for additional services or improve the support for the existing ones, feel free to
+contribute:
+
+* https://github.com/apache/solr/blob/main/CONTRIBUTING.md[Contributing to Solr]
+
+== Module
+
+This is provided via the `language-models` xref:configuration-guide:solr-modules.adoc[Solr Module] that needs to be
+enabled before use.
+
+== Language Model Configuration
+
+Language Models is a module and therefore its plugins must be configured in `solrconfig.xml`.
+
+=== Minimum Requirements
+
+* Enable the `language-models` module to make the Language Models classes available on Solr's classpath.
+See xref:configuration-guide:solr-modules.adoc[Solr Module] for more details.
+
+* An {solr-javadocs}/core/org/apache/solr/update/processor/UpdateRequestProcessorChain.html[UpdateRequestProcessorChain]
+that includes at least one `DocumentEnrichmentUpdateProcessor` update processor.
+
+=== Update Processor Chain Design
+
+To properly design the Update Processor Chain for Document Enrichment, several parameters must be defined:
+
+`inputField`::
++
+[%autowidth,frame=none]
+|===
+s|Required |Default: none
+|===
++
+The field whose content is passed to the LLM to enrich the documents. Every `inputField` declared must be referred to in
+the prompt.
+
++
+Multiple `inputField` are supported and can be defined by using one of the following notations:
+
+* Add more than one `inputField` string element
++
+[source,xml]
+----
+<updateRequestProcessorChain name="documentEnrichment">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">title</str>
+ <str name="inputField">body</str>
+ <str name="outputField">summary</str>
+ <str name="prompt">Summarize with the following information. Title: {title}. Body: {body}.</str>
+ <str name="model">model-name</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+----
+
+* Substitute the `inputField` string element with an array of string elements with the same name
++
+[source,xml]
+----
+<arr name="inputField">
+ <str>title</str>
+ <str>body</str>
+</arr>
+----
+
+
+`outputField`::
++
+[%autowidth,frame=none]
+|===
+s|Required |Default: none
+|===
++
+The LLM response is mapped to the specified `outputField`, and only one field is supported as output. Note that this
+module only supports a subset of Solr's available field types, which includes:
+
+* *String/Text*: `StrField`, `TextField`, `SortableTextField`
+* *Date*: `DatePointField` (the LLM must return an ISO-8601 date string; it might be useful to tune your prompt accordingly, to avoid indexing errors)
+* *Numeric*: `IntPointField`, `LongPointField`, `FloatPointField`, `DoublePointField`
+* *Boolean*: `BoolField`
+
+
+These fields _can_ be multivalued. Solr uses structured output from LangChain4j to deal with LLMs' responses.
+
+
+`prompt` or `promptFile`::
++
+[%autowidth,frame=none]
+|===
+s|Exactly one of these parameters is required |Default: none
+|===
++
+Two different ways to define a prompt are available: one directly in the solrconfig and one through a dedicated file.
+Either way, the content of the prompt _must_ contain a special token for each `inputField` declared, that are the
+`fieldName` surrounded by curly brackets (e.g., `{string_field}`, in the example below). Solr will throw an error if
+the parameters are not properly defined.
++
+These parameters can be defined in one of the following ways:
+
+* Update processor definition with the `prompt` parameter
++
+[source,xml]
+----
+<updateRequestProcessorChain name="documentEnrichment">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">summary</str>
+ <str name="prompt">Summarize this content: {string_field}</str>
+ <str name="model">model-name</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+----
+
+* Update processor definition with the `promptFile` parameter: in this case, the file `prompt.txt` must be uploaded to
+Solr inside the config folder of the collection (e.g., similarly to `solrconfig.xml`, `synonyms.txt`, etc.)
++
+[source,xml]
+----
+<updateRequestProcessorChain name="documentEnrichment">
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">summary</str>
+ <str name="promptFile">prompt.txt</str>
+ <str name="model">model-name</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+ </updateRequestProcessorChain>
+----
+
+`model`::
++
+[%autowidth,frame=none]
+|===
+s|Required |Default: none
+|===
++
+
+The name of the model that will be uploaded via REST. See xref:document-enrichment-with-llms.adoc#general-purpose-llm-setup[] for
+more information.
+
+
+For more details on how to work with update request processors in Apache Solr, please refer to the dedicated page:
+xref:configuration-guide:update-request-processors.adoc[Update Request Processor]
+
+[IMPORTANT]
+====
+This update processor sends your document field content off to some hosted service on the internet.
+There are serious performance implications that should be diligently examined before employing this component in production.
+It will slow down substantially your indexing pipeline so make sure to stress test your solution before going live.
+
+====
+
+[NOTE]
+====
+If any `inputField` value is absent or empty for a given document, enrichment is silently skipped for that document:
+the `outputField` is not added and the document is indexed as-is.
+
+If the LLM call fails at runtime (e.g., network error, model timeout), the exception is caught and logged but is
+*non-fatal*: the document is still indexed without the `outputField`.
+Monitor your indexing logs to detect documents that were not enriched as expected.
+====
+
+== General Purpose LLM Setup
+
+=== Models
+
+* A model is a https://docs.langchain4j.dev/category/language-models/[Langchain4j ChatModel] that generates a response given a prompt.
+* A model is a reference to an external API that runs the Large Language Model.
+
+[IMPORTANT]
+====
+The Solr model specifies the parameters to access the APIs, the LLM doesn't run internally in Solr.
+
+====
+
+A model is described by these parameters:
+
+
+`class`::
++
+[%autowidth,frame=none]
+|===
+s|Required |Default: none
+|===
++
+The model https://github.com/langchain4j/langchain4j[LangChain4j] implementation.
+Accepted values:
+
+* `dev.langchain4j.model.ollama.OllamaChatModel`
+* `dev.langchain4j.model.mistralai.MistralAiChatModel`
+* `dev.langchain4j.model.anthropic.AnthropicChatModel`
+* `dev.langchain4j.model.openai.OpenAiChatModel`
+* `dev.langchain4j.model.googleai.GoogleAiGeminiChatModel`
+
+`name`::
++
+[%autowidth,frame=none]
+|===
+s|Required |Default: none
+|===
++
+The identifier of your model, this is used by any component that intends to use the model
+(e.g., `DocumentEnrichmentUpdateProcessorFactory` update processor).
+
+`params`::
++
+[%autowidth,frame=none]
+|===
+|Optional |Default: none
+|===
++
+Each model class has potentially different params.
+Many are shared but for the full set of parameters of the model you are interested in please refer to the official
+documentation of the LangChain4j version included in Solr:
+https://docs.langchain4j.dev/category/language-models[Chat Models in LangChain4j].
+
+=== Supported Models
+Apache Solr uses https://github.com/langchain4j/langchain4j[LangChain4j] to support document enrichment with LLMs.
+The models currently supported are:
+
+[tabs#supported-chat-models]
+======
+Ollama::
++
+====
+
+[source,json]
+----
+{
+ "class": "dev.langchain4j.model.ollama.OllamaChatModel",
+ "name": "<a-name-for-your-model>",
+ "params": {
+ "baseUrl": "http://localhost:11434",
+ "modelName": "<a-local/hosted-chat-model>",
+ "timeout": 300,
+ "logRequests": true,
+ "logResponses": true,
+ "maxRetries": 5
+ }
+}
+----
+====
+
+MistralAI::
++
+====
+[source,json]
+----
+{
+ "class": "dev.langchain4j.model.mistralai.MistralAiChatModel",
+ "name": "<a-name-for-your-model>",
+ "params": {
+ "baseUrl": "https://api.mistral.ai/v1",
+ "apiKey": "<your-mistralAI-api-key>",
+ "modelName": "<a-mistralAI-chat-model>",
+ "timeout": 60,
+ "logRequests": true,
+ "logResponses": true,
+ "maxRetries": 5
+ }
+}
+----
+====
+OpenAI::
++
+====
+[source,json]
+----
+{
+ "class": "dev.langchain4j.model.openai.OpenAiChatModel",
+ "name": "<a-name-for-your-model>",
+ "params": {
+ "baseUrl": "https://api.openai.com/v1",
+ "apiKey": "<your-openAI-api-key>",
+ "modelName": "<a-openAI-chat-model>",
+ "timeout": 60,
+ "logRequests": true,
+ "logResponses": true,
+ "maxRetries": 5
+ }
+}
+----
+====
+
+Anthropic::
++
+====
+[source,json]
+----
+{
+ "class": "dev.langchain4j.model.anthropic.AnthropicChatModel",
+ "name": "<a-name-for-your-model>",
+ "params": {
+ "baseUrl": "https://api.anthropic.com/v1/",
+ "apiKey": "<your-anthropic-api-key>",
+ "modelName": "<a-anthropic-chat-model>",
+ "timeout": 60,
+ "logRequests": true,
+ "logResponses": true,
+ "maxRetries": 5
+ }
+}
+----
+====
+
+Gemini::
++
+====
+[source,json]
+----
+{
+ "class": "dev.langchain4j.model.googleai.GoogleAiGeminiChatModel",
+ "name": "<a-name-for-your-model>",
+ "params": {
+ "baseUrl": "https://generativelanguage.googleapis.com/v1beta/",
+ "apiKey": "<your-geminiAi-api-key>",
+ "modelName": "<a-geminiAi-chat-model>",
+ "timeout": 60,
+ "logRequests": true,
+ "logResponses": true,
+ "maxRetries": 5
+ }
+}
+----
+====
+======
+
+=== Uploading a Model
+
+To upload the model in a `/path/myModel.json` file, please run:
+
+[source,bash]
+----
+curl -XPUT 'http://localhost:8983/solr/YOUR_COLLECTION/schema/large-language-model-store' --data-binary "@/path/myModel.json" -H 'Content-type:application/json'
+----
+
+To delete the `currentModel` model:
+
+[source,bash]
+----
+curl -XDELETE 'http://localhost:8983/solr/YOUR_COLLECTION/schema/large-language-model-store/currentModel'
+----
+
+To view all models:
+
+[source,text]
+http://localhost:8983/solr/YOUR_COLLECTION/schema/large-language-model-store
+
+
+.Example: /path/myOpenAIModel.json
+[source,json]
+----
+{
+ "class": "dev.langchain4j.model.openai.OpenAiChatModel",
+ "name": "openai-1",
+ "params": {
+ "baseUrl": "https://api.openai.com/v1",
+ "apiKey": "apiKey-openAI",
+ "modelName": "gpt-5.4-nano",
+ "timeout": 60,
+ "logRequests": true,
+ "logResponses": true,
+ "maxRetries": 5
+ }
+}
+----
+
+
+== Index First and Enrich your Documents on a Second Pass
+LLM calls are typically slow, so depending on your use case, it may be preferable to first index your documents and
+enrich them with LLM-generated fields at a later stage.
+
+This can be done in Solr defining two update request processors chains: one that includes all the processors you need,
+excluding the `DocumentEnrichmentUpdateProcessor` (let's call it 'no-enrichment') and one that includes the
+`DocumentEnrichmentUpdateProcessor` (let's call it 'enrichment').
+
+[source,xml]
+----
+<updateRequestProcessorChain name="no-enrichment">
+ <processor class="solr.processor1">
+ ...
+ </processor>
+ ...
+ <processor class="solr.processorN">
+ ...
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+</updateRequestProcessorChain>
+----
+
+[source,xml]
+----
+<updateRequestProcessorChain name="enrichment">
+ <processor class="solr.processor1">
+ ...
+ </processor>
+ ...
+ <processor class="solr.processorN">
+ ...
+ </processor>
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">summary</str>
+ <str name="prompt">Summarize this content: {string_field}</str>
+ <str name="model">model-name</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+</updateRequestProcessorChain>
+----
+
+You would index your documents first using the 'no-enrichment' and when finished, incrementally repeat the indexing
+targeting the 'enrichment' chain.
+
+[IMPORTANT]
+====
+This implies you need to send the documents you want to index to Solr twice and re-run any other update request
+processor you need, in the second chain. This has data traffic implications (you transfer your documents over the
+network twice) and processing implications (if you have other update request processors in your chain, those must be
+repeated the second time as we are literally replacing the indexed documents one by one).
+====
+
+If your use case is compatible with xref:indexing-guide:partial-document-updates.adoc[Partial Updates], you can do better:
+
+You still define two chains, but this time the 'enrichment' one only includes the 'DocumentEnrichmentUpdateProcessor'
+(and the xref:configuration-guide:update-request-processors.adoc[Mandatory Processors])
+
+[source,xml]
+----
+<updateRequestProcessorChain name="no-enrichment">
+ <processor class="solr.processor1">
+ ...
+ </processor>
+ ...
+ <processor class="solr.processorN">
+ ...
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+</updateRequestProcessorChain>
+----
+
+[source,xml]
+----
+<updateRequestProcessorChain name="enrichment">
+ <processor class="solr.DistributedUpdateProcessorFactory"/>
+ <processor class="solr.languagemodels.update.processor.factory.DocumentEnrichmentUpdateProcessorFactory">
+ <str name="inputField">string_field</str>
+ <str name="outputField">summary</str>
+ <str name="prompt">Summarize this content: {string_field}</str>
+ <str name="model">model-name</str>
+ </processor>
+ <processor class="solr.RunUpdateProcessorFactory"/>
+</updateRequestProcessorChain>
+----
+
+[NOTE]
+====
+Since partial updates are resolved by `DistributedUpdateProcessorFactory`, be sure to place
+`DocumentEnrichmentUpdateProcessorFactory` afterwards so that it sees normal/complete documents.
+====
+
+Add to your schema a simple field that will be useful to track the enrichment process and use atomic updates:
+
+[source,xml]
+----
+<field name="enriched" type="boolean" indexed="true" stored="false" docValues="true" default="false"/>
+
+----
+
+In the first pass just index your documents using your reliable and fast 'no-enrichment' chain.
+
+On the second pass, re-index all your documents using atomic updates and targeting the 'enrichment' chain:
+
+[source,json]
+----
+{
+ "id":"mydoc",
+ "enriched": {
+ "set": true
+ }
+}
+----
+
+What will happen is that internally Solr fetches the stored content of the docs to update, all the existing fields are
+retrieved and a re-indexing happens, targeting the 'enrichment' chain that will add the LLM-generated fields and set the
+boolean `enriched` field to `true`.
+
+Faceting or querying on the boolean `enriched` field can also give you a quick idea on how many documents have been
+enriched with the new generated fields.
+
+[NOTE]
+====
+To gain information about several ways to target a different `updateRequestProcessorChain` from the default one, see the
+section related to xref:configuration-guide:update-request-processors.adoc#using-custom-chains[Using Custom Chains].
+====