lionagi 0.0.312__py3-none-any.whl → 0.2.1__py3-none-any.whl

lionagi/integrations/bridge/langchain_/documents.py

@@ -28,6 +28,10 @@ def to_langchain_document(datanode: T, **kwargs: Any) -> Any:
     SysUtil.change_dict_key(dnode, old_key="content", new_key="page_content")
     SysUtil.change_dict_key(dnode, old_key="lc_id", new_key="id_")
     dnode = {**dnode, **kwargs}
+    dnode = {k: v for k, v in dnode.items() if v is not None}
+    if "page_content" not in dnode:
+        dnode["page_content"] = ""
+
     return LangchainDocument(**dnode)
 
 

lionagi/integrations/bridge/llamaindex_/index.py

@@ -0,0 +1,30 @@
+class LlamaIndex:
+
+    @classmethod
+    def index(
+        cls,
+        nodes,
+        llm_obj=None,
+        llm_class=None,
+        llm_kwargs=None,
+        index_type=None,
+        **kwargs,
+    ):
+        from llama_index.core import Settings
+        from llama_index.llms.openai import OpenAI
+
+        if not llm_obj:
+            llm_class = llm_class or OpenAI
+            llm_kwargs = llm_kwargs or {}
+            if "model" not in llm_kwargs:
+                llm_kwargs["model"] = "gpt-4o"
+            llm_obj = llm_class(**llm_kwargs)
+
+        Settings.llm = llm_obj
+
+        if not index_type:
+            from llama_index.core import VectorStoreIndex
+
+            index_type = VectorStoreIndex
+
+        return index_type(nodes, **kwargs)

lionagi/integrations/bridge/llamaindex_/llama_index_bridge.py

@@ -100,3 +100,9 @@ class LlamaIndexBridge:
         from .reader import get_llama_index_reader
 
         return get_llama_index_reader(*args, **kwargs)
+
+    @staticmethod
+    def index(nodes, **kwargs):
+        from .index import LlamaIndex
+
+        return LlamaIndex.index(nodes, **kwargs)

lionagi/integrations/bridge/llamaindex_/llama_pack.py

@@ -0,0 +1,227 @@
+class LlamaPack:
+
+    @staticmethod
+    def download(pack_name, pack_path):
+        try:
+            from llama_index.llama_pack import download_llama_pack
+
+            return download_llama_pack(pack_name, pack_path)
+        except Exception as e:
+            raise ImportError(f"Error in downloading llama pack: {e}")
+
+    @staticmethod
+    def build(pack_name, pack_path, args=[], **kwargs):
+        pack = LlamaPack.download(pack_name, pack_path)
+        return pack(*args, **kwargs)
+
+    @staticmethod
+    def stock_market_pack(pack_path="./stock_market_data_pack", args=[], **kwargs):
+        name_ = "StockMarketDataQueryEnginePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def embedded_table_pack(
+        pack_path="./embedded_tables_unstructured_pack", args=[], **kwargs
+    ):
+        name_ = "RecursiveRetrieverSmallToBigPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def rag_evaluator_pack(pack_path="./rag_evaluator_pack", args=[], **kwargs):
+        name_ = "RagEvaluatorPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def ollma_pack(pack_path="./ollama_pack", args=[], **kwargs):
+        name_ = "OllamaQueryEnginePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def llm_compiler_agent_pack(
+        pack_path="./llm_compiler_agent_pack", args=[], **kwargs
+    ):
+        name_ = "LLMCompilerAgentPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def resume_screener_pack(pack_path="./resume_screener_pack", args=[], **kwargs):
+        name_ = "ResumeScreenerPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def ragatouille_retriever_pack(pack_path="./ragatouille_pack", args=[], **kwargs):
+        name_ = "RAGatouilleRetrieverPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def chain_of_table_pack(pack_path="./chain_of_table_pack", args=[], **kwargs):
+        name_ = "ChainOfTablePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def hybrid_fusion_retriever_pack(
+        pack_path="./hybrid_fusion_pack", args=[], **kwargs
+    ):
+        name_ = "HybridFusionRetrieverPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def neo4j_query_engine_pack(pack_path="./neo4j_pack", args=[], **kwargs):
+        name_ = "Neo4jQueryEnginePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def llava_completion_pack(pack_path="./llava_pack", args=[], **kwargs):
+        name_ = "LlavaCompletionPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def sentence_window_retriever_pack(
+        pack_path="./sentence_window_retriever_pack", args=[], **kwargs
+    ):
+        name_ = "SentenceWindowRetrieverPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def dense_x_retrieval_pack(pack_path="./dense_pack", args=[], **kwargs):
+        name_ = "DenseXRetrievalPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def zephyr_query_engine_pack(pack_path="./zephyr_pack", args=[], **kwargs):
+        name_ = "ZephyrQueryEnginePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def query_rewriting_retriever_pack(
+        pack_path="./query_rewriting_pack", args=[], **kwargs
+    ):
+        name_ = "QueryRewritingRetrieverPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def fuzzy_citation_engine_pack(
+        pack_path="./fuzzy_citation_pack", args=[], **kwargs
+    ):
+        name_ = "FuzzyCitationEnginePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def multidoc_auto_retriever_pack(
+        pack_path="./multidoc_autoretrieval_pack", args=[], **kwargs
+    ):
+        name_ = "MultiDocAutoRetrieverPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def auto_merging_retriever_pack(
+        pack_path="./auto_merging_retriever_pack", args=[], **kwargs
+    ):
+        name_ = "AutoMergingRetrieverPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def voyage_query_engine_pack(pack_path="./voyage_pack", args=[], **kwargs):
+        name_ = "VoyageQueryEnginePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def mix_self_consistency_pack(
+        pack_path="./mix_self_consistency_pack", args=[], **kwargs
+    ):
+        name_ = "MixSelfConsistencyPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def rag_fusion_pipeline_pack(
+        pack_path="./rag_fusion_pipeline_pack", args=[], **kwargs
+    ):
+        name_ = "RAGFusionPipelinePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def multi_document_agents_pack(
+        pack_path="./multi_doc_agents_pack", args=[], **kwargs
+    ):
+        name_ = "MultiDocumentAgentsPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def llama_guard_moderator_pack(pack_path="./llamaguard_pack", args=[], **kwargs):
+        name_ = "LlamaGuardModeratorPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def evaluator_benchmarker_pack(
+        pack_path="./eval_benchmark_pack", args=[], **kwargs
+    ):
+        name_ = "EvaluatorBenchmarkerPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def amazon_product_extraction_pack(
+        pack_path="./amazon_product_extraction_pack", args=[], **kwargs
+    ):
+        name_ = "AmazonProductExtractionPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def llama_dataset_metadata_pack(
+        pack_path="./llama_dataset_metadata_pack", args=[], **kwargs
+    ):
+        name_ = "LlamaDatasetMetadataPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def multi_tenancy_rag_pack(pack_path="./multitenancy_rag_pack", args=[], **kwargs):
+        name_ = "MultiTenancyRAGPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def gmail_openai_agent_pack(pack_path="./gmail_pack", args=[], **kwargs):
+        name_ = "GmailOpenAIAgentPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def snowflake_query_engine_pack(pack_path="./snowflake_pack", args=[], **kwargs):
+        name_ = "SnowflakeQueryEnginePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def agent_search_retriever_pack(pack_path="./agent_search_pack", args=[], **kwargs):
+        name_ = "AgentSearchRetrieverPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def vectara_rag_pack(pack_path="./vectara_rag_pack", args=[], **kwargs):
+        name_ = "VectaraRagPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def chroma_autoretrieval_pack(pack_path="./chroma_pack", args=[], **kwargs):
+        name_ = "ChromaAutoretrievalPack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def arize_phoenix_query_engine_pack(pack_path="./arize_pack", args=[], **kwargs):
+        name_ = "ArizePhoenixQueryEnginePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def redis_ingestion_pipeline_pack(
+        pack_path="./redis_ingestion_pack", args=[], **kwargs
+    ):
+        name_ = "RedisIngestionPipelinePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def nebula_graph_query_engine_pack(
+        pack_path="./nebulagraph_pack", args=[], **kwargs
+    ):
+        name_ = "NebulaGraphQueryEnginePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)
+
+    @staticmethod
+    def weaviate_retry_engine_pack(pack_path="./weaviate_pack", args=[], **kwargs):
+        name_ = "WeaviateRetryEnginePack"
+        return LlamaPack.build(name_, pack_path, args, **kwargs)

lionagi/integrations/bridge/llamaindex_/node_parser.py

@@ -29,19 +29,18 @@ def get_llama_index_node_parser(node_parser: Any):
     import llama_index.core.node_parser
 
     if not isinstance(node_parser, str) and not issubclass(node_parser, NodeParser):
-        raise TypeError(f"node_parser must be a string or NodeParser.")
+        raise TypeError("node_parser must be a string or NodeParser.")
 
     if isinstance(node_parser, str):
         if node_parser == "CodeSplitter":
             SysUtil.check_import("tree_sitter_languages")
 
         try:
-            parser = getattr(llama_index.core.node_parser, node_parser)
-            return parser
+            return getattr(llama_index.core.node_parser, node_parser)
         except Exception as e:
             raise AttributeError(
                 f"llama_index_core has no such attribute:" f" {node_parser}, Error: {e}"
-            )
+            ) from e
 
     elif isinstance(node_parser, NodeParser):
         return node_parser
@@ -75,10 +74,8 @@ def llama_index_parse_node(
         parser = get_llama_index_node_parser(node_parser)
         try:
             parser = parser(*parser_args, **parser_kwargs)
-        except:
+        except Exception:
             parser = parser.from_defaults(*parser_args, **parser_kwargs)
-        nodes = parser.get_nodes_from_documents(documents)
-        return nodes
-
+        return parser.get_nodes_from_documents(documents)
     except Exception as e:
-        raise ValueError(f"Failed to parse. Error: {e}")
+        raise ValueError(f"Failed to parse. Error: {e}") from e

lionagi/integrations/bridge/pydantic_/pydantic_bridge.py

@@ -0,0 +1 @@
+from pydantic import BaseModel, Field, ValidationError, AliasChoices, field_serializer

lionagi/integrations/bridge/transformers_/install_.py

@@ -0,0 +1,36 @@
+import subprocess
+from lionagi.libs import SysUtil
+
+
+def get_pytorch_install_command():
+    cpu_arch = SysUtil.get_cpu_architecture()
+
+    if cpu_arch == "apple_silicon":
+        return "pip install --pre torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/nightly/cpu"
+    else:
+        # Default CPU installation
+        return "pip install torch torchvision torchaudio"
+
+
+def install_pytorch():
+    command = get_pytorch_install_command()
+    try:
+        subprocess.run(command.split(), check=True)
+        print("PyTorch installed successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"Failed to install PyTorch: {e}")
+
+
+def install_transformers():
+    if not SysUtil.is_package_installed("torch"):
+        in_ = input(
+            "PyTorch is required for transformers. Would you like to install it now? (y/n): "
+        )
+        if in_ == "y":
+            install_pytorch()
+    if not SysUtil.is_package_installed("transformers"):
+        in_ = input(
+            "transformers is required. Would you like to install it now? (y/n): "
+        )
+        if in_ == "y":
+            SysUtil.install_import(package_name="transformers", import_name="pipeline")

lionagi/integrations/chunker/chunk.py

@@ -0,0 +1,312 @@
+from typing import Union, Callable
+
+from lionagi.libs import func_call
+from lionagi.libs.ln_convert import to_list
+from lionagi.core.collections import pile
+from lionagi.core.generic import Node
+from ..bridge.langchain_.langchain_bridge import LangchainBridge
+from ..bridge.llamaindex_.llama_index_bridge import LlamaIndexBridge
+
+
+from ..loader.load_util import ChunkerType, file_to_chunks, _datanode_parser
+
+
+def datanodes_convert(documents, chunker_type):
+    """
+    Converts documents to the specified chunker type.
+
+    Args:
+        documents (list): List of documents to be converted.
+        chunker_type (ChunkerType): The type of chunker to convert the documents to.
+
+    Returns:
+        list: The converted documents.
+
+    Example usage:
+        >>> documents = [Node(...), Node(...)]
+        >>> converted_docs = datanodes_convert(documents, ChunkerType.LLAMAINDEX)
+    """
+    for i in range(len(documents)):
+        if type(documents[i]) == Node:
+            if chunker_type == ChunkerType.LLAMAINDEX:
+                documents[i] = documents[i].to_llama_index()
+            elif chunker_type == ChunkerType.LANGCHAIN:
+                documents[i] = documents[i].to_langchain()
+    return documents
+
+
+def text_chunker(documents, args, kwargs):
+    """
+    Chunks text documents into smaller pieces.
+
+    Args:
+        documents (list): List of documents to be chunked.
+        args (tuple): Positional arguments for the chunking function.
+        kwargs (dict): Keyword arguments for the chunking function.
+
+    Returns:
+        pile: A pile of chunked Node instances.
+
+    Example usage:
+        >>> documents = [Node(...), Node(...)]
+        >>> chunked_docs = text_chunker(documents, args, kwargs)
+    """
+
+    def chunk_node(node):
+        chunks = file_to_chunks(node.to_dict(), *args, **kwargs)
+        func_call.lcall(chunks, lambda chunk: chunk.pop("ln_id"))
+        return [Node.from_obj({**chunk}) for chunk in chunks]
+
+    a = to_list([chunk_node(doc) for doc in documents], flatten=True, dropna=True)
+    return pile(a)
+
+
+def chunk(
+    docs,
+    field: str = "content",
+    chunk_size: int = 1500,
+    overlap: float = 0.1,
+    threshold: int = 200,
+    chunker="text_chunker",
+    chunker_type=ChunkerType.PLAIN,
+    chunker_args=None,
+    chunker_kwargs=None,
+    chunking_kwargs=None,
+    documents_convert_func=None,
+    to_lion: bool | Callable = True,
+):
+    """
+    Chunks documents using the specified chunker.
+
+    Args:
+        docs (list): List of documents to be chunked.
+        field (str, optional): The field to chunk. Defaults to "content".
+        chunk_size (int, optional): The size of each chunk. Defaults to 1500.
+        overlap (float, optional): The overlap between chunks. Defaults to 0.1.
+        threshold (int, optional): The threshold for chunking. Defaults to 200.
+        chunker (str, optional): The chunker function or its name. Defaults to "text_chunker".
+        chunker_type (ChunkerType, optional): The type of chunker to use. Defaults to ChunkerType.PLAIN.
+        chunker_args (list, optional): Positional arguments for the chunker function. Defaults to None.
+        chunker_kwargs (dict, optional): Keyword arguments for the chunker function. Defaults to None.
+        chunking_kwargs (dict, optional): Additional keyword arguments for chunking. Defaults to None.
+        documents_convert_func (Callable, optional): Function to convert documents. Defaults to None.
+        to_lion (bool | Callable, optional): Whether to convert the data to Node instances or a custom parser. Defaults to True.
+
+    Returns:
+        pile: A pile of chunked Node instances.
+
+    Raises:
+        ValueError: If the chunker_type is not supported.
+
+    Example usage:
+        >>> chunked_docs = chunk(docs, field='text', chunk_size=1000, overlap=0.2)
+    """
+
+    if chunker_args is None:
+        chunker_args = []
+    if chunker_kwargs is None:
+        chunker_kwargs = {}
+    if chunking_kwargs is None:
+        chunking_kwargs = {}
+
+    if chunker_type == ChunkerType.PLAIN:
+        chunker_kwargs["field"] = field
+        chunker_kwargs["chunk_size"] = chunk_size
+        chunker_kwargs["overlap"] = overlap
+        chunker_kwargs["threshold"] = threshold
+        return chunk_funcs[ChunkerType.PLAIN](
+            docs, chunker, chunker_args, chunker_kwargs
+        )
+
+    elif chunker_type == ChunkerType.LANGCHAIN:
+        return chunk_funcs[ChunkerType.LANGCHAIN](
+            docs,
+            documents_convert_func,
+            chunker,
+            chunker_args,
+            chunker_kwargs,
+            to_lion,
+        )
+
+    elif chunker_type == ChunkerType.LLAMAINDEX:
+        return chunk_funcs[ChunkerType.LLAMAINDEX](
+            docs,
+            documents_convert_func,
+            chunker,
+            chunker_args,
+            chunker_kwargs,
+            to_lion,
+        )
+
+    elif chunker_type == ChunkerType.SELFDEFINED:
+        return chunk_funcs[ChunkerType.SELFDEFINED](
+            docs,
+            chunker,
+            chunker_args,
+            chunker_kwargs,
+            chunking_kwargs,
+            to_lion,
+        )
+
+    else:
+        raise ValueError(
+            f"{chunker_type} is not supported. Please choose from {list(ChunkerType)}"
+        )
+
+
+def _self_defined_chunker(
+    documents,
+    chunker,
+    chunker_args,
+    chunker_kwargs,
+    chunking_kwargs,
+    to_lion: bool | Callable,
+):
+    """
+    Chunks documents using a self-defined chunker.
+
+    Args:
+        documents (list): List of documents to be chunked.
+        chunker (str | Callable): The chunker function or its name.
+        chunker_args (list): Positional arguments for the chunker function.
+        chunker_kwargs (dict): Keyword arguments for the chunker function.
+        chunking_kwargs (dict): Additional keyword arguments for chunking.
+        to_lion (bool | Callable): Whether to convert the data to Node instances or a custom parser.
+
+    Returns:
+        pile: A pile of chunked Node instances or custom parsed nodes.
+
+    Raises:
+        ValueError: If the self-defined chunker is not valid.
+
+    Example usage:
+        >>> chunked_docs = _self_defined_chunker(docs, custom_chunker, ['arg1'], {'key': 'value'}, {}, custom_parser)
+    """
+    try:
+        splitter = chunker(*chunker_args, **chunker_kwargs)
+        nodes = splitter.split(documents, **chunking_kwargs)
+    except Exception as e:
+        raise ValueError(
+            f"Self defined chunker {chunker} is not valid. Error: {e}"
+        ) from e
+
+    if isinstance(to_lion, bool) and to_lion is True:
+        raise ValueError("Please define a valid parser to Node.")
+    elif isinstance(to_lion, Callable):
+        nodes = _datanode_parser(nodes, to_lion)
+    return nodes
+
+
+def _llama_index_chunker(
+    documents,
+    documents_convert_func,
+    chunker,
+    chunker_args,
+    chunker_kwargs,
+    to_lion: bool | Callable,
+):
+    """
+    Chunks documents using a LlamaIndex chunker.
+
+    Args:
+        documents (list): List of documents to be chunked.
+        documents_convert_func (Callable): Function to convert documents.
+        chunker (str | Callable): The chunker function or its name.
+        chunker_args (list): Positional arguments for the chunker function.
+        chunker_kwargs (dict): Keyword arguments for the chunker function.
+        to_lion (bool | Callable): Whether to convert the data to Node instances or a custom parser.
+
+    Returns:
+        pile: A pile of chunked Node instances or custom parsed nodes.
+
+    Example usage:
+        >>> chunked_docs = _llama_index_chunker(docs, convert_func, llama_chunker, ['arg1'], {'key': 'value'}, True)
+    """
+    if documents_convert_func:
+        documents = documents_convert_func(documents, "llama_index")
+    nodes = LlamaIndexBridge.llama_index_parse_node(
+        documents, chunker, chunker_args, chunker_kwargs
+    )
+
+    if isinstance(to_lion, bool) and to_lion is True:
+        nodes = [Node.from_llama_index(i) for i in nodes]
+    elif isinstance(to_lion, Callable):
+        nodes = _datanode_parser(nodes, to_lion)
+    return nodes
+
+
+def _langchain_chunker(
+    documents,
+    documents_convert_func,
+    chunker,
+    chunker_args,
+    chunker_kwargs,
+    to_lion: bool | Callable,
+):
+    """
+    Chunks documents using a Langchain chunker.
+
+    Args:
+        documents (list): List of documents to be chunked.
+        documents_convert_func (Callable): Function to convert documents.
+        chunker (str | Callable): The chunker function or its name.
+        chunker_args (list): Positional arguments for the chunker function.
+        chunker_kwargs (dict): Keyword arguments for the chunker function.
+        to_lion (bool | Callable): Whether to convert the data to Node instances or a custom parser.
+
+    Returns:
+        pile: A pile of chunked Node instances or custom parsed nodes.
+
+    Example usage:
+        >>> chunked_docs = _langchain_chunker(docs, convert_func, langchain_chunker, ['arg1'], {'key': 'value'}, True)
+    """
+    if documents_convert_func:
+        documents = documents_convert_func(documents, "langchain")
+    nodes = LangchainBridge.langchain_text_splitter(
+        documents, chunker, chunker_args, chunker_kwargs
+    )
+    if isinstance(to_lion, bool) and to_lion is True:
+        if isinstance(documents, str):
+            nodes = [Node(content=i) for i in nodes]
+        else:
+            nodes = [Node.from_langchain(i) for i in nodes]
+    elif isinstance(to_lion, Callable):
+        nodes = _datanode_parser(nodes, to_lion)
+    return nodes
+
+
+def _plain_chunker(documents, chunker, chunker_args, chunker_kwargs):
+    """
+    Chunks documents using a plain chunker.
+
+    Args:
+        documents (list): List of documents to be chunked.
+        chunker (str | Callable): The chunker function or its name.
+        chunker_args (list): Positional arguments for the chunker function.
+        chunker_kwargs (dict): Keyword arguments for the chunker function.
+
+    Returns:
+        pile: A pile of chunked Node instances.
+
+    Raises:
+        ValueError: If the chunker is not supported.
+
+    Example usage:
+        >>> chunked_docs = _plain_chunker(docs, 'text_chunker', ['arg1'], {'key': 'value'})
+    """
+    try:
+        if chunker == "text_chunker":
+            chunker = text_chunker
+        return chunker(documents, chunker_args, chunker_kwargs)
+    except Exception as e:
+        raise ValueError(
+            f"Reader {chunker} is currently not supported. Error: {e}"
+        ) from e
+
+
+chunk_funcs = {
+    ChunkerType.PLAIN: _plain_chunker,
+    ChunkerType.LANGCHAIN: _langchain_chunker,
+    ChunkerType.LLAMAINDEX: _llama_index_chunker,
+    ChunkerType.SELFDEFINED: _self_defined_chunker,
+}