gnosisllm-knowledge 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

gnosisllm_knowledge/backends/opensearch/setup.py

@@ -249,7 +249,10 @@ class OpenSearchSetupAdapter:
             self._model_id = self._config.model_id
 
         # Step 4: Create ingest pipeline
-        if self._model_id:
+        # Only create ingest pipeline for global setup (not per-account)
+        # Account indices should use the global pipeline to ensure consistent model
+        is_global_setup = self._config.index_prefix == "gnosisllm"
+        if self._model_id and is_global_setup:
             try:
                 await self._create_ingest_pipeline()
                 pipeline_name = self._config.ingest_pipeline_name or f"{self._config.index_prefix}-ingest-pipeline"
@@ -258,28 +261,35 @@ class OpenSearchSetupAdapter:
                 errors.append(f"Failed to create ingest pipeline: {e}")
                 logger.error(f"Failed to create ingest pipeline: {e}")
 
-        # Step 5: Create search pipeline
-        try:
-            await self._create_search_pipeline()
-            pipeline_name = self._config.search_pipeline_name or f"{self._config.index_prefix}-search-pipeline"
-            steps_completed.append(f"Created search pipeline: {pipeline_name}")
-        except Exception as e:
-            errors.append(f"Failed to create search pipeline: {e}")
-            logger.error(f"Failed to create search pipeline: {e}")
+        # Step 5: Create search pipeline (only for global setup)
+        if is_global_setup:
+            try:
+                await self._create_search_pipeline()
+                pipeline_name = self._config.search_pipeline_name or f"{self._config.index_prefix}-search-pipeline"
+                steps_completed.append(f"Created search pipeline: {pipeline_name}")
+            except Exception as e:
+                errors.append(f"Failed to create search pipeline: {e}")
+                logger.error(f"Failed to create search pipeline: {e}")
 
-        # Step 6: Create index template
-        try:
-            template_name = f"{self._config.index_prefix}-template"
-            template_body = get_index_template(self._config)
+        # Step 6: Create index template (only for global setup)
+        # Template covers all gnosisllm-* indices including per-account indices
+        if is_global_setup:
+            try:
+                template_name = f"{self._config.index_prefix}-template"
+                template_body = get_index_template(self._config)
 
-            await self._client.indices.put_index_template(
-                name=template_name,
-                body=template_body,
-            )
-            steps_completed.append(f"Created index template: {template_name}")
-        except Exception as e:
-            errors.append(f"Failed to create index template: {e}")
-            logger.error(f"Failed to create index template: {e}")
+                # Ensure template has global pipeline for auto-index creation
+                global_pipeline = self._config.ingest_pipeline_name or "gnosisllm-ingest-pipeline"
+                template_body["template"]["settings"]["index"]["default_pipeline"] = global_pipeline
+
+                await self._client.indices.put_index_template(
+                    name=template_name,
+                    body=template_body,
+                )
+                steps_completed.append(f"Created index template: {template_name}")
+            except Exception as e:
+                errors.append(f"Failed to create index template: {e}")
+                logger.error(f"Failed to create index template: {e}")
 
         # Step 7: Create knowledge index
         try:
@@ -288,8 +298,9 @@ class OpenSearchSetupAdapter:
 
             if not exists:
                 settings = get_knowledge_index_settings(self._config)
-                # Add default pipeline
-                pipeline_name = self._config.ingest_pipeline_name or f"{self._config.index_prefix}-ingest-pipeline"
+                # Add default pipeline - always use global pipeline for consistency
+                # This ensures all accounts use the same embedding model
+                pipeline_name = self._config.ingest_pipeline_name or "gnosisllm-ingest-pipeline"
                 settings["index"]["default_pipeline"] = pipeline_name
 
                 await self._client.indices.create(
@@ -346,6 +357,7 @@ class OpenSearchSetupAdapter:
         if not self._config.openai_api_key:
             raise SetupError(
                 message="OPENAI_API_KEY required to create connector",
+                step="connector",
                 details={"hint": "Set OPENAI_API_KEY environment variable"},
             )
 
@@ -442,12 +454,18 @@ class OpenSearchSetupAdapter:
 
         task_id = response.get("task_id")
         if not task_id:
-            raise SetupError(message="No task_id returned from model registration")
+            raise SetupError(
+                message="No task_id returned from model registration",
+                step="model_deployment",
+            )
 
         # Wait for registration
         model_id = await self._wait_for_task(task_id, "model registration")
         if not model_id:
-            raise SetupError(message="Model registration timed out")
+            raise SetupError(
+                message="Model registration timed out",
+                step="model_deployment",
+            )
 
         self._model_id = model_id
 
@@ -512,37 +530,44 @@ class OpenSearchSetupAdapter:
     async def cleanup(self) -> SetupResult:
         """Clean up all resources in correct order.
 
+        Deletes all indices and templates matching the index prefix pattern.
+
         Returns:
             Cleanup result.
         """
         steps_completed: list[str] = []
         errors: list[str] = []
+        prefix = self._config.index_prefix
 
-        # Delete knowledge index
-        try:
-            index_name = self._config.knowledge_index_name
-            if await self._client.indices.exists(index=index_name):
-                await self._client.indices.delete(index=index_name)
-                steps_completed.append(f"Deleted index: {index_name}")
-        except Exception as e:
-            errors.append(f"Failed to delete knowledge index: {e}")
-
-        # Delete memory index
+        # Delete all indices matching prefix-*
         try:
-            memory_index = self._config.agentic_memory_index_name
-            if await self._client.indices.exists(index=memory_index):
-                await self._client.indices.delete(index=memory_index)
-                steps_completed.append(f"Deleted index: {memory_index}")
-        except Exception as e:
-            errors.append(f"Failed to delete memory index: {e}")
+            index_pattern = f"{prefix}-*"
+            # Check if any indices match the pattern
+            indices_response = await self._client.indices.get(index=index_pattern)
+            if indices_response:
+                for index_name in indices_response.keys():
+                    try:
+                        await self._client.indices.delete(index=index_name)
+                        steps_completed.append(f"Deleted index: {index_name}")
+                    except Exception as e:
+                        logger.warning(f"Failed to delete index {index_name}: {e}")
+        except Exception:
+            pass  # No matching indices
 
-        # Delete index template
+        # Delete all index templates matching prefix-*
         try:
-            template_name = f"{self._config.index_prefix}-template"
-            await self._client.indices.delete_index_template(name=template_name)
-            steps_completed.append(f"Deleted template: {template_name}")
+            templates_response = await self._client.indices.get_index_template(name=f"{prefix}-*")
+            if templates_response and "index_templates" in templates_response:
+                for template_info in templates_response["index_templates"]:
+                    template_name = template_info.get("name")
+                    if template_name:
+                        try:
+                            await self._client.indices.delete_index_template(name=template_name)
+                            steps_completed.append(f"Deleted template: {template_name}")
+                        except Exception as e:
+                            logger.warning(f"Failed to delete template {template_name}: {e}")
         except Exception:
-            pass  # May not exist
+            pass  # No matching templates
 
         # Delete search pipeline
         try:
@@ -835,6 +860,7 @@ class OpenSearchSetupAdapter:
         except Exception as e:
             raise SetupError(
                 message=f"Failed to get cluster stats: {e}",
+                step="cluster_stats",
                 cause=e,
             ) from e
 
@@ -865,17 +891,71 @@ class OpenSearchSetupAdapter:
         except Exception as e:
             raise SetupError(
                 message=f"Failed to get index stats: {e}",
+                step="index_stats",
                 details={"index_name": index_name},
                 cause=e,
             ) from e
 
     # === Agentic Search Setup Methods ===
 
+    async def enable_agentic_search(self) -> None:
+        """Enable agentic search cluster settings.
+
+        The agent framework is enabled by default in OpenSearch 3.x.
+        This method verifies that required settings are enabled.
+
+        Note: The settings plugins.ml_commons.agentic_search_enabled and
+        plugins.neural_search.agentic_search_enabled do not exist in
+        OpenSearch 3.4+. The agent_framework_enabled and rag_pipeline_feature_enabled
+        settings are used instead and are enabled by default.
+
+        Raises:
+            SetupError: If required settings are not enabled.
+        """
+        try:
+            # Check if agent framework is enabled (required for agents)
+            settings = await self._client.cluster.get_settings(
+                include_defaults=True,
+                flat_settings=True,
+            )
+            defaults = settings.get("defaults", {})
+
+            agent_enabled = defaults.get(
+                "plugins.ml_commons.agent_framework_enabled", "false"
+            )
+            rag_enabled = defaults.get(
+                "plugins.ml_commons.rag_pipeline_feature_enabled", "false"
+            )
+
+            if agent_enabled != "true":
+                raise SetupError(
+                    message="Agent framework is not enabled. Set plugins.ml_commons.agent_framework_enabled=true",
+                    step="enable_agentic_search",
+                )
+
+            if rag_enabled != "true":
+                logger.warning("RAG pipeline feature is not enabled, some features may be limited")
+
+            logger.info("Agent framework is enabled (agentic search ready)")
+        except SetupError:
+            raise
+        except Exception as e:
+            raise SetupError(
+                message=f"Failed to verify agentic search settings: {e}",
+                step="enable_agentic_search",
+                cause=e,
+            ) from e
+
     async def setup_flow_agent(self) -> str:
-        """Create and deploy flow agent for fast RAG.
+        """Create flow agent with RAGTool for agentic search.
+
+        Flow agents use RAGTool to perform retrieval-augmented generation:
+        1. Search the knowledge base using neural/semantic search
+        2. Pass results to LLM for answer generation
+        3. Return AI-generated answer with source citations
 
-        Flow agents provide single-turn RAG with minimal reasoning overhead.
-        They're optimized for quick responses and API use cases.
+        This provides a conversational experience where users get natural
+        language answers instead of raw search results.
 
         Returns:
             Agent ID of the created/existing flow agent.
@@ -891,27 +971,38 @@ class OpenSearchSetupAdapter:
             logger.info(f"Using existing flow agent: {existing}")
             return existing
 
-        # Validate prerequisites
-        if not self._config.model_id and not self._model_id:
+        # Enable agentic search if not already enabled
+        await self.enable_agentic_search()
+
+        # Create LLM model for answer generation
+        llm_model_id = await self._setup_llm_model()
+
+        # Get embedding model ID for neural search
+        embedding_model_id = self._model_id or self._config.model_id
+        if not embedding_model_id:
             raise SetupError(
-                message="Embedding model not configured",
+                message="Embedding model ID is required for RAGTool. Run 'gnosisllm-knowledge setup' first.",
                 step="flow_agent",
-                details={"hint": "Run 'gnosisllm-knowledge setup' first to deploy the embedding model."},
             )
 
-        # Create LLM connector and model for reasoning
-        llm_model_id = await self._setup_llm_model()
+        # Index pattern for multi-tenant knowledge bases
+        # Matches: gnosisllm-<account_id>-knowledge
+        index_pattern = f"{self._config.index_prefix}-*-knowledge"
 
-        # Create tool configurations
-        vector_tool = self._create_vector_db_tool_config()
-        answer_tool = self._create_answer_generator_tool_config(llm_model_id)
+        # Create RAGTool configuration
+        rag_tool = self._create_rag_tool_config(
+            embedding_model_id=embedding_model_id,
+            llm_model_id=llm_model_id,
+            index_pattern=index_pattern,
+        )
 
-        # Register flow agent with both search and answer generation tools
+        # Register flow agent with RAGTool
+        # Flow agents execute tools sequentially and return the last tool's output
         agent_body = {
             "name": agent_name,
             "type": "flow",
-            "description": "Fast RAG agent for GnosisLLM Knowledge - optimized for single-turn queries",
-            "tools": [vector_tool, answer_tool],
+            "description": "Agentic search agent for GnosisLLM Knowledge - uses RAGTool for conversational AI answers",
+            "tools": [rag_tool],
         }
 
         try:
@@ -921,7 +1012,7 @@ class OpenSearchSetupAdapter:
                 body=agent_body,
             )
             agent_id = response.get("agent_id")
-            logger.info(f"Created flow agent: {agent_id}")
+            logger.info(f"Created flow agent with RAGTool: {agent_id}")
             return agent_id
         except Exception as e:
             raise SetupError(
@@ -931,10 +1022,11 @@ class OpenSearchSetupAdapter:
             ) from e
 
     async def setup_conversational_agent(self) -> str:
-        """Create and deploy conversational agent with memory.
+        """Create conversational agent with RAGTool and memory.
 
         Conversational agents support multi-turn dialogue with memory
-        persistence. They maintain context across interactions.
+        persistence. They use RAGTool to search and generate AI answers,
+        providing a chat-like experience with context from previous turns.
 
         Returns:
             Agent ID of the created/existing conversational agent.
@@ -950,41 +1042,43 @@ class OpenSearchSetupAdapter:
             logger.info(f"Using existing conversational agent: {existing}")
             return existing
 
-        # Validate prerequisites
-        if not self._config.model_id and not self._model_id:
+        # Enable agentic search if not already enabled
+        await self.enable_agentic_search()
+
+        # Create LLM model for answer generation
+        llm_model_id = await self._setup_llm_model()
+
+        # Get embedding model ID for neural search
+        embedding_model_id = self._model_id or self._config.model_id
+        if not embedding_model_id:
             raise SetupError(
-                message="Embedding model not configured",
+                message="Embedding model ID is required for RAGTool. Run 'gnosisllm-knowledge setup' first.",
                 step="conversational_agent",
-                details={"hint": "Run 'gnosisllm-knowledge setup' first to deploy the embedding model."},
             )
 
-        # Create LLM connector and model for reasoning
-        llm_model_id = await self._setup_llm_model()
+        # Index pattern for multi-tenant knowledge bases
+        index_pattern = f"{self._config.index_prefix}-*-knowledge"
 
-        # Create tool configurations
-        # Conversational agent uses chat_history in prompt for multi-turn support
-        vector_tool = self._create_vector_db_tool_config()
-        answer_tool = self._create_answer_generator_tool_config(
-            llm_model_id, include_chat_history=True
+        # Create RAGTool configuration
+        rag_tool = self._create_rag_tool_config(
+            embedding_model_id=embedding_model_id,
+            llm_model_id=llm_model_id,
+            index_pattern=index_pattern,
         )
 
-        # Register conversational flow agent with memory and both tools
-        # Using "conversational_flow" type which:
-        # - Executes tools sequentially like flow agent
-        # - Supports conversation memory for multi-turn dialogue
-        # - Injects chat_history from memory when message_history_limit > 0
+        # Register conversational agent with memory support
+        # Use conversational_flow type for simpler tool execution without ReAct prompting
         agent_body = {
             "name": agent_name,
             "type": "conversational_flow",
-            "app_type": "rag",
-            "description": "Conversational agent with memory for GnosisLLM Knowledge - supports multi-turn dialogue",
+            "description": "Conversational agentic search for GnosisLLM Knowledge - multi-turn dialogue with memory and AI answers",
             "llm": {
                 "model_id": llm_model_id,
                 "parameters": {
-                    "message_history_limit": 10,  # Include last 10 messages as chat_history
+                    "max_iteration": str(self._config.agentic_max_iterations),
                 },
             },
-            "tools": [vector_tool, answer_tool],
+            "tools": [rag_tool],
             "memory": {
                 "type": "conversation_index",
             },
@@ -997,7 +1091,7 @@ class OpenSearchSetupAdapter:
                 body=agent_body,
             )
             agent_id = response.get("agent_id")
-            logger.info(f"Created conversational agent: {agent_id}")
+            logger.info(f"Created conversational agent with RAGTool: {agent_id}")
             return agent_id
         except Exception as e:
             raise SetupError(
@@ -1007,14 +1101,18 @@ class OpenSearchSetupAdapter:
             ) from e
 
     async def setup_agents(self, agent_types: list[str] | None = None) -> dict[str, str]:
-        """Setup agentic search agents.
+        """Setup agentic search agents with RAGTool.
+
+        Creates agents using RAGTool for retrieval-augmented generation.
+        Agents search the knowledge base and generate AI-powered answers.
+        Also creates an agentic search pipeline for the flow agent.
 
         Args:
             agent_types: List of agent types to setup ('flow', 'conversational').
                         If None, sets up all agent types.
 
         Returns:
-            Dictionary mapping agent type to agent ID.
+            Dictionary mapping agent type to agent ID, plus agentic_pipeline_name.
 
         Raises:
             SetupError: If any agent creation fails.
@@ -1025,7 +1123,13 @@ class OpenSearchSetupAdapter:
         results: dict[str, str] = {}
 
         if "flow" in agent_types:
-            results["flow_agent_id"] = await self.setup_flow_agent()
+            flow_agent_id = await self.setup_flow_agent()
+            results["flow_agent_id"] = flow_agent_id
+
+            # Create agentic search pipeline for the flow agent
+            # This allows using agentic search via standard _search API
+            pipeline_name = await self.setup_agentic_search_pipeline(flow_agent_id)
+            results["agentic_pipeline_name"] = pipeline_name
 
         if "conversational" in agent_types:
             results["conversational_agent_id"] = await self.setup_conversational_agent()
@@ -1033,7 +1137,7 @@ class OpenSearchSetupAdapter:
         return results
 
     async def cleanup_agents(self) -> SetupResult:
-        """Clean up agentic search agents.
+        """Clean up agentic search agents and pipelines.
 
         Returns:
             Cleanup result with steps completed.
@@ -1041,6 +1145,17 @@ class OpenSearchSetupAdapter:
         steps_completed: list[str] = []
         errors: list[str] = []
 
+        # Delete agentic search pipeline first
+        pipeline_name = f"{self._config.index_prefix}-agentic-pipeline"
+        try:
+            await self._client.transport.perform_request(
+                "DELETE",
+                f"/_search/pipeline/{pipeline_name}",
+            )
+            steps_completed.append(f"Deleted agentic pipeline: {pipeline_name}")
+        except Exception:
+            pass  # Pipeline may not exist
+
         # Delete flow agent
         flow_agent_name = f"{self._config.index_prefix}-flow-agent"
         flow_agent_id = await self._find_agent_by_name(flow_agent_name)
@@ -1104,93 +1219,135 @@ class OpenSearchSetupAdapter:
             errors=errors if errors else None,
         )
 
-    def _create_vector_db_tool_config(self) -> dict[str, Any]:
-        """Create VectorDBTool configuration for knowledge search.
+    def _create_rag_tool_config(
+        self,
+        embedding_model_id: str,
+        llm_model_id: str,
+        index_pattern: str,
+    ) -> dict[str, Any]:
+        """Create RAGTool configuration for agentic search.
+
+        RAGTool (OpenSearch 2.13+) performs retrieval-augmented generation:
+        1. Searches the index using neural/semantic search
+        2. Passes results to LLM for answer generation
+        3. Returns AI-generated answer with source citations
+
+        This provides a conversational experience where users get natural
+        language answers instead of raw search results.
 
-        The tool uses ${parameters.question} to get the user's query from
-        the agent execution parameters.
+        Args:
+            embedding_model_id: Embedding model ID for neural search.
+            llm_model_id: LLM model ID for answer generation.
+            index_pattern: Index pattern to search (supports wildcards).
 
         Returns:
             Tool configuration dictionary.
         """
-        embedding_model_id = self._model_id or self._config.model_id
-        # Use wildcard pattern to search all collection indices
-        # Format: {index_prefix}-knowledge-* (e.g., gnosisllm-knowledge-*)
-        index_pattern = f"{self._config.index_prefix}-knowledge-*"
+        # Prompt template for RAGTool - instructs LLM how to use retrieved context
+        # RAGTool fills ${parameters.output:-} with search results
+        prompt_template = (
+            "You are a helpful assistant. Use the following context to answer the question. "
+            "If the context doesn't contain enough information, say so.\n\n"
+            "Context:\n${parameters.output:-}\n\n"
+            "Question: ${parameters.question}\n\n"
+            "Answer:"
+        )
+
         return {
-            "type": "VectorDBTool",
+            "type": "RAGTool",
             "name": "knowledge_search",
-            "description": "Search the knowledge base for relevant information. "
-                          "Use this tool to find documents related to user questions.",
+            "description": "Search knowledge base and generate AI answer. "
+                          "Retrieves relevant documents and synthesizes a natural language response.",
             "parameters": {
-                "input": "${parameters.question}",
+                "embedding_model_id": embedding_model_id,
+                "inference_model_id": llm_model_id,
                 "index": index_pattern,
                 "embedding_field": self._config.embedding_field,
-                "source_field": '["content", "title", "url", "source", "collection_id"]',
-                "model_id": embedding_model_id,
+                "source_field": '["content", "title", "url"]',
+                "doc_size": "5",
+                "query_type": "neural",
+                "input": "${parameters.question}",
+                "prompt": prompt_template,
             },
         }
 
-    def _create_answer_generator_tool_config(
-        self, llm_model_id: str, include_chat_history: bool = False
+    def _create_query_planning_tool_config(
+        self, llm_model_id: str
     ) -> dict[str, Any]:
-        """Create MLModelTool configuration for answer generation.
+        """Create QueryPlanningTool configuration for agentic search.
+
+        QueryPlanningTool (OpenSearch 3.2+) translates natural language queries
+        into OpenSearch DSL. The LLM decides the optimal query type based on
+        user intent - keyword, neural, hybrid, or complex aggregations.
+
+        NOTE: QueryPlanningTool only generates DSL - it does NOT generate answers.
+        Use RAGTool for conversational experience with AI-generated answers.
 
         Args:
-            llm_model_id: LLM model ID for answer generation.
-            include_chat_history: Include chat_history placeholder for conversational agents.
+            llm_model_id: LLM model ID for query generation.
 
         Returns:
             Tool configuration dictionary.
         """
-        if include_chat_history:
-            # Conversational prompt with chat_history for multi-turn support
-            # ${parameters.chat_history:-} is populated by OpenSearch from memory
-            prompt = """You are a helpful assistant that answers questions based on provided context and conversation history.
-
-Context from knowledge base:
-${parameters.knowledge_search.output}
+        # Response filter extracts generated DSL from OpenAI chat completions format
+        # Format: {"choices": [{"message": {"content": "<DSL JSON>"}}]}
+        response_filter = "$.choices[0].message.content"
 
-Previous conversation:
-${parameters.chat_history:-}
-
-Question: ${parameters.question}
-
-Instructions:
-- Use conversation history to understand follow-up questions
-- Answer based on the context and conversation history
-- If the answer is not available, say "I don't have enough information to answer this question."
-- Be concise and accurate
-- Cite sources when possible
+        return {
+            "type": "QueryPlanningTool",
+            "name": "query_planner",
+            "description": "Generate OpenSearch DSL queries from natural language. "
+                          "Supports keyword search, neural/semantic search, hybrid search, "
+                          "and complex aggregations based on user intent.",
+            "parameters": {
+                "model_id": llm_model_id,
+                "response_filter": response_filter,
+            },
+        }
 
-Answer:"""
-        else:
-            # Simple prompt for flow agents (no conversation history)
-            prompt = """You are a helpful assistant that answers questions based on provided context.
+    async def setup_agentic_search_pipeline(self, agent_id: str) -> str:
+        """Create search pipeline with agentic query translator.
 
-Context from knowledge base:
-${parameters.knowledge_search.output}
+        This pipeline allows using agentic search via the standard
+        _search API by translating natural language to DSL.
 
-Question: ${parameters.question}
+        Args:
+            agent_id: Agent ID to use for query translation.
 
-Instructions:
-- Answer based ONLY on the context provided above
-- If the answer is not in the context, say "I don't have enough information to answer this question."
-- Be concise and accurate
-- Cite sources when possible using the URLs provided
+        Returns:
+            Pipeline name.
 
-Answer:"""
+        Raises:
+            SetupError: If pipeline creation fails.
+        """
+        pipeline_name = f"{self._config.index_prefix}-agentic-pipeline"
 
-        return {
-            "type": "MLModelTool",
-            "name": "answer_generator",
-            "description": "Generate a natural language answer from search results",
-            "parameters": {
-                "model_id": llm_model_id,
-                "prompt": prompt,
-            },
+        pipeline_body = {
+            "description": "GnosisLLM agentic search pipeline - translates natural language to DSL",
+            "request_processors": [
+                {
+                    "agentic_query_translator": {
+                        "agent_id": agent_id,
+                    }
+                }
+            ],
         }
 
+        try:
+            await self._client.transport.perform_request(
+                "PUT",
+                f"/_search/pipeline/{pipeline_name}",
+                body=pipeline_body,
+            )
+            logger.info(f"Created agentic search pipeline: {pipeline_name}")
+            return pipeline_name
+        except Exception as e:
+            raise SetupError(
+                message=f"Failed to create agentic search pipeline: {e}",
+                step="agentic_pipeline",
+                cause=e,
+            ) from e
+
     async def _setup_llm_model(self) -> str:
         """Setup LLM model for agent reasoning.
 
@@ -1275,6 +1432,8 @@ Answer:"""
                 details={"hint": "Set OPENAI_API_KEY environment variable"},
             )
 
+        # Connector for RAGTool uses 'prompt' parameter
+        # See: https://docs.opensearch.org/latest/ml-commons-plugin/agents-tools/tools/rag-tool/
         connector_body = {
             "name": connector_name,
             "description": f"OpenAI {self._config.agentic_llm_model} connector for agent reasoning",
@@ -1295,7 +1454,8 @@ Answer:"""
                         "Authorization": "Bearer ${credential.openAI_key}",
                         "Content-Type": "application/json",
                     },
-                    "request_body": '{ "model": "${parameters.model}", "messages": [{"role": "user", "content": "${parameters.prompt}"}], "temperature": ${parameters.temperature:-0} }',
+                    # RAGTool sends 'prompt' containing question + retrieved context
+                    "request_body": '{ "model": "${parameters.model}", "messages": [{"role": "user", "content": "${parameters.prompt}"}] }',
                 },
             ],
         }