How to add node metadata to the node text

[aiwalter]

I am using a query engine and would like to add some matadata of the nodes to the node text, e.g. file_name and some other custom metadata. I think there is a class for this in llama_index but now I cant find it. Or do I need to write sth custom?

[dosubot[bot]]

🤖

Hey there, @aiwalter! Good to see you back in the LlamaIndex world. Hope your code is behaving today. 😄

Based on the information you provided and the context from the LlamaIndex repository, you can add metadata to the nodes in two ways:

1. You can directly assign metadata to a node using the metadata attribute. Here is an example:

node.metadata = metadata

Or when creating a new TextNode:

node = TextNode(text=text, metadata=metadata)

If your input documents already have this metadata, it would be inherited to the nodes automatically. For retrieval, you can use metadata filters:

from llama_index.vector_stores.types import ExactMatchFilter, MetadataFilters

filters = MetadataFilters(
    filters=[ExactMatchFilter(key="key", value="val")]
)

query_engine = index.as_query_engine(similarity_top_k=3, filters=filters)

This solution was suggested in a similar issue: [Question]: Add TextNode metadata to help Retriever

2. If you need to add custom metadata such as file_name, you may need to create a custom extractor class that inherits from BaseExtractor and implements the required functionality. Here is a basic example of how you can create a custom extractor class:

from llama_index.extractors.interface import BaseExtractor
from typing import Sequence, List, Dict
from llama_index.schema import BaseNode

class CustomExtractor(BaseExtractor):
    async def aextract(self, nodes: Sequence[BaseNode]) -> List[Dict]:
        # Implement your custom extraction logic here
        pass

In this example, CustomExtractor is a new class that inherits from BaseExtractor. It implements the aextract method, which is required because aextract is an abstract method in BaseExtractor. The aextract method is where you would put your custom logic for extracting metadata from a sequence of nodes.

You can find more details about creating a custom extractor in the LlamaIndex source code: llama_index/extractors/interface.py

I hope this helps! If you have any other questions or need further clarification, feel free to ask.

Sources

• [Question]: Add TextNode metadata to help Retriever
• Support for Document Metadata in Query Responses
• Support for Document Metadata in Query Responses
• llama_index/extractors/metadata_extractors.py
• llama_index/extractors/interface.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[aiwalter]

@dosubot not sure if I get this right with the CustomExtractor. Can you give an example, lets say we have a matadata key called my_key and I want its value called my_value to be appended/included in the node text to generate response, but not in the similarity search.

[dosubot[bot]]

🤖

Based on your request, you want to create a CustomExtractor that appends a metadata key-value pair to the node text when generating a response, but excludes it from the similarity search. You can achieve this by creating a new class that inherits from the BaseExtractor class and override the necessary methods.

Here is an example of how you can do this:

from llama_index.extractors.interface import BaseExtractor
from llama_index.llms.llm import LLM
from llama_index.types import BasePydanticProgram
from typing import Any, Dict, Optional, Sequence, List
from llama_index.async_utils import run_jobs

class CustomExtractor(BaseExtractor):
    """Custom extractor. Appends a metadata key-value pair to the node text when generating a response,
    but excludes it from the similarity search.

    Args:
        llm (Optional[LLM]): LLM
    """

    llm: LLMPredictorType = Field(description="The LLM to use for generation.")

    def __init__(
        self,
        llm: Optional[LLM] = None,
        llm_predictor: Optional[LLMPredictorType] = None,
        num_workers: int = DEFAULT_NUM_WORKERS,
        **kwargs: Any,
    ) -> None:
        """Init params."""
        super().__init__(
            llm=llm or llm_predictor or resolve_llm("default"),
            num_workers=num_workers,
            **kwargs,
        )

    @classmethod
    def class_name(cls) -> str:
        return "CustomExtractor"

    async def _acustom_extract(self, node: BaseNode) -> Dict[str, str]:
        """Custom extraction from a node and return it's metadata dict."""
        if self.is_text_node_only and not isinstance(node, TextNode):
            return {}

        # TODO: Implement your custom extraction logic here
        # For example, you can use self.llm.apredict() to generate the metadata
        # Make sure to return a dictionary with the metadata key-value pair

    async def aextract(self, nodes: Sequence[BaseNode]) -> List[Dict]:
        extract_jobs = []
        for node in nodes:
            extract_jobs.append(self._acustom_extract(node))

        metadata_list: List[Dict] = await run_jobs(
            extract_jobs, show_progress=self.show_progress, workers=self.num_workers
        )

        return metadata_list

In this example, you would need to implement your custom extraction logic in the _acustom_extract method. This method should return a dictionary with the metadata key-value pair that you want to append to the node text. The aextract method is responsible for running the extraction jobs for all nodes and returning the list of metadata dictionaries.

Please note that this is a basic example and you might need to adjust it according to your specific needs. You can refer to the llama_index/extractors/metadata_extractors.py for more details.

Regarding your question about the structure of the BaseExtractor class, it provides several methods and properties. The aextract method is abstract and must be overridden in a subclass. The aprocess_nodes and acall methods are also designed to be overridden in a subclass if asynchronous processing is needed. You can refer to the llama_index/extractors/interface.py for more details.

I hope this helps! If you have any other questions, feel free to ask.

Sources

• [Question]: Metadata exclusion
• llama_index/extractors/metadata_extractors.py
• llama_index/extractors/interface.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[aiwalter]

@dosubot where and how would I handover this CustomExtractor to the query engine?

[dosubot[bot]]

🤖

To integrate your CustomExtractor class into the LlamaIndex query engine, you need to subclass the BaseExtractor class and implement the aextract method. This method should return a list of metadata dictionaries corresponding to each node.

Here is a basic example of how you can implement your CustomExtractor:

from llama_index.extractors.interface import BaseExtractor
from llama_index.schema import BaseNode
from typing import Any, Dict, List, Sequence

class CustomExtractor(BaseExtractor):
    async def aextract(self, nodes: Sequence[BaseNode]) -> List[Dict]:
        # Your custom extraction logic here
        # This should return a list of metadata dictionaries corresponding to each node
        pass

    async def aprocess_nodes(
        self,
        nodes: List[BaseNode],
        excluded_embed_metadata_keys: Optional[List[str]] = None,
        excluded_llm_metadata_keys: Optional[List[str]] = None,
        **kwargs: Any,
    ) -> List[BaseNode]:
        # Call the parent method with the keys you want to exclude from the similarity search
        return await super().aprocess_nodes(
            nodes,
            excluded_embed_metadata_keys=excluded_embed_metadata_keys,
            excluded_llm_metadata_keys=excluded_llm_metadata_keys,
            **kwargs,
        )

Remember to replace the pass statement in the aextract method with your custom extraction logic. The aprocess_nodes method in this example calls the parent method with the keys you want to exclude from the similarity search.

The BaseExtractor class in the LlamaIndex codebase serves as the base class for metadata extractors. It is responsible for extracting metadata from a sequence of nodes (documents) and post-processing these nodes.

Key functionalities of the BaseExtractor class include:

1. Metadata Extraction: The aextract method is an abstract method that needs to be implemented by any class that inherits from BaseExtractor. This method is responsible for extracting metadata from a sequence of nodes and returning a list of metadata dictionaries corresponding to each node.

2. Node Post-Processing: The aprocess_nodes method allows for post-processing of nodes parsed from documents. This method also allows for chaining of extractors. It updates the metadata of each node with the extracted metadata and modifies the text template of each node if disable_template_rewrite is not set.

3. Concurrent Processing: The BaseExtractor class supports concurrent async processing of nodes. The number of workers for this concurrent processing can be set using the num_workers field.

4. Configuration: The class also provides several configuration options such as metadata_mode to specify the metadata mode to use when reading nodes, node_text_template to specify the template to represent how node text is mixed with metadata text, and in_place to specify whether to process nodes in place.

You can find more details in the llama_index/extractors/interface.py file.

For more examples and context, you can refer to these similar solved issues in the LlamaIndex repository:

1. [Question]: Metadata exclusion
2. Support for Document Metadata in Query Responses
3. Support for Document Metadata in Query Responses

I hope this helps! If you have any more questions, feel free to ask.

Sources

• [Question]: Metadata exclusion
• Support for Document Metadata in Query Responses
• Support for Document Metadata in Query Responses
• llama_index/extractors/interface.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[aiwalter]

@dosubot I managed to add some metadata to the document, how can I use this metadata in synthesize(...) or query(..) now? Is there way to provide a custom class that reads the metadata and appends it to the document text? Where would I provide this object?

[dosubot[bot]]

🤖

Yes, you can provide a custom class that reads the metadata and appends it to the document text in LlamaIndex. This can be achieved by creating a custom class that inherits from the TextNode class and overrides the get_content and get_metadata_str methods. Here is an example:

class CustomTextNode(TextNode):
    def get_content(self, metadata_mode: MetadataMode = MetadataMode.NONE) -> str:
        """Get object content."""
        metadata_str = self.get_metadata_str(mode=metadata_mode).strip()
        if not metadata_str:
            return self.text

        # Custom logic to append metadata to the document text
        return self.text + "\n" + metadata_str

    def get_metadata_str(self, mode: MetadataMode = MetadataMode.ALL) -> str:
        """Metadata info string."""
        if mode == MetadataMode.NONE:
            return ""
        usable_metadata_keys = set(self.metadata.keys())
        if mode == MetadataMode.LLM:
            for key in self.excluded_llm_metadata_keys:
                if key in usable_metadata_keys:
                    usable_metadata_keys.remove(key)
        elif mode == MetadataMode.EMBED:
            for key in self.excluded_embed_metadata_keys:
                if key in usable_metadata_keys:
                    usable_metadata_keys.remove(key)

        # Custom logic to format metadata
        return "\n".join(
            [
                f"{key}: {value}"
                for key, value in self.metadata.items()
                if key in usable_metadata_keys
            ]
        )

In this example, the get_content method is overridden to append the metadata to the document text. The get_metadata_str method is also overridden to format the metadata in a custom way. You can modify these methods according to your needs. You can find more details in the llama_index/schema.py file.

As for the synthesize(...) method, I wasn't able to find specific information on how it handles metadata within the LlamaIndex repository. However, you can refer to the Support for Document Metadata in Query Responses and More flexible answer generation issues for more information on how metadata can be used in LlamaIndex.

If you need further assistance, please provide more details about your use case.

Sources

• Support for Document Metadata in Query Responses
• Support for Document Metadata in Query Responses
• More flexible answer generation
• llama_index/schema.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[aiwalter]

@dosubot I am already using TextNode as the retriever is giving me this. Whats an easy way to plug in my custom nodes into the index or query engine?

[dosubot[bot]]

🤖

To integrate your custom nodes into the LlamaIndex's index or query engine, you need to ensure that your custom nodes inherit from the BaseNode class and override the get_content and get_metadata_str methods.

Here is an example of how you can create a custom node:

from llama_index.schema import BaseNode, MetadataMode
from typing import Any

class CustomNode(BaseNode):
    custom_field: str

    @classmethod
    def get_type(cls) -> str:
        """Get Object type."""
        return "custom"

    def get_content(self, metadata_mode: MetadataMode = MetadataMode.NONE) -> str:
        """Get object content."""
        return self.custom_field

    def get_metadata_str(self, mode: MetadataMode = MetadataMode.ALL) -> str:
        """Metadata info string."""
        return self.metadata

    def set_content(self, value: Any) -> None:
        """Set the content of the node."""
        self.custom_field = value

In this example, CustomNode is a new node type that has a custom_field attribute. The get_content method returns the value of custom_field, and the get_metadata_str method returns the metadata of the node. The set_content method sets the value of custom_field.

Once you have your custom node class, you can create instances of it and add them to the index or use them in queries. The exact way to do this will depend on the specifics of your index or query engine.

Please note that you might need to adjust the get_type method to return a type that is recognized by your index or query engine. The get_type method is used to determine the type of the node, and different types might be handled differently by the index or query engine.

For more information, you can refer to the llama_index/schema.py file in the LlamaIndex repository.

Sources

• llama_index/schema.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[Audiopolis]

@aiwalter Did you ever figure this out? These bot responses are pretty useless.