nvidia-nat 1.2.0rc5__py3-none-any.whl

aiq/experimental/test_time_compute/functions/plan_select_execute_function.py

@@ -0,0 +1,224 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed 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.
+
+import logging
+from collections.abc import AsyncGenerator
+
+from pydantic import Field
+
+from aiq.builder.builder import Builder
+from aiq.builder.framework_enum import LLMFrameworkEnum
+from aiq.builder.function_info import FunctionInfo
+from aiq.cli.register_workflow import register_function
+from aiq.data_models.api_server import AIQChatRequest
+from aiq.data_models.component_ref import FunctionRef
+from aiq.data_models.component_ref import TTCStrategyRef
+from aiq.data_models.function import FunctionBaseConfig
+from aiq.experimental.test_time_compute.models.stage_enums import PipelineTypeEnum
+from aiq.experimental.test_time_compute.models.stage_enums import StageTypeEnum
+from aiq.experimental.test_time_compute.models.ttc_item import TTCItem
+
+logger = logging.getLogger(__name__)
+
+
+class PlanSelectExecuteFunctionConfig(FunctionBaseConfig, name="plan_select_execute_function"):
+    """
+    Defines an aiqtoolkit function that performs reasoning on the input data.
+    Output is passed to the next function in the workflow.
+
+    Designed to be used with an InterceptingFunction.
+    """
+
+    augmented_fn: FunctionRef = Field(description="The name of the function to reason on.")
+
+    planner: TTCStrategyRef = Field(description="The configuration for the planner.")
+    editor: TTCStrategyRef | None = Field(description="The configuration for the editor.", default=None)
+    scorer: TTCStrategyRef | None = Field(description="The configuration for the scorer.", default=None)
+    selector: TTCStrategyRef = Field(description="The configuration for the selector.")
+
+    verbose: bool = Field(default=False, description="Whether to log detailed information.")
+    agent_context_prompt_template: str = Field(
+        description="The template for the agent context prompt. This prompt is used to provide context about the agent",
+        default=("\nThe agent system has the following description:\n"
+                 "{description}\n"
+                 "And has access to the following tools with functionality:\n"
+                 "{tools}\n\n"))
+
+    downstream_template: str = Field(
+        description=("The template for the downstream prompt. This prompt is used to provide the reasoning output to"
+                     " the executing agent"),
+        default=("Answer the following question based on message history: {input_text}"
+                 "\n\nHere is a plan for execution that you could use to guide you if you wanted to:"
+                 "\n\n{reasoning_output}"
+                 "\n\nNOTE: Remember to follow your guidance on how to format output, etc."
+                 "\n\n You must respond with the answer to the original question directly to the user."))
+
+
+@register_function(config_type=PlanSelectExecuteFunctionConfig, framework_wrappers=[LLMFrameworkEnum.LANGCHAIN])
+async def plan_select_execute_function(config: PlanSelectExecuteFunctionConfig, builder: Builder):
+    """
+    Build a ExecutionPlanningFunction from the provided config.
+
+    Args:
+        config (ExecutionPlanningFunctionConfig): The config for the ExecutionPlanningFunction.
+        builder (Builder): The Builder instance to use for building the function.
+
+    Returns:
+        ExecutionPlanningFunction: The built ExecutionPlanningFunction.
+    """
+
+    try:
+        from langchain_core.prompts import PromptTemplate
+    except ImportError:
+        raise ImportError("langchain-core is not installed. Please install it to use SingleShotMultiPlanPlanner.\n"
+                          "This error can be resolved by installing aiqtoolkit-langchain.")
+
+    # Get the augmented function's description
+    augmented_function = builder.get_function(config.augmented_fn)
+
+    # For now, we rely on runtime checking for type conversion
+
+    if augmented_function.description and augmented_function.description != "":
+        augmented_function_desc = augmented_function.description
+    else:
+        raise ValueError(f"Function {config.augmented_fn} does not have a description. Cannot augment "
+                         f"function without a description.")
+
+    # Get the function dependencies of the augmented function
+    function_used_tools = builder.get_function_dependencies(config.augmented_fn).functions
+    tool_list = "Tool: Description\n"
+
+    for tool in function_used_tools:
+        tool_impl = builder.get_function(tool)
+        tool_list += f"- {tool}: {tool_impl.description if hasattr(tool_impl, 'description') else ''}\n"
+
+    # Draft the reasoning prompt for the augmented function
+    template = PromptTemplate(template=config.agent_context_prompt_template,
+                              input_variables=["description", "tools"],
+                              validate_template=True)
+
+    downstream_template = PromptTemplate(template=config.downstream_template,
+                                         input_variables=["input_text", "reasoning_output"],
+                                         validate_template=True)
+
+    planner = await builder.get_ttc_strategy(strategy_name=config.planner,
+                                             pipeline_type=PipelineTypeEnum.PLANNING,
+                                             stage_type=StageTypeEnum.SEARCH)
+
+    selector = await builder.get_ttc_strategy(strategy_name=config.selector,
+                                              pipeline_type=PipelineTypeEnum.PLANNING,
+                                              stage_type=StageTypeEnum.SELECTION)
+
+    if config.editor:
+        editor = await builder.get_ttc_strategy(strategy_name=config.editor,
+                                                pipeline_type=PipelineTypeEnum.PLANNING,
+                                                stage_type=StageTypeEnum.EDITING)
+    else:
+        editor = None
+
+    if config.scorer:
+        scorer = await builder.get_ttc_strategy(strategy_name=config.scorer,
+                                                pipeline_type=PipelineTypeEnum.PLANNING,
+                                                stage_type=StageTypeEnum.SCORING)
+    else:
+        scorer = None
+
+    async def planning_pipeline(prompt, context):
+
+        plans = await planner.ainvoke([TTCItem()], prompt, context)
+
+        if editor:
+            plans = await editor.ainvoke(plans, prompt, context)
+        if scorer:
+            plans = await scorer.ainvoke(plans, prompt, context)
+
+        selected_plan = (await selector.ainvoke(plans, prompt, context))[0]
+
+        return selected_plan
+
+    streaming_inner_fn = None
+    single_inner_fn = None
+
+    if augmented_function.has_streaming_output:
+
+        async def streaming_inner(
+                input_message: AIQChatRequest) -> AsyncGenerator[augmented_function.streaming_output_type]:
+            """
+            Perform reasoning on the input text.
+
+            Args:
+                input_message (AIQChatRequest): The input text to reason on.
+            """
+
+            input_text = "".join([str(message.model_dump()) + "\n" for message in input_message.messages])
+
+            context_prompt = await template.ainvoke(input={"description": augmented_function_desc, "tools": tool_list})
+
+            context_prompt = context_prompt.to_string()
+
+            # Run the TTC pipeline
+            planning_item: TTCItem = await planning_pipeline(prompt=input_text, context=context_prompt)
+
+            output = await downstream_template.ainvoke(input={
+                "input_text": input_text, "reasoning_output": planning_item.plan
+            })
+
+            output = output.to_string()
+
+            if config.verbose:
+                logger.info("Reasoning plan and input to agent: \n\n%s", output)
+
+            async for chunk in augmented_function.acall_stream(output):
+                yield chunk
+
+        streaming_inner_fn = streaming_inner
+
+    if augmented_function.has_single_output:
+
+        async def single_inner(input_message: AIQChatRequest) -> augmented_function.single_output_type:
+            """
+            Perform reasoning on the input text.
+
+            Args:
+                input_message (AIQChatRequest): The input text to reason on.
+            """
+
+            input_text = "".join([str(message.model_dump()) + "\n" for message in input_message.messages])
+
+            context_prompt = await template.ainvoke(input={"description": augmented_function_desc, "tools": tool_list})
+
+            context_prompt = context_prompt.to_string()
+
+            # Run the TTC pipeline
+            planning_item: TTCItem = await planning_pipeline(prompt=input_text, context=context_prompt)
+
+            output = await downstream_template.ainvoke(input={
+                "input_text": input_text, "reasoning_output": planning_item.plan
+            })
+
+            output = output.to_string()
+
+            if config.verbose:
+                logger.info("Reasoning plan and input to agent: \n\n%s", output)
+
+            return await augmented_function.acall_invoke(output)
+
+        single_inner_fn = single_inner
+
+    yield FunctionInfo.create(
+        single_fn=single_inner_fn,
+        stream_fn=streaming_inner_fn,
+        description=("Function that runs an TTC execution planner on input and sends plan downstream"),
+        converters=augmented_function.converter_list)

aiq/experimental/test_time_compute/models/editor_config.py

@@ -0,0 +1,132 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed 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.
+
+import typing
+
+from pydantic import Field
+from pydantic import model_validator
+
+from aiq.data_models.component_ref import LLMRef
+from aiq.data_models.ttc_strategy import TTCStrategyBaseConfig
+
+
+class LLMAsAJudgeEditorConfig(TTCStrategyBaseConfig, name="llm_as_a_judge_editor"):
+    """
+    Configuration for the LLMAsAJudgeEditor.
+    """
+    num_feedback: int = Field(default=10,
+                              description="Number of feedback items to generate for each plan during editing. "
+                              "This can help in refining the plans based on feedback.")
+
+    # If strategy is provided, LLM must be
+    editing_llm: LLMRef | typing.Any | None = Field(
+        default=None,
+        description="The LLM to use for editing the plans. This can be a callable or an instance of an LLM client.")
+
+    # If strategy is LLM_AS_A_JUDGE, ensure that the feedback_llm is provided.
+    feedback_llm: LLMRef | typing.Any | None = Field(default=None,
+                                                     description="The LLM to use for generating feedback on the plans."
+                                                     " This can be a callable or an instance of an LLM client.")
+
+    editor_template: str = Field(default=(
+        "You are an expert at improving execution plans. You will be given a plan and feedback on that plan."
+        " Your task is to create an improved version of the plan that addresses the feedback "
+        "while maintaining its strengths.\n\n"
+        "Here is the context:\n\n"
+        "{context}\n\n"
+        "**Input:** \n{original_prompt}\n\n"
+        "**Original Plan:**\n{plan}\n\n"
+        "**Feedback on the Plan:**\n{feedback}\n\n"
+        "Please provide an improved version of the plan that addresses"
+        " the feedback points. Maintain the same structure and "
+        "step-by-step format, but enhance the content. Do not include explanations of your changes, just provide the "
+        "improved plan directly:\n\n"
+        "Begin the final improve plan with 'EDITED PLAN:'"),
+                                 description="The template to use for editing the planning items based on feedback.")
+
+    feedback_template: str = Field(
+        default=("You are an expert at evaluating execution plans. You will be given a plan and "
+                 "need to provide {num_feedback} "
+                 "specific points of feedback about its strengths and weaknesses.\n\n"
+                 "Your feedback should cover aspects like:\n"
+                 "- Comprehensiveness of the plan\n"
+                 "- Logical flow and sequencing\n"
+                 "- Appropriate use of available tools\n"
+                 "- Potential edge cases or failure points\n"
+                 "- Efficiency and optimization opportunities\n\n"
+                 "Here is the context and plan to evaluate:\n\n"
+                 "{context}\n\n"
+                 "**Objective:** \n{original_prompt}\n\n"
+                 "**Plan to Evaluate:**\n{plan}\n\n"
+                 "Please provide exactly {num_feedback} numbered points of feedback, including "
+                 "both strengths and areas for improvement. Begin the feedback with 'FEEDBACK:' and provide"
+                 "{num_feedback} specific feedback points."),
+        description="The template to use for generating feedback for each planning item.")
+
+    @model_validator(mode="before")
+    def validate_strategies(cls, values: dict[str, typing.Any]) -> dict[str, typing.Any]:
+
+        if values.get('editing_llm') is None:
+            raise ValueError('editing_llm must be provided when editing_strategy is set.')
+        # If editing strategy is LLM_AS_A_JUDGE, feedback_llm must also be provided
+        if (values.get('feedback_llm') is None):
+            raise ValueError('feedback_llm must be provided when editing_strategy is LLM_AS_A_JUDGE.')
+
+        return values
+
+
+class IterativePlanRefinementConfig(TTCStrategyBaseConfig, name="iterative_plan_refinement"):
+    """Configuration for an 'iterative plan refinement' strategy."""
+    editor_llm: LLMRef | typing.Any | None = Field(
+        default=None, description="The LLM to use for generating and refining the plan across multiple iterations.")
+    num_iterations: int = Field(default=3, description="How many refinement steps to perform.")
+    refinement_template: str = Field(
+        default=("You have the current plan:\n{current_plan}\n\n"
+                 "The plan was generated to achieve the following objective:\n{original_prompt}\n\n"
+                 "Using an agent system with the following description:\n{context}\n\n"
+                 "Refine or improve it to achieve the objective better."
+                 "Output the updated plan, beginning with:\nEDITED PLAN:\n"),
+        description="Prompt used in each iteration to refine the plan.")
+
+    @model_validator(mode="before")
+    def validate_iterative_strategies(cls, values: dict) -> dict:
+        if not values.get('editor_llm'):
+            raise ValueError('planning_llm must be provided for iterative plan refinement.')
+        if values.get('num_iterations', 0) < 1:
+            raise ValueError('num_iterations must be >= 1 for iterative plan refinement.')
+        return values
+
+
+class MotivationAwareSummarizationConfig(TTCStrategyBaseConfig, name="motivation_aware_editing"):
+    """
+    Configuration for the MotivationAwareSummarization strategy.
+    """
+    editor_llm: LLMRef | typing.Any | None = Field(
+        default=None,
+        description="The LLM to use for editing the plans. This can be a callable or an instance of an LLM client.")
+
+    editor_template: str = Field(
+        default=("You are an expert at summarizing key information from relevant documents based on an input task"
+                 "and motivation. Given a task and motivation, and documents, your task is to create a concise "
+                 "a summarized response to the task and motivation grounded in the documents .\n\n"
+                 "Here is the task:\n\n"
+                 "{task}\n\n"
+                 "Here is the motivation:\n\n"
+                 "{motivation}\n\n"
+                 "and here are the documents:\n\n"
+                 "{output}\n\n"
+                 "Please respond with a concise summary that addresses the task and motivation, in at most one"
+                 "or two sentences. Do not include any other output except the summary. "),
+        description="The template to use for summarizing documents.")

aiq/experimental/test_time_compute/models/scoring_config.py

@@ -0,0 +1,112 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed 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.
+
+import typing
+
+from pydantic import Field
+from pydantic import model_validator
+
+from aiq.data_models.component_ref import LLMRef
+from aiq.data_models.ttc_strategy import TTCStrategyBaseConfig
+
+
+class LLMBasedPlanScoringConfig(TTCStrategyBaseConfig, name="llm_based_plan_scoring"):
+    """
+    Configuration for LLMBasedScoring.
+    """
+    scoring_llm: LLMRef | typing.Any | None = Field(
+        default=None,
+        description="The LLM to use for scoring the plans. This can be a callable or an instance of an LLM client.")
+
+    scoring_template: str = Field(
+        default=("You are an expert reasoning model tasked with scoring the following execution plan based on its"
+                 "quality and relevance to the provided input to an agent system.\n\n"
+                 "The agent system's role is:\n{context}\n\n"
+                 "It has been tasked with achieving the following goal: \n{original_prompt}\n\n"
+                 "The following plan has been generated to achieve this goal:\n\n{plan}\n\n"
+                 "Score the plan on a scale from 1 to 10, where 10 is the best. "
+                 "Return the final score as a floating point number preceded by `FINAL SCORE:` without any "
+                 "other text before or after it\n"),
+        description="The template to use for scoring the plans.")
+
+    @model_validator(mode="before")
+    def validate_strategies(cls, values: dict[str, typing.Any]) -> dict[str, typing.Any]:
+        """
+        Ensure that the scoring_llm is provided when using LLMBasedScoring.
+        """
+        if values.get('scoring_llm') is None:
+            raise ValueError('scoring_llm must be provided when scorer_type is set to LLM_BASED_SCORING.')
+
+        return values
+
+
+class LLMBasedAgentScoringConfig(TTCStrategyBaseConfig, name="llm_based_agent_scoring"):
+    """
+    Configuration for LLMBasedScoring.
+    """
+    scoring_llm: LLMRef | typing.Any | None = Field(
+        default=None,
+        description="The LLM to use for scoring the plans. This can be a callable or an instance of an LLM client.")
+
+    scoring_template: str = Field(
+        description="Prompt template to use for scoring the function output",
+        default=("You are an expert reasoning model tasked with scoring the following "
+                 "result of an agent system based on its input and objective. Judge"
+                 " the quality and relevance of the answer to score it.\n\n"
+                 "The agent system's objective is:\n{objective}\n\n"
+                 "It has been tasked with achieving the following goal: \n{input}\n\n"
+                 "The following output has been generated by the agent:\n\n{output}\n\n"
+                 "Score the result on a scale from 1 to 10, where 10 is the best. "
+                 "Return the final score as a floating point number preceded by `FINAL SCORE:` without any "
+                 "other text before or after it\n"),
+    )
+
+    @model_validator(mode="before")
+    def validate_strategies(cls, values: dict[str, typing.Any]) -> dict[str, typing.Any]:
+        """
+        Ensure that the scoring_llm is provided when using LLMBasedScoring.
+        """
+        if values.get('scoring_llm') is None:
+            raise ValueError('scoring_llm must be provided when scorer_type is set to LLM_BASED_SCORING.')
+
+        return values
+
+
+class MotivationAwareScoringConfig(TTCStrategyBaseConfig, name="motivation_aware_scoring"):
+    """
+    Configuration for a scoring strategy that considers both the original input (task)
+    and the motivation (from metadata) along with the current output.
+    """
+
+    scoring_llm: LLMRef | None = Field(
+        default=None, description="The LLM used to evaluate how well the output addresses the task plus motivation.")
+
+    scoring_template: str = Field(
+        default=("You are an expert at assessing the quality of an output in relation to its task and motivation.\n"
+                 "Task: {task}\n"
+                 "Motivation: {motivation}\n"
+                 "Output: {output}\n"
+                 "On a scale from 1 to 10 (10 being the best), how well does this output fulfill "
+                 "the original task in the context "
+                 "of the provided motivation? Note that the task might answer one part of a bigger question "
+                 "which should count as a satisfactory response and should not receive a lower score.\n"
+                 "Return the final score as a floating point number preceded by 'FINAL SCORE:'."),
+        description="The prompt template used to evaluate and score the output.")
+
+    @model_validator(mode="before")
+    def validate_scoring_llm(cls, values):
+        if values.get('scoring_llm') is None:
+            raise ValueError("A scoring_llm must be provided for motivation_aware_scoring.")
+        return values

aiq/experimental/test_time_compute/models/search_config.py

@@ -0,0 +1,120 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed 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.
+
+import typing
+
+from pydantic import Field
+from pydantic import model_validator
+
+from aiq.data_models.component_ref import LLMRef
+from aiq.data_models.ttc_strategy import TTCStrategyBaseConfig
+
+
+class SingleShotMultiPlanConfig(TTCStrategyBaseConfig, name="single_shot_multi_plan"):
+    num_plans: int = Field(default=4, description="Number of plans to generate.")
+    max_temperature: float = Field(default=1.0,
+                                   description="Maximum temperature to use for sampling when generating plans. "
+                                   "This can help control the randomness of the generated plans.")
+    min_temperature: float = Field(default=0.5,
+                                   description="Minimum temperature to use for sampling when generating plans. "
+                                   "This can help control the randomness of the generated plans.")
+    # If strategy is provided, LLM must be
+    planning_llm: LLMRef | typing.Any | None = Field(
+        default=None,
+        description="The LLM to use for planning. This can be a callable or an "
+        "instance of an LLM client.")
+
+    planning_template: str = Field(
+        default=("You are an expert reasoning model task with creating a detailed execution plan"
+                 " for a system that has the following information to get the result of a given input:\n\n"
+                 "**System Information:**\n {context}"
+                 "**Input:** \n{prompt}\n\n"
+                 "An example plan could look like this:\n\n"
+                 "1. Call tool A with input X\n"
+                 "2. Call tool B with input Y\n"
+                 "3. Interpret the output of tool A and B\n"
+                 "4. Return the final result"
+                 "\n\nBegin the final plan with PLAN:\n"),
+        description="The template to use for generating plans.")
+
+    @model_validator(mode="before")
+    def validate_strategies(cls, values: dict[str, typing.Any]) -> dict[str, typing.Any]:
+        """
+        Ensure that the required LLMs are provided based on the selected strategies.
+        """
+        # Validate planning strategy: planning_llm must be provided if planning_strategy is set
+        if values.get('planning_llm') is None:
+            raise ValueError('planning_llm must be provided when planning_strategy is set.')
+
+        return values
+
+
+class MultiLLMPlanConfig(TTCStrategyBaseConfig, name="multi_llm_plan"):
+    """Configuration for a 'multi LLM plan generation' strategy."""
+    llms: list[LLMRef] = Field(
+        default_factory=list,
+        description="list of LLMs to use for plan generation. Each LLM can generate one or more plans.")
+    plans_per_llm: int = Field(default=2, description="Number of plans each LLM should generate.")
+    max_temperature: float = Field(default=1.0,
+                                   description="Maximum temperature to use for sampling when generating plans. "
+                                   "This can help control the randomness of the generated plans.")
+    min_temperature: float = Field(default=0.5,
+                                   description="Minimum temperature to use for sampling when generating plans. "
+                                   "This can help control the randomness of the generated plans.")
+    planning_template: str = Field(
+        default=("You are an expert reasoning model task with creating a detailed execution plan"
+                 " for a system that has the following information to get the result of a given input:\n\n"
+                 "**System Information:**\n {context}"
+                 "**Input:** \n{prompt}\n\n"
+                 "An example plan could look like this:\n\n"
+                 "1. Call tool A with input X\n"
+                 "2. Call tool B with input Y\n"
+                 "3. Interpret the output of tool A and B\n"
+                 "4. Return the final result"
+                 "\n\nBegin the final plan with PLAN:\n"),
+        description="The template to use for generating plans.")
+
+    @model_validator(mode="before")
+    def validate_multi_llm_strategies(cls, values: dict) -> dict:
+        if not values.get('llms'):
+            raise ValueError('Must provide at least one LLMRef in `llms` for multi-LLM strategy.')
+        return values
+
+
+class MultiQueryRetrievalSearchConfig(TTCStrategyBaseConfig, name="multi_query_retrieval_search"):
+    """
+    Configuration for the MultiQueryRetrievalSearch strategy.
+    This strategy generates multiple new 'TTCItem's per original item,
+    each containing a differently phrased or re-focused version of the original task.
+    """
+    llms: list[LLMRef] = Field(default_factory=list,
+                               description="list of LLM references to use for generating diverse queries.")
+
+    query_generation_template: str = Field(
+        default=("You are an expert at re-framing a user's query to encourage new solution paths. "
+                 "Given the task description and an optional motivation, produce a short alternative query "
+                 "that addresses the same task from a different angle. By generating multiple "
+                 "perspectives on the task, your goal is to help "
+                 "the user overcome some of the limitations of distance-based similarity search.\n\n"
+                 "Task: {task}\n"
+                 "Motivation: {motivation}\n\n"
+                 "Output a concise new query statement below. Only output the revised query and nothing else.\n"),
+        description="Prompt template for rewriting the task from a different perspective.")
+
+    @model_validator(mode="before")
+    def validate_llms(cls, values):
+        if not values.get('llms'):
+            raise ValueError("At least one LLMRef must be provided for multi_query_retrieval_search.")
+        return values