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

gnosisllm_knowledge/backends/__init__.py

@@ -9,18 +9,27 @@ from gnosisllm_knowledge.backends.opensearch import (
     OpenSearchKnowledgeSearcher,
     OpenSearchSetupAdapter,
 )
+from gnosisllm_knowledge.backends.opensearch.memory import (
+    MemoryConfig,
+    MemorySetup,
+    OpenSearchMemoryClient,
+)
 from gnosisllm_knowledge.backends.opensearch.queries import QueryBuilder
 
 __all__ = [
+    "AgenticSearchFallback",
+    # OpenSearch Memory
+    "MemoryConfig",
+    # Memory (for testing)
+    "MemoryIndexer",
+    "MemorySearcher",
+    "MemorySetup",
+    "OpenSearchAgenticSearcher",
     # OpenSearch
     "OpenSearchConfig",
     "OpenSearchIndexer",
     "OpenSearchKnowledgeSearcher",
+    "OpenSearchMemoryClient",
     "OpenSearchSetupAdapter",
-    "OpenSearchAgenticSearcher",
-    "AgenticSearchFallback",
     "QueryBuilder",
-    # Memory (for testing)
-    "MemoryIndexer",
-    "MemorySearcher",
 ]

gnosisllm_knowledge/backends/opensearch/agentic.py

@@ -96,11 +96,12 @@ class OpenSearchAgenticSearcher:
     ) -> AgenticSearchResult:
         """Execute agentic search with agent orchestration.
 
-        The flow:
+        The flow with RAGTool:
         1. Select agent based on query.agent_type
         2. Build execution request with query and filters
         3. Execute agent via OpenSearch ML API
-        4. Parse response for answer, reasoning, and results
+        4. RAGTool searches the index and generates an AI answer
+        5. Parse response for answer, reasoning, and source documents
 
         Args:
             query: Agentic search query with agent type and context.
@@ -121,7 +122,7 @@ class OpenSearchAgenticSearcher:
             raise AgenticSearchError(
                 message=f"Agent not configured for type: {query.agent_type.value}",
                 agent_type=query.agent_type.value,
-                details={"hint": "Run 'gnosisllm-knowledge agentic setup' to configure agents."},
+                details={"hint": "Run 'gnosisllm-knowledge agentic setup --force' to configure agents."},
             )
 
         # Build execution request
@@ -133,15 +134,114 @@ class OpenSearchAgenticSearcher:
                 "agent_id": agent_id,
                 "agent_type": query.agent_type.value,
                 "query": query.text[:100],
+                "index_name": index_name,
             },
         )
 
-        # Execute agent
-        response = await self._execute_agent(agent_id, execute_body)
+        # Execute agent - RAGTool handles search AND answer generation
+        agent_response = await self._execute_agent(agent_id, execute_body)
 
         duration_ms = (datetime.now(UTC) - start).total_seconds() * 1000
 
-        return self._parse_agentic_response(query, response, duration_ms)
+        return self._parse_rag_response(query, agent_response, duration_ms)
+
+    def _parse_rag_response(
+        self,
+        query: AgenticSearchQuery,
+        response: dict[str, Any],
+        duration_ms: float,
+    ) -> AgenticSearchResult:
+        """Parse RAGTool response into AgenticSearchResult.
+
+        RAGTool returns both an AI-generated answer and source documents.
+
+        Response format:
+        {
+            "inference_results": [
+                {
+                    "output": [
+                        {"name": "knowledge_search", "result": "<LLM answer>"}
+                    ]
+                }
+            ]
+        }
+
+        Args:
+            query: The original query.
+            response: Agent execution response.
+            duration_ms: Total execution duration.
+
+        Returns:
+            Parsed AgenticSearchResult with answer and sources.
+        """
+        answer: str | None = None
+        reasoning_steps: list[ReasoningStep] = []
+        items: list[SearchResultItem] = []
+        conversation_id = response.get("memory_id")
+
+        # Parse inference results
+        inference_results = response.get("inference_results", [])
+        if inference_results:
+            outputs = inference_results[0].get("output", [])
+
+            for output in outputs:
+                name = output.get("name", "")
+                result = output.get("result", "")
+
+                # Handle dataAsMap structure
+                data_as_map = output.get("dataAsMap", {})
+                if data_as_map and "response" in data_as_map:
+                    result = data_as_map.get("response", result)
+
+                if name == "memory_id":
+                    conversation_id = str(result) if result else None
+                elif name in ("knowledge_search", "RAGTool", "response"):
+                    # RAGTool returns the LLM-generated answer
+                    answer = self._extract_answer_from_result(result)
+
+                    if query.include_reasoning:
+                        reasoning_steps.append(
+                            ReasoningStep(
+                                tool="RAGTool",
+                                action="rag_search",
+                                input=query.text,
+                                output=answer[:200] if answer else None,
+                                duration_ms=duration_ms,
+                            )
+                        )
+
+            # Extract source documents if available in the response
+            for output in outputs:
+                name = output.get("name", "")
+                result = output.get("result", "")
+
+                # Try to extract source documents from additional_info or similar
+                additional_info = output.get("additional_info", {})
+                if additional_info:
+                    hits = additional_info.get("hits", {})
+                    if hits:
+                        items.extend(self._parse_opensearch_hits(hits))
+
+        # If no answer from structured output, try raw response
+        if not answer and "response" in response:
+            answer = response.get("response")
+
+        # Preserve the query's conversation_id if agent didn't return one
+        final_conversation_id = conversation_id or query.conversation_id
+
+        return AgenticSearchResult(
+            query=query.text,
+            mode=SearchMode.AGENTIC,
+            items=items,
+            total_hits=len(items),
+            duration_ms=duration_ms,
+            max_score=items[0].score if items else None,
+            answer=answer,
+            reasoning_steps=reasoning_steps,
+            conversation_id=final_conversation_id,
+            agent_type=query.agent_type,
+            citations=[item.doc_id for item in items[:5]],
+        )
 
     async def get_conversation(
         self,
@@ -317,17 +417,18 @@ class OpenSearchAgenticSearcher:
     ) -> dict[str, Any]:
         """Build agent execution request.
 
-        Only includes parameters that the agent actually uses:
+        RAGTool requires:
         - question: The user's query (required)
-        - memory_id: For conversation continuity (conversational agents)
-        - message_history_limit: Number of historical messages to include
 
-        Note: VectorDBTool's index and model_id are configured in the agent,
-        not passed at runtime. Extra parameters cause IllegalArgumentException.
+        The index is configured at agent creation time, not at execution time.
+        RAGTool searches the configured index and generates an AI answer.
+
+        Conversational agents also support:
+        - memory_id: For conversation continuity
 
         Args:
             query: The agentic search query.
-            index_name: Target index name (not used - agent has hardcoded index).
+            index_name: Target index name (for logging, not used by RAGTool).
 
         Returns:
             Request body for agent execution.
@@ -339,7 +440,6 @@ class OpenSearchAgenticSearcher:
         }
 
         # Add conversation context for conversational agents
-        # OpenSearch handles memory injection automatically with app_type=rag
         if query.agent_type == AgentType.CONVERSATIONAL and query.conversation_id:
             request["parameters"]["memory_id"] = query.conversation_id
 
@@ -386,32 +486,155 @@ class OpenSearchAgenticSearcher:
                 cause=e,
             )
 
+    def _extract_dsl_from_agent_response(
+        self,
+        response: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        """Extract generated DSL query from agent response.
+
+        The flow agent with QueryPlanningTool returns the DSL in the output.
+        Format: {"inference_results": [{"output": [{"name": "response", "result": "<DSL JSON>"}]}]}
+
+        Args:
+            response: Agent execution response.
+
+        Returns:
+            Parsed DSL query dict, or None if not found.
+        """
+        try:
+            inference_results = response.get("inference_results", [])
+            if not inference_results:
+                return None
+
+            outputs = inference_results[0].get("output", [])
+            for output in outputs:
+                name = output.get("name", "")
+                result = output.get("result", "")
+
+                # QueryPlanningTool outputs come as "response" or "query_planner"
+                if name in ("response", "query_planner", "QueryPlanningTool"):
+                    if isinstance(result, dict):
+                        return result
+                    if isinstance(result, str) and result.strip():
+                        # Try to parse as JSON
+                        return self._parse_dsl_string(result)
+
+            return None
+        except Exception as e:
+            self._logger.warning(f"Failed to extract DSL from agent response: {e}")
+            return None
+
+    def _parse_dsl_string(self, dsl_string: str) -> dict[str, Any] | None:
+        """Parse a DSL query string into a dictionary.
+
+        Handles various formats:
+        - Raw JSON
+        - Markdown code blocks
+        - JSON with surrounding text
+
+        Args:
+            dsl_string: The DSL query as a string.
+
+        Returns:
+            Parsed DSL query dict, or None if parsing fails.
+        """
+        dsl_string = dsl_string.strip()
+
+        # Remove markdown code blocks if present
+        if dsl_string.startswith("```"):
+            lines = dsl_string.split("\n")
+            # Remove first line (```json or ```)
+            lines = lines[1:] if lines else []
+            # Remove last line (```)
+            if lines and lines[-1].strip() == "```":
+                lines = lines[:-1]
+            dsl_string = "\n".join(lines).strip()
+
+        # Try to find and parse JSON
+        try:
+            # Find the first { and last }
+            start = dsl_string.find("{")
+            end = dsl_string.rfind("}") + 1
+            if start >= 0 and end > start:
+                json_str = dsl_string[start:end]
+                return json.loads(json_str)
+        except json.JSONDecodeError as e:
+            self._logger.debug(f"Failed to parse DSL JSON: {e}")
+
+        # Try parsing the whole string
+        try:
+            return json.loads(dsl_string)
+        except json.JSONDecodeError:
+            pass
+
+        return None
+
+    async def _execute_dsl_query(
+        self,
+        index_name: str,
+        dsl_query: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Execute a DSL query against the index.
+
+        Args:
+            index_name: Target index name.
+            dsl_query: OpenSearch DSL query to execute.
+
+        Returns:
+            Search response with hits.
+
+        Raises:
+            AgenticSearchError: If query execution fails.
+        """
+        try:
+            response = await self._client.search(
+                index=index_name,
+                body=dsl_query,
+            )
+            return response
+        except Exception as e:
+            self._logger.error(f"DSL query execution failed: {e}")
+            raise AgenticSearchError(
+                message=f"Failed to execute generated DSL query: {e}",
+                details={"index_name": index_name, "query": str(dsl_query)[:200]},
+                cause=e,
+            )
+
     def _parse_agentic_response(
         self,
         query: AgenticSearchQuery,
-        response: dict[str, Any],
+        agent_response: dict[str, Any],
         duration_ms: float,
+        search_response: dict[str, Any] | None = None,
+        generated_dsl: dict[str, Any] | None = None,
     ) -> AgenticSearchResult:
         """Parse agent response into AgenticSearchResult.
 
-        The response structure from OpenSearch ML agents:
-        {
-            "inference_results": [
-                {
-                    "output": [
-                        {"name": "response", "result": "The answer..."},
-                        {"name": "knowledge_search", "result": {...}}
-                    ]
-                }
-            ],
-            "memory_id": "...",
-            ...
-        }
+        Supports two response formats:
+
+        1. QueryPlanningTool (OpenSearch 3.2+):
+           The agent generates DSL queries which we then execute.
+           Agent response: {"inference_results": [{"output": [{"name": "response", "result": "<DSL JSON>"}]}]}
+           Search response: Standard OpenSearch search response with hits.
+
+        2. Legacy VectorDBTool + MLModelTool:
+           {
+               "inference_results": [
+                   {
+                       "output": [
+                           {"name": "knowledge_search", "result": {...}},
+                           {"name": "answer_generator", "result": "..."}
+                       ]
+                   }
+               ]
+           }
 
         Args:
             query: The original query.
-            response: Agent execution response.
+            agent_response: Agent execution response.
             duration_ms: Total execution duration.
+            search_response: Search results from executing the generated DSL (optional).
+            generated_dsl: The DSL query generated by the agent (optional).
 
         Returns:
             Parsed AgenticSearchResult.
@@ -419,13 +642,40 @@ class OpenSearchAgenticSearcher:
         answer: str | None = None
         reasoning_steps: list[ReasoningStep] = []
         items: list[SearchResultItem] = []
-        conversation_id = response.get("memory_id")
+        conversation_id = agent_response.get("memory_id")
+        dsl_string: str | None = None
         total_tokens = 0
         prompt_tokens = 0
         completion_tokens = 0
 
-        # Parse inference results
-        inference_results = response.get("inference_results", [])
+        # Parse search results from executed DSL query first (QueryPlanningTool flow)
+        if search_response:
+            hits_data = search_response.get("hits", {})
+            items.extend(self._parse_opensearch_hits(hits_data))
+
+            if query.include_reasoning:
+                dsl_string = json.dumps(generated_dsl) if generated_dsl else None
+                reasoning_steps.append(
+                    ReasoningStep(
+                        tool="QueryPlanningTool",
+                        action="query_generation",
+                        input=query.text,
+                        output=dsl_string[:200] if dsl_string else None,
+                        duration_ms=0,
+                    )
+                )
+                reasoning_steps.append(
+                    ReasoningStep(
+                        tool="QueryPlanningTool",
+                        action="search_execution",
+                        input=dsl_string[:100] if dsl_string else query.text,
+                        output=f"Found {len(items)} documents",
+                        duration_ms=0,
+                    )
+                )
+
+        # Parse inference results for additional outputs (legacy or conversational)
+        inference_results = agent_response.get("inference_results", [])
         if inference_results:
             outputs = inference_results[0].get("output", [])
 
@@ -443,8 +693,8 @@ class OpenSearchAgenticSearcher:
                 elif name == "parent_message_id":
                     # Track parent message ID for conversation threading
                     pass  # Could store for future use
-                elif name in ("response", "answer_generator", "MLModelTool"):
-                    # Parse answer from output
+                elif name in ("answer_generator", "MLModelTool"):
+                    # Parse answer from output (legacy format)
                     answer = self._extract_answer_from_result(result)
 
                     # Add reasoning step for answer generation
@@ -459,7 +709,7 @@ class OpenSearchAgenticSearcher:
                             )
                         )
                 elif name in ("knowledge_search", "VectorDBTool"):
-                    # Parse search results from tool output
+                    # Parse search results from legacy VectorDBTool output
                     items.extend(self._parse_tool_search_results(result))
 
                     # Add reasoning step
@@ -470,9 +720,10 @@ class OpenSearchAgenticSearcher:
                                 action="search",
                                 input=query.text,
                                 output=f"Found {len(items)} documents",
-                                duration_ms=0,  # Not tracked per-step
+                                duration_ms=0,
                             )
                         )
+                # Skip "response" and "query_planner" here - they're handled via generated_dsl parameter
 
             # Parse token usage if available
             usage = inference_results[0].get("usage", {})
@@ -480,8 +731,8 @@ class OpenSearchAgenticSearcher:
             prompt_tokens = usage.get("prompt_tokens", 0)
             completion_tokens = usage.get("completion_tokens", 0)
 
-        # Parse agentic context for reasoning traces
-        agentic_context = response.get("agentic_context", {})
+        # Parse agentic context for reasoning traces (if present)
+        agentic_context = agent_response.get("agentic_context", {})
         traces = agentic_context.get("traces", [])
         for trace in traces:
             if query.include_reasoning:
@@ -497,8 +748,8 @@ class OpenSearchAgenticSearcher:
                 )
 
         # If no answer from structured output, try to get from raw response
-        if not answer and "response" in response:
-            answer = response.get("response")
+        if not answer and "response" in agent_response:
+            answer = agent_response.get("response")
 
         # Preserve the query's conversation_id if agent didn't return one
         # This allows multi-turn conversations when memory was created beforehand
@@ -519,6 +770,7 @@ class OpenSearchAgenticSearcher:
             total_tokens=total_tokens,
             prompt_tokens=prompt_tokens,
             completion_tokens=completion_tokens,
+            generated_query=dsl_string,  # Include the generated DSL for debugging
         )
 
     def _extract_answer_from_result(
@@ -622,6 +874,56 @@ class OpenSearchAgenticSearcher:
 
         return items
 
+    def _parse_opensearch_hits(
+        self,
+        hits_data: dict[str, Any],
+    ) -> list[SearchResultItem]:
+        """Parse OpenSearch hits structure into SearchResultItems.
+
+        Standard OpenSearch response format:
+        {
+            "total": {"value": 10},
+            "max_score": 1.0,
+            "hits": [
+                {"_id": "...", "_score": 0.9, "_source": {...}}
+            ]
+        }
+
+        Args:
+            hits_data: OpenSearch hits object.
+
+        Returns:
+            List of SearchResultItem.
+        """
+        items: list[SearchResultItem] = []
+
+        hits = hits_data.get("hits", [])
+        for hit in hits:
+            if not isinstance(hit, dict):
+                continue
+
+            source = hit.get("_source", {})
+            if not source:
+                continue
+
+            items.append(
+                SearchResultItem(
+                    doc_id=hit.get("_id", ""),
+                    content=source.get("content", ""),
+                    score=hit.get("_score", 0.0),
+                    title=source.get("title"),
+                    url=source.get("url"),
+                    source=source.get("source"),
+                    collection_id=source.get("collection_id"),
+                    source_id=source.get("source_id"),
+                    chunk_index=source.get("chunk_index"),
+                    total_chunks=source.get("total_chunks"),
+                    metadata=source.get("metadata"),
+                )
+            )
+
+        return items
+
 
 class AgenticSearchFallback:
     """Fallback handler for when agentic search fails.

gnosisllm_knowledge/backends/opensearch/config.py

@@ -74,7 +74,7 @@ class OpenSearchConfig:
 
     # === k-NN Settings ===
     knn_engine: str = "lucene"  # lucene (recommended for OpenSearch 2.9+), faiss
-    knn_space_type: str = "l2"  # l2, cosinesimil, innerproduct
+    knn_space_type: str = "cosinesimil"  # cosinesimil (recommended), l2, innerproduct
     knn_algo_param_ef_search: int = 512
     knn_algo_param_ef_construction: int = 512
     knn_algo_param_m: int = 16
@@ -85,10 +85,13 @@ class OpenSearchConfig:
     model_group_id: str | None = None
     embedding_field: str = "content_embedding"  # Field name for embeddings
 
-    # === Agentic Search ===
+    # === Agentic Search (OpenSearch 3.2+) ===
+    # Uses QueryPlanningTool for LLM-generated DSL queries
     # Agent IDs from 'gnosisllm-knowledge agentic setup'
     flow_agent_id: str | None = None
     conversational_agent_id: str | None = None
+    # Agentic search pipeline (created during agentic setup)
+    agentic_pipeline_name: str | None = None
     # LLM for agent reasoning (OpenAI model ID)
     agentic_llm_model: str = "gpt-4o"
     # Agent execution limits
@@ -139,57 +142,75 @@ class OpenSearchConfig:
     def from_env(cls) -> OpenSearchConfig:
         """Create config from environment variables.
 
-        Environment variables:
-            OPENSEARCH_HOST: Host (default: localhost)
-            OPENSEARCH_PORT: Port (default: 9200)
-            OPENSEARCH_USE_SSL: Use SSL (default: false)
-            OPENSEARCH_VERIFY_CERTS: Verify certificates (default: true)
-            OPENSEARCH_USERNAME: Username
-            OPENSEARCH_PASSWORD: Password
-            OPENSEARCH_USE_AWS_SIGV4: Use AWS Sig v4 auth (default: false)
-            AWS_REGION: AWS region for Sig v4
-            OPENSEARCH_NODES: Comma-separated list of nodes
-            EMBEDDING_MODEL: OpenAI embedding model
-            EMBEDDING_DIMENSION: Embedding vector dimension
-            OPENAI_API_KEY: OpenAI API key
-            OPENSEARCH_INDEX_PREFIX: Index name prefix
-            OPENSEARCH_SHARDS: Number of shards
-            OPENSEARCH_REPLICAS: Number of replicas
-            OPENSEARCH_FLOW_AGENT_ID: Flow agent ID for agentic search
-            OPENSEARCH_CONVERSATIONAL_AGENT_ID: Conversational agent ID
-            AGENTIC_LLM_MODEL: LLM model for agent reasoning (default: gpt-4o)
-            AGENTIC_MAX_ITERATIONS: Maximum agent iterations (default: 5)
-            AGENTIC_TIMEOUT_SECONDS: Agent execution timeout (default: 60)
+        All configuration options can be set via environment variables.
+        See .env.example for a complete list with descriptions.
 
         Returns:
             Configuration from environment.
         """
+        # Parse nodes list
         nodes_str = os.getenv("OPENSEARCH_NODES", "")
-        nodes = tuple(nodes_str.split(",")) if nodes_str else None
+        nodes = tuple(n.strip() for n in nodes_str.split(",") if n.strip()) or None
 
         return cls(
+            # === Connection ===
             host=os.getenv("OPENSEARCH_HOST", "localhost"),
             port=int(os.getenv("OPENSEARCH_PORT", "9200")),
-            use_ssl=os.getenv("OPENSEARCH_USE_SSL", "").lower() == "true",
+            use_ssl=os.getenv("OPENSEARCH_USE_SSL", "false").lower() == "true",
             verify_certs=os.getenv("OPENSEARCH_VERIFY_CERTS", "true").lower() == "true",
+            ca_certs=os.getenv("OPENSEARCH_CA_CERTS"),
+            # Authentication
             username=os.getenv("OPENSEARCH_USERNAME"),
             password=os.getenv("OPENSEARCH_PASSWORD"),
-            use_aws_sigv4=os.getenv("OPENSEARCH_USE_AWS_SIGV4", "").lower() == "true",
+            # AWS OpenSearch Service
+            use_aws_sigv4=os.getenv("OPENSEARCH_USE_AWS_SIGV4", "false").lower() == "true",
             aws_region=os.getenv("AWS_REGION"),
+            aws_service=os.getenv("OPENSEARCH_AWS_SERVICE", "es"),
+            # === Cluster (High Availability) ===
             nodes=nodes,
+            sniff_on_start=os.getenv("OPENSEARCH_SNIFF_ON_START", "false").lower() == "true",
+            sniff_on_node_failure=os.getenv("OPENSEARCH_SNIFF_ON_NODE_FAILURE", "true").lower()
+            == "true",
+            sniff_timeout=float(os.getenv("OPENSEARCH_SNIFF_TIMEOUT", "10.0")),
+            sniffer_timeout=float(os.getenv("OPENSEARCH_SNIFFER_TIMEOUT", "60.0")),
+            # === Embedding ===
             embedding_model=os.getenv("EMBEDDING_MODEL", "text-embedding-3-small"),
             embedding_dimension=int(os.getenv("EMBEDDING_DIMENSION", "1536")),
             openai_api_key=os.getenv("OPENAI_API_KEY"),
+            embedding_batch_size=int(os.getenv("EMBEDDING_BATCH_SIZE", "100")),
+            # === Index Settings ===
             index_prefix=os.getenv("OPENSEARCH_INDEX_PREFIX", "gnosisllm"),
             number_of_shards=int(os.getenv("OPENSEARCH_SHARDS", "5")),
             number_of_replicas=int(os.getenv("OPENSEARCH_REPLICAS", "1")),
-            model_id=os.getenv("OPENSEARCH_MODEL_ID"),
+            refresh_interval=os.getenv("OPENSEARCH_REFRESH_INTERVAL", "1s"),
+            # Pipeline names
             ingest_pipeline_name=os.getenv("OPENSEARCH_INGEST_PIPELINE"),
             search_pipeline_name=os.getenv("OPENSEARCH_SEARCH_PIPELINE"),
-            # Agentic search configuration
+            # === k-NN Settings ===
+            knn_engine=os.getenv("OPENSEARCH_KNN_ENGINE", "lucene"),
+            knn_space_type=os.getenv("OPENSEARCH_KNN_SPACE_TYPE", "cosinesimil"),
+            knn_algo_param_ef_search=int(os.getenv("OPENSEARCH_KNN_EF_SEARCH", "512")),
+            knn_algo_param_ef_construction=int(
+                os.getenv("OPENSEARCH_KNN_EF_CONSTRUCTION", "512")
+            ),
+            knn_algo_param_m=int(os.getenv("OPENSEARCH_KNN_M", "16")),
+            # === Neural Search ===
+            model_id=os.getenv("OPENSEARCH_MODEL_ID"),
+            model_group_id=os.getenv("OPENSEARCH_MODEL_GROUP_ID"),
+            embedding_field=os.getenv("OPENSEARCH_EMBEDDING_FIELD", "content_embedding"),
+            # === Agentic Search ===
             flow_agent_id=os.getenv("OPENSEARCH_FLOW_AGENT_ID"),
             conversational_agent_id=os.getenv("OPENSEARCH_CONVERSATIONAL_AGENT_ID"),
+            agentic_pipeline_name=os.getenv("OPENSEARCH_AGENTIC_PIPELINE"),
             agentic_llm_model=os.getenv("AGENTIC_LLM_MODEL", "gpt-4o"),
             agentic_max_iterations=int(os.getenv("AGENTIC_MAX_ITERATIONS", "5")),
             agentic_timeout_seconds=int(os.getenv("AGENTIC_TIMEOUT_SECONDS", "60")),
+            memory_window_size=int(os.getenv("AGENTIC_MEMORY_WINDOW_SIZE", "10")),
+            # === Timeouts ===
+            connect_timeout=float(os.getenv("OPENSEARCH_CONNECT_TIMEOUT", "5.0")),
+            read_timeout=float(os.getenv("OPENSEARCH_READ_TIMEOUT", "30.0")),
+            bulk_timeout=float(os.getenv("OPENSEARCH_BULK_TIMEOUT", "120.0")),
+            # === Bulk Indexing ===
+            bulk_batch_size=int(os.getenv("OPENSEARCH_BULK_BATCH_SIZE", "500")),
+            bulk_max_concurrent=int(os.getenv("OPENSEARCH_BULK_MAX_CONCURRENT", "3")),
         )

gnosisllm_knowledge/backends/opensearch/indexer.py

@@ -481,6 +481,7 @@ class OpenSearchIndexer:
             "source": document.source,
             "account_id": document.account_id,
             "collection_id": document.collection_id,
+            "collection_name": document.collection_name,
             "source_id": document.source_id,
             "chunk_index": document.chunk_index,
             "total_chunks": document.total_chunks,