alita-sdk 0.3.263__py3-none-any.whl → 0.3.499__py3-none-any.whl

alita_sdk/tools/vector_adapters/VectorStoreAdapter.py

@@ -2,6 +2,8 @@ from abc import ABC, abstractmethod
 from typing import Any, Dict, Optional, List
 from logging import getLogger
 
+from ...runtime.utils.utils import IndexerKeywords
+
 logger = getLogger(__name__)
 
 
@@ -24,13 +26,13 @@ class VectorStoreAdapter(ABC):
         pass
 
     @abstractmethod
-    def get_indexed_ids(self, vectorstore_wrapper, collection_suffix: Optional[str] = '') -> List[str]:
+    def get_indexed_ids(self, vectorstore_wrapper, index_name: Optional[str] = '') -> List[str]:
         """Get all indexed document IDs from vectorstore"""
         pass
 
     @abstractmethod
-    def clean_collection(self, vectorstore_wrapper, collection_suffix: str = ''):
-        """Clean the vectorstore collection by deleting all indexed data."""
+    def clean_collection(self, vectorstore_wrapper, index_name: str = '', including_index_meta: bool = False):
+        """Clean the vectorstore collection by deleting all indexed data. If including_index_meta is True, skip the index_meta records."""
         pass
 
     @abstractmethod
@@ -39,7 +41,7 @@ class VectorStoreAdapter(ABC):
         pass
 
     @abstractmethod
-    def get_code_indexed_data(self, vectorstore_wrapper, collection_suffix) -> Dict[str, Dict[str, Any]]:
+    def get_code_indexed_data(self, vectorstore_wrapper, index_name) -> Dict[str, Dict[str, Any]]:
         """Get all indexed data from vectorstore for code content"""
         pass
 
@@ -48,15 +50,26 @@ class VectorStoreAdapter(ABC):
         """Add a new collection name to the metadata"""
         pass
 
+    @abstractmethod
+    def get_index_meta(self, vectorstore_wrapper, index_name: str) -> List[Dict[str, Any]]:
+        """Get all index_meta entries from the vector store."""
+        pass
+
 
 class PGVectorAdapter(VectorStoreAdapter):
     """Adapter for PGVector database operations."""
 
     def get_vectorstore_params(self, collection_name: str, connection_string: Optional[str] = None) -> Dict[str, Any]:
+        try:
+            from tools import this  # pylint: disable=E0401,C0415
+            worker_config = this.for_module("indexer_worker").descriptor.config
+        except:  # pylint: disable=W0702
+            worker_config = {}
+        #
         return {
             "use_jsonb": True,
             "collection_name": collection_name,
-            "create_extension": True,
+            "create_extension": worker_config.get("pgvector_create_extension", True),
             "alita_sdk_options": {
                 "target_schema": collection_name,
             },
@@ -93,20 +106,25 @@ class PGVectorAdapter(VectorStoreAdapter):
             session.commit()
             logger.info(f"Schema '{schema_name}' has been dropped.")
 
-    def get_indexed_ids(self, vectorstore_wrapper, collection_suffix: Optional[str] = '') -> List[str]:
+    def get_indexed_ids(self, vectorstore_wrapper, index_name: Optional[str] = '') -> List[str]:
         """Get all indexed document IDs from PGVector"""
         from sqlalchemy.orm import Session
-        from sqlalchemy import func
+        from sqlalchemy import func, or_
 
         store = vectorstore_wrapper.vectorstore
         try:
             with Session(store.session_maker.bind) as session:
                 # Start building the query
                 query = session.query(store.EmbeddingStore.id)
-                # Apply filter only if collection_suffix is provided
-                if collection_suffix:
+                # Apply filter only if index_name is provided
+                if index_name:
                     query = query.filter(
-                        func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection') == collection_suffix
+                        func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection') == index_name,
+                        or_(
+                            func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'type').is_(None),
+                            func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata,
+                                                         'type') != IndexerKeywords.INDEX_META_TYPE.value
+                        )
                     )
                 ids = query.all()
                 return [str(id_tuple[0]) for id_tuple in ids]
@@ -114,25 +132,37 @@ class PGVectorAdapter(VectorStoreAdapter):
             logger.error(f"Failed to get indexed IDs from PGVector: {str(e)}")
             return []
 
-    def clean_collection(self, vectorstore_wrapper, collection_suffix: str = ''):
-        """Clean the vectorstore collection by deleting all indexed data."""
-        # This logic deletes all data from the vectorstore collection without removal of collection.
-        # Collection itself remains available for future indexing.
-        vectorstore_wrapper.vectorstore.delete(ids=self.get_indexed_ids(vectorstore_wrapper, collection_suffix))
+    def clean_collection(self, vectorstore_wrapper, index_name: str = '', including_index_meta: bool = False):
+        """Clean the vectorstore collection by deleting all indexed data. If including_index_meta is True, skip the index_meta records."""
+        from sqlalchemy.orm import Session
+        from sqlalchemy import func, or_
+        store = vectorstore_wrapper.vectorstore
+        with Session(store.session_maker.bind) as session:
+            if including_index_meta:
+                session.query(store.EmbeddingStore).filter(
+                    func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection') == index_name
+                ).delete(synchronize_session=False)
+            else:
+                session.query(store.EmbeddingStore).filter(
+                    func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection') == index_name,
+                    or_(func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'type').is_(None),
+                        func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'type') != IndexerKeywords.INDEX_META_TYPE.value)
+                ).delete(synchronize_session=False)
+            session.commit()
 
     def is_vectorstore_type(self, vectorstore) -> bool:
         """Check if the vectorstore is a PGVector store."""
         return hasattr(vectorstore, 'session_maker') and hasattr(vectorstore, 'EmbeddingStore')
 
-    def get_indexed_data(self, vectorstore_wrapper, collection_suffix: str)-> Dict[str, Dict[str, Any]]:
-        """Get all indexed data from PGVector for non-code content per collection_suffix."""
+    def get_indexed_data(self, vectorstore_wrapper, index_name: str)-> Dict[str, Dict[str, Any]]:
+        """Get all indexed data from PGVector for non-code content per index_name."""
         from sqlalchemy.orm import Session
         from sqlalchemy import func
         from ...runtime.utils.utils import IndexerKeywords
 
         result = {}
         try:
-            vectorstore_wrapper._log_data("Retrieving already indexed data from PGVector vectorstore",
+            vectorstore_wrapper._log_tool_event("Retrieving already indexed data from PGVector vectorstore",
                            tool_name="get_indexed_data")
             store = vectorstore_wrapper.vectorstore
             with Session(store.session_maker.bind) as session:
@@ -141,7 +171,7 @@ class PGVectorAdapter(VectorStoreAdapter):
                     store.EmbeddingStore.document,
                     store.EmbeddingStore.cmetadata
                 ).filter(
-                    func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection') == collection_suffix
+                    func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection') == index_name
                 ).all()
 
             # Process the retrieved data
@@ -174,14 +204,14 @@ class PGVectorAdapter(VectorStoreAdapter):
 
         return result
 
-    def get_code_indexed_data(self, vectorstore_wrapper, collection_suffix: str) -> Dict[str, Dict[str, Any]]:
+    def get_code_indexed_data(self, vectorstore_wrapper, index_name: str) -> Dict[str, Dict[str, Any]]:
         """Get all indexed code data from PGVector per collection suffix."""
         from sqlalchemy.orm import Session
         from sqlalchemy import func
 
         result = {}
         try:
-            vectorstore_wrapper._log_data("Retrieving already indexed code data from PGVector vectorstore",
+            vectorstore_wrapper._log_tool_event(message="Retrieving already indexed code data from PGVector vectorstore",
                            tool_name="index_code_data")
             store = vectorstore_wrapper.vectorstore
             with (Session(store.session_maker.bind) as session):
@@ -189,7 +219,7 @@ class PGVectorAdapter(VectorStoreAdapter):
                     store.EmbeddingStore.id,
                     store.EmbeddingStore.cmetadata
                 ).filter(
-                    func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection') == collection_suffix
+                    func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection') == index_name
                 ).all()
 
             for db_id, meta in docs:
@@ -259,6 +289,29 @@ class PGVectorAdapter(VectorStoreAdapter):
         except Exception as e:
             logger.error(f"Failed to update collection for entry ID {entry_id}: {str(e)}")
 
+    def get_index_meta(self, vectorstore_wrapper, index_name: str) -> List[Dict[str, Any]]:
+        from sqlalchemy.orm import Session
+        from sqlalchemy import func
+
+        store = vectorstore_wrapper.vectorstore
+        try:
+            with Session(store.session_maker.bind) as session:
+                meta = session.query(
+                    store.EmbeddingStore.id,
+                    store.EmbeddingStore.document,
+                    store.EmbeddingStore.cmetadata
+                ).filter(
+                    store.EmbeddingStore.cmetadata['type'].astext == IndexerKeywords.INDEX_META_TYPE.value,
+                    func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection') == index_name
+                ).all()
+                result = []
+                for id, document, cmetadata in meta:
+                    result.append({"id": id, "content": document, "metadata": cmetadata})
+                return result
+        except Exception as e:
+            logger.error(f"Failed to get index_meta from PGVector: {str(e)}")
+            raise e
+
 
 class ChromaAdapter(VectorStoreAdapter):
     """Adapter for Chroma database operations."""
@@ -276,7 +329,7 @@ class ChromaAdapter(VectorStoreAdapter):
     def remove_collection(self, vectorstore_wrapper, collection_name: str):
         vectorstore_wrapper.vectorstore.delete_collection()
 
-    def get_indexed_ids(self, vectorstore_wrapper, collection_suffix: Optional[str] = '') -> List[str]:
+    def get_indexed_ids(self, vectorstore_wrapper, index_name: Optional[str] = '') -> List[str]:
         """Get all indexed document IDs from Chroma"""
         try:
             data = vectorstore_wrapper.vectorstore.get(include=[])  # Only get IDs, no metadata
@@ -285,9 +338,9 @@ class ChromaAdapter(VectorStoreAdapter):
             logger.error(f"Failed to get indexed IDs from Chroma: {str(e)}")
             return []
 
-    def clean_collection(self, vectorstore_wrapper, collection_suffix: str = ''):
-        """Clean the vectorstore collection by deleting all indexed data."""
-        vectorstore_wrapper.vectorstore.delete(ids=self.get_indexed_ids(vectorstore_wrapper, collection_suffix))
+    def clean_collection(self, vectorstore_wrapper, index_name: str = '', including_index_meta: bool = False):
+        """Clean the vectorstore collection by deleting all indexed data. including_index_meta is ignored."""
+        vectorstore_wrapper.vectorstore.delete(ids=self.get_indexed_ids(vectorstore_wrapper, index_name))
 
     def get_indexed_data(self, vectorstore_wrapper):
         """Get all indexed data from Chroma for non-code content"""
@@ -325,7 +378,7 @@ class ChromaAdapter(VectorStoreAdapter):
 
         return result
 
-    def get_code_indexed_data(self, vectorstore_wrapper, collection_suffix) -> Dict[str, Dict[str, Any]]:
+    def get_code_indexed_data(self, vectorstore_wrapper, index_name) -> Dict[str, Dict[str, Any]]:
         """Get all indexed code data from Chroma."""
         result = {}
         try:
@@ -355,6 +408,9 @@ class ChromaAdapter(VectorStoreAdapter):
         # This is a simplified implementation - in practice, you might need more complex logic
         logger.warning("add_to_collection for Chroma is not fully implemented yet")
 
+    def get_index_meta(self, vectorstore_wrapper, index_name: str) -> List[Dict[str, Any]]:
+        logger.warning("get_index_meta for Chroma is not implemented yet")
+
 
 class VectorStoreAdapterFactory:
     """Factory for creating vector store adapters."""

alita_sdk/tools/xray/__init__.py

@@ -7,7 +7,8 @@ from pydantic import create_model, BaseModel, Field
 
 from .api_wrapper import XrayApiWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.pgvector import PgVectorConfiguration
 from ...configurations.xray import XrayConfiguration
 
@@ -21,6 +22,7 @@ def get_tools(tool):
         limit=tool['settings'].get('limit', 20),
         verify_ssl=tool['settings'].get('verify_ssl', True),
         toolkit_name=tool.get('toolkit_name'),
+        llm=tool['settings'].get('llm', None),
         alita=tool['settings'].get('alita', None),
 
         # indexer settings
@@ -32,12 +34,10 @@ def get_tools(tool):
 
 class XrayToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in XrayApiWrapper.model_construct().get_available_tools()}
-        XrayToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             limit=(Optional[int], Field(description="Limit", default=100)),
@@ -54,7 +54,7 @@ class XrayToolkit(BaseToolkit):
                             {
                                 'metadata': {
                                     "label": "XRAY cloud", "icon_url": "xray.svg",
-                                "categories": ["test management"],
+                                    "categories": ["test management"],
                                     "extra_categories": ["test automation", "test case management", "test planning"]
                                 }
                             }
@@ -62,6 +62,7 @@ class XrayToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -72,17 +73,21 @@ class XrayToolkit(BaseToolkit):
             **(kwargs.get('pgvector_configuration') or {}),
         }
         xray_api_wrapper = XrayApiWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = xray_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description + "\nXray instance: " + xray_api_wrapper.base_url
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=xray_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] + "\nXray instance: " + xray_api_wrapper.base_url,
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/tools/xray/api_wrapper.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import hashlib
-from typing import Any, Dict, Generator, List, Optional
+from typing import Any, Dict, Generator, List, Optional, Literal
 
 import requests
 from langchain_core.documents import Document
@@ -9,12 +9,9 @@ from langchain_core.tools import ToolException
 from pydantic import PrivateAttr, SecretStr, create_model, model_validator, Field
 from python_graphql_client import GraphqlClient
 
-from ..elitea_base import (
-    BaseVectorStoreToolApiWrapper,
-    extend_with_vector_tools,
-)
+from ..non_code_indexer_toolkit import NonCodeIndexerToolkit
+from ..utils.available_tools_decorator import extend_with_parent_available_tools
 from ...runtime.utils.utils import IndexerKeywords
-from ..utils.content_parser import parse_file_content, load_content_from_bytes
 
 try:
     from alita_sdk.runtime.langchain.interfaces.llm_processor import get_embeddings
@@ -31,7 +28,7 @@ _get_tests_query = """query GetTests($jql: String!, $limit:Int!, $start: Int)
         limit
         results {
             issueId
-            jira(fields: ["key", "summary", "created", "updated", "assignee.displayName", "reporter.displayName"])
+            jira(fields: ["key", "summary", "description", "created", "updated", "assignee.displayName", "reporter.displayName"])
             projectId
             testType {
                 name
@@ -107,7 +104,7 @@ XrayCreateTest = create_model(
 
 XrayCreateTests = create_model(
     "XrayCreateTests",
-    graphql_mutations=(list[str], Field(description="list of GraphQL mutations:\n" + _graphql_mutation_description))
+    graphql_mutations=(List[str], Field(description="list of GraphQL mutations:\n" + _graphql_mutation_description))
 )
 
 def _parse_tests(test_results) -> List[Any]:
@@ -120,7 +117,7 @@ def _parse_tests(test_results) -> List[Any]:
     return test_results
 
 
-class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
+class XrayApiWrapper(NonCodeIndexerToolkit):
     _default_base_url: str = 'https://xray.cloud.getxray.app'
     base_url: str = ""
     client_id: str = None
@@ -147,7 +144,7 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
         client_id = values['client_id']
         client_secret = values['client_secret']
         # Authenticate to get the token
-        values['base_url'] = values.get('base_url', '') or cls._default_base_url
+        values['base_url'] = values.get('base_url', '') or cls._default_base_url.default
         auth_url = f"{values['base_url']}/api/v1/authenticate"
         auth_data = {
             "client_id": client_id,
@@ -168,7 +165,7 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
                 return ToolException(f"Please, check you credentials ({values['client_id']} / {masked_secret}). Unable")
             else:
                 return ToolException(f"Authentication failed: {str(e)}")
-        return values
+        return super().validate_toolkit(values)
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -333,6 +330,7 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
 
             for test in tests_data:
                 page_content = ""
+                content_structure = {}
                 test_type_name = test.get("testType", {}).get("name", "").lower()
 
                 attachment_ids = []
@@ -359,19 +357,16 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
                     content_structure = {"steps": steps_content}
                     if attachment_ids:
                         content_structure["attachment_ids"] = sorted(attachment_ids)
-                    page_content = json.dumps(content_structure, indent=2)
 
                 elif test_type_name == "cucumber" and test.get("gherkin"):
                     content_structure = {"gherkin": test["gherkin"]}
                     if attachment_ids:
                         content_structure["attachment_ids"] = sorted(attachment_ids)
-                    page_content = json.dumps(content_structure, indent=2)
 
                 elif test.get("unstructured"):
                     content_structure = {"unstructured": test["unstructured"]}
                     if attachment_ids:
                         content_structure["attachment_ids"] = sorted(attachment_ids)
-                    page_content = json.dumps(content_structure, indent=2)
 
                 metadata = {"doctype": self.doctype}
 
@@ -382,7 +377,12 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
 
                     if "created" in jira_data:
                         metadata["created_on"] = jira_data["created"]
-                    
+
+                    if jira_data.get("description"):
+                        content_structure["description"] = jira_data.get("description")
+
+                    page_content = json.dumps(content_structure if content_structure.items() else "", indent=2)
+
                     content_hash = hashlib.sha256(page_content.encode('utf-8')).hexdigest()[:16]
                     metadata["updated_on"] = content_hash
 
@@ -407,11 +407,13 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
                         if "attachments" in step and step["attachments"]:
                             for attachment in step["attachments"]:
                                 if attachment and "id" in attachment and "filename" in attachment:
+                                    attachment['step_id'] = step['id']
                                     attachments_data.append(attachment)
                     if attachments_data:
                         metadata["_attachments_data"] = attachments_data
 
-                yield Document(page_content=page_content, metadata=metadata)
+                metadata[IndexerKeywords.CONTENT_IN_BYTES.value] = page_content.encode('utf-8')
+                yield Document(page_content='', metadata=metadata)
                 
         except Exception as e:
             logger.error(f"Error processing test data: {e}")
@@ -430,14 +432,7 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
             Generator[Document, None, None]: A generator yielding processed Document objects with metadata.
         """
         try:
-            if not getattr(self, '_include_attachments', False):
-                yield document
-                return
-                
             attachments_data = document.metadata.get("_attachments_data", [])
-            if not attachments_data:
-                yield document
-                return
                 
             issue_id = document.metadata.get("id")
             
@@ -458,44 +453,33 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
                 ).append(attachment_id)
 
                 try:
-                    content = self._process_attachment(attachment)
-                    if not content or content.startswith("Attachment processing failed"):
-                        logger.warning(f"Skipping attachment {filename} due to processing failure")
-                        continue
+                    attachment_metadata = {
+                        'id': str(attachment_id),
+                        'issue_key': document.metadata.get('key', ''),
+                        'issueId': str(issue_id),
+                        'projectId': document.metadata.get('projectId', ''),
+                        'source': f"xray_test_{issue_id}",
+                        'filename': filename,
+                        'download_link': attachment.get('downloadLink', ''),
+                        'entity_type': 'test_case_attachment',
+                        'step_id': attachment.get('step_id', ''),
+                        'key': document.metadata.get('key', ''),
+                        IndexerKeywords.PARENT.value: document.metadata.get('id', str(issue_id)),
+                        'type': 'attachment',
+                        'doctype': self.doctype,
+                    }
+                    yield from self._process_attachment(attachment, attachment_metadata)
                 except Exception as e:
                     logger.error(f"Failed to process attachment {filename}: {str(e)}")
                     continue
-
-                attachment_metadata = {
-                    'id': str(attachment_id),
-                    'issue_key': document.metadata.get('key', ''),
-                    'issueId': str(issue_id),
-                    'projectId': document.metadata.get('projectId', ''),
-                    'source': f"xray_test_{issue_id}",
-                    'filename': filename,
-                    'download_link': attachment.get('downloadLink', ''),
-                    'entity_type': 'test_case_attachment',
-                    'key': document.metadata.get('key', ''),
-                    IndexerKeywords.PARENT.value: document.metadata.get('id', str(issue_id)),
-                    'type': 'attachment',
-                    'doctype': self.doctype,
-                }
-
-                yield Document(
-                    page_content=content,
-                    metadata=attachment_metadata
-                )
             
             if "_attachments_data" in document.metadata:
                 del document.metadata["_attachments_data"]
             
-            yield document
-            
         except Exception as e:
             logger.error(f"Error processing document for attachments: {e}")
-            yield document
 
-    def _process_attachment(self, attachment: Dict[str, Any]) -> str:
+    def _process_attachment(self, attachment: Dict[str, Any], attachment_metadata) -> Generator[Document, None, None]:
         """
         Processes an attachment to extract its content.
 
@@ -508,38 +492,17 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
         try:
             download_link = attachment.get('downloadLink')
             filename = attachment.get('filename', '')
-            
-            if not download_link:
-                return f"Attachment: {filename} (no download link available)"
 
             try:
                 auth_token = self._ensure_auth_token()
                 headers = {'Authorization': f'Bearer {auth_token}'}
                 response = requests.get(download_link, headers=headers, timeout=30)
                 response.raise_for_status()
-                
-                ext = f".{filename.split('.')[-1].lower()}" if filename and '.' in filename else ""
-                
-                if ext == '.pdf':
-                    content = parse_file_content(
-                        file_content=response.content,
-                        file_name=filename,
-                        llm=self.llm,
-                        is_capture_image=True
-                    )
-                else:
-                    content = load_content_from_bytes(
-                        response.content,
-                        ext,
-                        llm=self.llm
-                    )
-
-                if content:
-                    return f"filename: {filename}\ncontent: {content}"
-                else:
-                    logger.warning(f"No content extracted from attachment {filename}")
-                    return f"filename: {filename}\ncontent: [No extractable content]"
-                
+
+                yield from self._load_attachment(content=response.content,
+                                                 file_name=filename,
+                                                 attachment_metadata=attachment_metadata)
+
             except requests.RequestException as req_e:
                 logger.error(f"Unable to download attachment {filename} with existing token: {req_e}")
                 
@@ -560,23 +523,13 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
                         fresh_headers = {'Authorization': f'Bearer {fresh_token}'}
                         response = requests.get(download_link, headers=fresh_headers, timeout=60)
                         response.raise_for_status()
-                        
-                        ext = f".{filename.split('.')[-1].lower()}" if filename and '.' in filename else ""
-                        content = parse_file_content(
-                            file_content=response.content,
-                            file_name=filename,
-                            llm=self.llm,
-                            is_capture_image=True
-                        ) if ext == '.pdf' else load_content_from_bytes(response.content, ext, llm=self.llm)
-                        
-                        if content:
-                            return f"filename: {filename}\ncontent: {content}"
-                        else:
-                            return f"filename: {filename}\ncontent: [Content extraction failed after re-auth]"
+
+                        yield from self._load_attachment(content=response.content,
+                                                         file_name=filename,
+                                                         attachment_metadata=attachment_metadata)
                             
                     except Exception as reauth_e:
                         logger.error(f"Re-authentication and retry failed for {filename}: {reauth_e}")
-                        return f"Attachment: {filename} (download failed: {str(req_e)}, re-auth failed: {str(reauth_e)})"
                 else:
                     try:
                         auth_token = self._ensure_auth_token()
@@ -587,34 +540,29 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
                         }
                         response = requests.get(download_link, headers=fallback_headers, timeout=60)
                         response.raise_for_status()
-                        
-                        ext = f".{filename.split('.')[-1].lower()}" if filename and '.' in filename else ""
-                        content = parse_file_content(
-                            file_content=response.content,
-                            file_name=filename,
-                            llm=self.llm,
-                            is_capture_image=True
-                        ) if ext == '.pdf' else load_content_from_bytes(response.content, ext, llm=self.llm)
-                        
-                        if content:
-                            return f"filename: {filename}\ncontent: {content}"
-                        else:
-                            return f"filename: {filename}\ncontent: [Content extraction failed after fallback]"
+
+                        yield from self._load_attachment(content=response.content,
+                                                         file_name=filename,
+                                                         attachment_metadata=attachment_metadata)
                             
                     except Exception as fallback_e:
                         logger.error(f"Fallback download also failed for {filename}: {fallback_e}")
-                        return f"Attachment: {filename} (download failed: {str(req_e)}, fallback failed: {str(fallback_e)})"
                     
             except Exception as parse_e:
                 logger.error(f"Unable to parse attachment {filename}: {parse_e}")
-                return f"Attachment: {filename} (parsing failed: {str(parse_e)})"
                 
         except Exception as e:
             logger.error(f"Error processing attachment: {e}")
-            return f"Attachment processing failed: {str(e)}"
+
+    def _load_attachment(self, content, file_name, attachment_metadata) -> Generator[Document, None, None]:
+        attachment_metadata[IndexerKeywords.CONTENT_IN_BYTES.value] = content
+        attachment_metadata[IndexerKeywords.CONTENT_FILE_NAME.value] = file_name
+        yield Document(page_content='', metadata=attachment_metadata)
 
     def _index_tool_params(self, **kwargs) -> dict[str, tuple[type, Field]]:
         return {
+            'chunking_tool': (Literal['json', ''],
+                              Field(description="Name of chunking tool for base document", default='json')),
             'jql': (Optional[str], Field(description="""JQL query for searching test cases in Xray.
 
             Standard JQL query syntax for filtering Xray test cases. Examples:
@@ -684,9 +632,9 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
         except Exception as e:
             raise ToolException(f"Unable to execute GraphQL due to error: {str(e)}")
 
-    @extend_with_vector_tools
+    @extend_with_parent_available_tools
     def get_available_tools(self):
-        tools = [
+        return [
             {
                 "name": "get_tests",
                 "description": self.get_tests.__doc__,
@@ -711,7 +659,4 @@ class XrayApiWrapper(BaseVectorStoreToolApiWrapper):
                 "args_schema": XrayGrapql,
                 "ref": self.execute_graphql,
             }
-        ]
-
-        tools.extend(self._get_vector_search_tools())
-        return tools
+        ]