gllm-inference-binary 0.5.9b1__cp312-cp312-macosx_11_0_universal2.macosx_13_0_arm64.whl

gllm_inference/builder/__init__.pyi

@@ -0,0 +1,6 @@
+from gllm_inference.builder.build_em_invoker import build_em_invoker as build_em_invoker
+from gllm_inference.builder.build_lm_invoker import build_lm_invoker as build_lm_invoker
+from gllm_inference.builder.build_lm_request_processor import build_lm_request_processor as build_lm_request_processor
+from gllm_inference.builder.build_output_parser import build_output_parser as build_output_parser
+
+__all__ = ['build_em_invoker', 'build_lm_invoker', 'build_lm_request_processor', 'build_output_parser']

gllm_inference/builder/build_em_invoker.pyi

@@ -0,0 +1,137 @@
+from _typeshed import Incomplete
+from gllm_inference.em_invoker import AzureOpenAIEMInvoker as AzureOpenAIEMInvoker, BedrockEMInvoker as BedrockEMInvoker, GoogleEMInvoker as GoogleEMInvoker, LangChainEMInvoker as LangChainEMInvoker, OpenAICompatibleEMInvoker as OpenAICompatibleEMInvoker, OpenAIEMInvoker as OpenAIEMInvoker, TwelveLabsEMInvoker as TwelveLabsEMInvoker, VoyageEMInvoker as VoyageEMInvoker
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker as BaseEMInvoker
+from gllm_inference.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider
+from typing import Any
+
+PROVIDER_TO_EM_INVOKER_MAP: dict[str, type[BaseEMInvoker]]
+logger: Incomplete
+
+class Key:
+    """Defines valid keys in the config."""
+    ACCESS_KEY_ID: str
+    API_KEY: str
+    AZURE_DEPLOYMENT: str
+    AZURE_ENDPOINT: str
+    BASE_URL: str
+    CREDENTIALS_PATH: str
+    MODEL_KWARGS: str
+    MODEL_NAME: str
+    MODEL_CLASS_PATH: str
+    SECRET_ACCESS_KEY: str
+
+def build_em_invoker(model_id: str | ModelId, credentials: str | dict[str, Any] | None = None, config: dict[str, Any] | None = None) -> BaseEMInvoker:
+    '''Build an embedding model invoker based on the provided configurations.
+
+    Args:
+        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in the following format:
+            1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
+            2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
+            3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
+            4. For other providers: `provider/model-name`.
+        credentials (str | dict[str, Any] | None, optional): The credentials for the language model. Can either be:
+            1. An API key.
+            2. A path to a credentials JSON file, currently only supported for Google Vertex AI.
+            3. A dictionary of credentials, currently only supported for LangChain.
+            Defaults to None, in which case the credentials will be loaded from the appropriate environment variables.
+        config (dict[str, Any] | None, optional): Additional configuration for the embedding model. Defaults to None.
+
+    Returns:
+        BaseEMInvoker: The initialized embedding model invoker.
+
+    Raises:
+        ValueError: If the provider is invalid.
+
+    Usage examples:
+        # Using Bedrock
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="bedrock/cohere.embed-english-v3",
+            credentials={
+                "access_key_id": "Abc123...",
+                "secret_access_key": "Xyz123...",
+            },
+        )
+        ```
+        The credentials can also be provided through the `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`
+        environment variables.
+
+        # Using Google Gen AI (via API key)
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="google/text-embedding-004",
+            credentials="AIzaSyD..."
+        )
+        ```
+        The credentials can also be provided through the `GOOGLE_API_KEY` environment variable.
+
+        # Using Google Vertex AI (via service account)
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="google/text-embedding-004",
+            credentials="/path/to/google-credentials.json"
+        )
+        ```
+        Providing credentials through environment variable is not supported for Google Vertex AI.
+
+        # Using OpenAI
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="openai/text-embedding-3-small",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using Azure OpenAI
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment",
+            credentials="azure-api-key"
+        )
+        ```
+        The credentials can also be provided through the `AZURE_OPENAI_API_KEY` environment variable.
+
+        # Using OpenAI Compatible endpoint (e.g. Text Embeddings Inference)
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="openai-compatible/https://my-text-embeddings-inference-endpoint.com:model-name",
+            credentials="tei-api-key"
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using TwelveLabs
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="twelvelabs/Marengo-retrieval-2.7",
+            credentials="tlk_..."
+        )
+        ```
+        The credentials can also be provided through the `TWELVELABS_API_KEY` environment variable.
+
+        # Using Voyage
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="voyage/voyage-3.5-lite",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `VOYAGE_API_KEY` environment variable.
+
+        # Using LangChain
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="langchain/langchain_openai.OpenAIEmbeddings:text-embedding-3-small",
+            credentials={"api_key": "sk-..."}
+        )
+        ```
+        The credentials can also be provided through various environment variables depending on the
+        LangChain module being used. For the list of supported providers and the supported environment
+        variables credentials, please refer to the following page:
+        https://python.langchain.com/docs/integrations/text_embedding/
+
+    Security warning:
+        Please provide the EM invoker credentials ONLY to the `credentials` parameter. Do not put any kind of
+        credentials in the `config` parameter as the content of the `config` parameter will be logged.
+    '''

gllm_inference/builder/build_lm_invoker.pyi

@@ -0,0 +1,161 @@
+from _typeshed import Incomplete
+from gllm_inference.lm_invoker import AnthropicLMInvoker as AnthropicLMInvoker, AzureOpenAILMInvoker as AzureOpenAILMInvoker, BedrockLMInvoker as BedrockLMInvoker, DatasaurLMInvoker as DatasaurLMInvoker, GoogleLMInvoker as GoogleLMInvoker, LangChainLMInvoker as LangChainLMInvoker, LiteLLMLMInvoker as LiteLLMLMInvoker, OpenAICompatibleLMInvoker as OpenAICompatibleLMInvoker, OpenAILMInvoker as OpenAILMInvoker, XAILMInvoker as XAILMInvoker
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
+from gllm_inference.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider
+from typing import Any
+
+PROVIDER_TO_LM_INVOKER_MAP: dict[str, type[BaseLMInvoker]]
+logger: Incomplete
+
+class Key:
+    """Defines valid keys in the config."""
+    ACCESS_KEY_ID: str
+    API_KEY: str
+    AZURE_DEPLOYMENT: str
+    AZURE_ENDPOINT: str
+    BASE_URL: str
+    CREDENTIALS_PATH: str
+    MODEL_ID: str
+    MODEL_KWARGS: str
+    MODEL_NAME: str
+    MODEL_CLASS_PATH: str
+    SECRET_ACCESS_KEY: str
+
+def build_lm_invoker(model_id: str | ModelId, credentials: str | dict[str, Any] | None = None, config: dict[str, Any] | None = None) -> BaseLMInvoker:
+    '''Build a language model invoker based on the provided configurations.
+
+    Args:
+        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in the following format:
+            1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
+            2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
+            3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
+            4. For `litellm` provider: `litellm/provider/model-name`.
+            5. For `datasaur` provider: `datasaur/deployment-id:model-name`.
+            6. For other providers: `provider/model-name`.
+        credentials (str | dict[str, Any] | None, optional): The credentials for the language model. Can either be:
+            1. An API key.
+            2. A path to a credentials JSON file, currently only supported for Google Vertex AI.
+            3. A dictionary of credentials, currently supported for Bedrock and LangChain.
+            Defaults to None, in which case the credentials will be loaded from the appropriate environment variables.
+        config (dict[str, Any] | None, optional): Additional configuration for the language model. Defaults to None.
+
+    Returns:
+        BaseLMInvoker: The initialized language model invoker.
+
+    Raises:
+        ValueError: If the provider is invalid.
+
+    Usage examples:
+        # Using Anthropic
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="anthropic/claude-3-5-sonnet-latest",
+            credentials="sk-ant-api03-..."
+        )
+        ```
+        The credentials can also be provided through the `ANTHROPIC_API_KEY` environment variable.
+
+        # Using Bedrock
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="bedrock/us.anthropic.claude-sonnet-4-20250514-v1:0",
+            credentials={
+                "access_key_id": "Abc123...",
+                "secret_access_key": "Xyz123...",
+            },
+        )
+        ```
+        The credentials can also be provided through the `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`
+        environment variables.
+
+        # Using Datasaur LLM Projects Deployment API
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="datasaur/https://deployment.datasaur.ai/api/deployment/teamId/deploymentId/",
+            credentials="..."
+        )
+        ```
+        The credentials can also be provided through the `DATASAUR_API_KEY` environment variable.
+
+        # Using Google Gen AI (via API key)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="google/gemini-1.5-flash-latest",
+            credentials="AIzaSyD..."
+        )
+        ```
+        The credentials can also be provided through the `GOOGLE_API_KEY` environment variable.
+
+        # Using Google Vertex AI (via service account)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="google/gemini-1.5-flash",
+            credentials="/path/to/google-credentials.json"
+        )
+        ```
+        Providing credentials through environment variable is not supported for Google Vertex AI.
+
+        # Using OpenAI
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="openai/gpt-4o-mini",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using Azure OpenAI
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment",
+            credentials="azure-api-key"
+        )
+        ```
+        The credentials can also be provided through the `AZURE_OPENAI_API_KEY` environment variable.
+
+        # Using OpenAI Compatible endpoint (e.g. Groq)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="openai-compatible/https://api.groq.com/openai/v1:llama3-8b-8192",
+            credentials="gsk_..."
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using LangChain
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="langchain/langchain_openai.ChatOpenAI:gpt-4o-mini",
+            credentials={"api_key": "sk-..."}
+        )
+        ```
+        The credentials can also be provided through various environment variables depending on the
+        LangChain module being used. For the list of supported providers and the supported environment
+        variables credentials, please refer to the following table:
+        https://python.langchain.com/docs/integrations/chat/#featured-providers
+
+        # Using LiteLLM
+        ```python
+        os.environ["OPENAI_API_KEY"] = "sk-..."
+        lm_invoker = build_lm_invoker(
+            model_id="litellm/openai/gpt-4o-mini",
+        )
+        ```
+        For the list of supported providers, please refer to the following page:
+        https://docs.litellm.ai/docs/providers/
+
+        # Using xAI
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="xai/grok-3",
+            credentials="xai-..."
+        )
+        ```
+        The credentials can also be provided through the `XAI_API_KEY` environment variable.
+        For the list of supported models, please refer to the following page:
+        https://docs.x.ai/docs/models
+
+    Security warning:
+        Please provide the LM invoker credentials ONLY to the `credentials` parameter. Do not put any kind of
+        credentials in the `config` parameter as the content of the `config` parameter will be logged.
+    '''

gllm_inference/builder/build_lm_request_processor.pyi

@@ -0,0 +1,93 @@
+from _typeshed import Incomplete
+from gllm_inference.builder.build_lm_invoker import build_lm_invoker as build_lm_invoker
+from gllm_inference.builder.build_output_parser import build_output_parser as build_output_parser
+from gllm_inference.prompt_builder import PromptBuilder as PromptBuilder
+from gllm_inference.request_processor.lm_request_processor import LMRequestProcessor as LMRequestProcessor
+from gllm_inference.schema.model_id import ModelId as ModelId
+from typing import Any
+
+logger: Incomplete
+
+def build_lm_request_processor(model_id: str | ModelId, credentials: str | dict[str, Any] | None = None, config: dict[str, Any] | None = None, system_template: str = '', user_template: str = '', key_defaults: dict[str, Any] | None = None, output_parser_type: str = 'none') -> LMRequestProcessor:
+    '''Build a language model invoker based on the provided configurations.
+
+    Args:
+        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in the following format:
+            1. For `azure-openai` provider: `azure-openai/azure-endpoint:azure-deployment`.
+            2. For `openai-compatible` provider: `openai-compatible/base-url:model-name`.
+            3. For `langchain` provider: `langchain/<package>.<class>:model-name`.
+            4. For `litellm` provider: `litellm/provider/model-name`.
+            5. For `datasaur` provider: `datasaur/base-url`.
+            6. For other providers: `provider/model-name`.
+        credentials (str | dict[str, Any] | None, optional): The credentials for the language model. Can either be:
+            1. An API key.
+            2. A path to a credentials JSON file, currently only supported for Google Vertex AI.
+            3. A dictionary of credentials, currently supported for Bedrock and LangChain.
+            Defaults to None, in which case the credentials will be loaded from the appropriate environment variables.
+        config (dict[str, Any] | None, optional): Additional configuration for the language model. Defaults to None.
+        system_template (str): The system prompt template. May contain placeholders enclosed in curly braces `{}`.
+            Defaults to an empty string.
+        user_template (str): The user prompt template. May contain placeholders enclosed in curly braces `{}`.
+            Defaults to an empty string.
+        key_defaults (dict[str, str] | None, optional): Default values for the keys in the prompt templates.
+            Applied when the corresponding keys are not provided in the runtime input.
+            Defaults to None, in which case no default values will be assigned to the keys.
+        output_parser_type (str, optional): The type of output parser to use. Supports "json" and "none".
+            Defaults to "none".
+
+    Returns:
+        LMRequestProcessor: The initialized language model request processor.
+
+    Raises:
+        ValueError: If the provided configuration is invalid.
+
+    Usage examples:
+        ```python
+        # Basic usage
+        lm_request_processor = build_lm_request_processor(
+            model_id="openai/gpt-4o-mini",
+            credentials="sk-...",
+            user_template="{query}",
+        )
+        ```
+
+        # With custom LM invoker configuration
+        ```python
+        config = {
+            "default_hyperparameters": {"temperature": 0.5},
+            "tools": [tool_1, tool_2],
+        }
+
+        lm_request_processor = build_lm_request_processor(
+            model_id="openai/gpt-4o-mini",
+            credentials="sk-...",
+            config=config,
+            user_template="{query}",
+        )
+        ```
+
+        # With custom prompt builder configuration
+        ```python
+        lm_request_processor = build_lm_request_processor(
+            model_id="openai/gpt-4o-mini",
+            credentials="sk-...",
+            system_template="Talk like a {role}.",
+            user_template="{query}",
+            key_defaults={"role": "pirate"},
+        )
+        ```
+
+        # With output parser
+        ```python
+        lm_request_processor = build_lm_request_processor(
+            model_id="openai/gpt-4o-mini",
+            credentials="sk-...",
+            user_template="{query}",
+            output_parser_type="json",
+        )
+        ```
+
+    Security warning:
+        Please provide the LM invoker credentials ONLY to the `credentials` parameter. Do not put any kind of
+        credentials in the `config` parameter as the content of the `config` parameter will be logged.
+    '''

gllm_inference/builder/build_output_parser.pyi

@@ -0,0 +1,29 @@
+from _typeshed import Incomplete
+from gllm_inference.output_parser import JSONOutputParser as JSONOutputParser
+from gllm_inference.output_parser.output_parser import BaseOutputParser as BaseOutputParser
+
+OUTPUT_PARSER_TYPE_MAP: Incomplete
+
+def build_output_parser(output_parser_type: str) -> BaseOutputParser | None:
+    '''Build an output parser based on the provided configurations.
+
+    Args:
+        output_parser_type (str): The type of output parser to use. Supports "json" and "none".
+
+    Returns:
+        BaseOutputParser: The initialized output parser.
+
+    Raises:
+        ValueError: If the provided type is not supported.
+
+    Usage examples:
+        # Using JSON output parser
+        ```python
+        output_parser = build_output_parser(output_parser_type="json")
+        ```
+
+        # Not using output parser
+        ```python
+        output_parser = build_output_parser(output_parser_type="none")
+        ```
+    '''

gllm_inference/catalog/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.catalog.lm_request_processor_catalog import LMRequestProcessorCatalog as LMRequestProcessorCatalog
+from gllm_inference.catalog.prompt_builder_catalog import PromptBuilderCatalog as PromptBuilderCatalog
+
+__all__ = ['LMRequestProcessorCatalog', 'PromptBuilderCatalog']

gllm_inference/catalog/catalog.pyi

@@ -0,0 +1,121 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC
+from pydantic import BaseModel
+from typing import Generic, TypeVar
+
+T = TypeVar('T')
+logger: Incomplete
+
+class BaseCatalog(ABC, BaseModel, Generic[T], arbitrary_types_allowed=True, metaclass=abc.ABCMeta):
+    '''A base class for catalogs used for loading and managing various components in GLLM Inference.
+
+    Attributes:
+        components (dict[str, T]): A dictionary containing the components.
+
+    Initialization:
+        # Example 1: Load from Google Sheets using client email and private key
+        ```python
+        catalog = BaseCatalog.from_gsheets(
+            sheet_id="...",
+            worksheet_id="...",
+            client_email="...",
+            private_key="...",
+        )
+        component = catalog.name
+        ```
+
+        # Example 2: Load from Google Sheets using credential file
+        ```python
+        catalog = BaseCatalog.from_gsheets(
+            sheet_id="...",
+            worksheet_id="...",
+            credential_file_path="...",
+        )
+        component = catalog.name
+        ```
+
+        # Example 3: Load from CSV
+        ```python
+        catalog = BaseCatalog.from_csv(csv_path="...")
+        component = catalog.name
+        ```
+
+        # Example 4: Load from records
+        ```python
+        records = [
+            {"name": "...", "col_1": "...", "col_2": "..."},
+            {"name": "...", "col_1": "...", "col_2": "..."},
+        ]
+        catalog = BaseCatalog.from_records(records=records)
+        component = catalog.name
+    ```
+    '''
+    components: dict[str, T]
+    def __getattr__(self, name: str) -> T:
+        """Fetches a component by attribute name.
+
+        This method attempts to retrieve a component from the `components` dictionary using the provided
+        attribute name. If the attribute is not found, it raises an `AttributeError`.
+
+        Args:
+            name (str): The name of the attribute to fetch.
+
+        Returns:
+            T: The component associated with the given attribute name.
+
+        Raises:
+            AttributeError: If the attribute name does not exist in the `components` dictionary.
+        """
+    @classmethod
+    def from_gsheets(cls, sheet_id: str, worksheet_id: str = '0', credential_file_path: str = None, client_email: str = None, private_key: str = None) -> BaseCatalog[T]:
+        '''Creates a `BaseCatalog[T]` instance from Google Sheets data.
+
+        This class method reads component data from a Google Sheets worksheet and initializes components
+        based on the provided data. Authentication can be provided either by specifying the path to a `credential.json`
+        file or by directly supplying the `client_email` and `private_key`.
+
+        Args:
+            sheet_id (str): The ID of the Google Sheet.
+            worksheet_id (str): The ID of the worksheet within the Google Sheet. Defaults to "0"
+            credential_file_path (str): The file path to the `credential.json` file. If provided, `client_email` and
+                `private_key` are extracted from this file, effectively ignoring the `client_email` and `private_key`
+                arguments. Defaults to None.
+            client_email (str): The client email associated with the service account. This is ignored if
+                `credential_file_path` is provided. Defaults to None.
+            private_key (str): The private key used for authentication. This is ignored if `credential_file_path`
+                is provided. Defaults to None.
+
+        Returns:
+            BaseCatalog[T]: An instance of `BaseCatalog[T]` initialized with components based on the
+                Google Sheets data.
+
+        Raises:
+            ValueError: If authentication credentials are not provided or are invalid.
+        '''
+    @classmethod
+    def from_csv(cls, csv_path: str) -> BaseCatalog[T]:
+        """Creates a `BaseCatalog[T]` instance from CSV data.
+
+        This class method reads component data from a CSV file and initializes components based on the provided data.
+
+        Args:
+            csv_path (str): The file path to the CSV containing component data.
+
+        Returns:
+            BaseCatalog[T]: An instance of `BaseCatalog[T]` initialized with components based on the
+                CSV data.
+        """
+    @classmethod
+    def from_records(cls, records: list[dict[str, str]]) -> BaseCatalog[T]:
+        """Creates a `BaseCatalog[T]` instance from a list of records.
+
+        This class method builds a catalog from the provided records.
+
+        Args:
+            records (list[dict[str, str]]): A list of records containing component data.
+
+        Returns:
+            BaseCatalog[T]: An instance of `BaseCatalog[T]` initialized with components based on the
+                list of records.
+        """

gllm_inference/catalog/lm_request_processor_catalog.pyi

@@ -0,0 +1,112 @@
+from _typeshed import Incomplete
+from gllm_inference.builder import build_lm_request_processor as build_lm_request_processor
+from gllm_inference.catalog.catalog import BaseCatalog as BaseCatalog
+from gllm_inference.request_processor import LMRequestProcessor as LMRequestProcessor
+
+MODEL_ID_ENV_VAR_REGEX_PATTERN: str
+LM_REQUEST_PROCESSOR_REQUIRED_COLUMNS: Incomplete
+CONFIG_SCHEMA_MAP: Incomplete
+logger: Incomplete
+
+class LMRequestProcessorCatalog(BaseCatalog[LMRequestProcessor]):
+    '''Loads multiple LM request processors from certain sources.
+
+    Attributes:
+        components (dict[str, LMRequestProcessor]): Dictionary of the loaded LM request processors.
+
+    Initialization:
+        # Example 1: Load from Google Sheets using client email and private key
+        ```python
+        catalog = LMRequestProcessorCatalog.from_gsheets(
+            sheet_id="...",
+            worksheet_id="...",
+            client_email="...",
+            private_key="...",
+        )
+
+        lm_request_processor = catalog.name
+        ```
+
+        # Example 2: Load from Google Sheets using credential file
+        ```python
+        catalog = LMRequestProcessorCatalog.from_gsheets(
+            sheet_id="...",
+            worksheet_id="...",
+            credential_file_path="...",
+        )
+
+        lm_request_processor = catalog.name
+        ```
+
+        # Example 3: Load from CSV
+        ```python
+        catalog = LMRequestProcessorCatalog.from_csv(csv_path="...")
+
+        lm_request_processor = catalog.name
+        ```
+
+        # Example 4: Load from record
+        ```python
+        records=[
+            {
+                "name": "answer_question",
+                "system_template": (
+                    "You are helpful assistant.\\n"
+                    "Answer the following question based on the provided context.\\n"
+                    "```{context}```"
+                ),
+                "user_template": "{query}",
+                "key_defaults": \'{"context": "<default context>"}\',
+                "model_id": "openai/gpt-4.1-nano",
+                "credentials": "OPENAI_API_KEY",
+                "config": "",
+                "output_parser_type": "none",
+            },
+        ]
+        catalog = LMRequestProcessorCatalog.from_records(records=records)
+        lm_request_processor = catalog.answer_question
+        ```
+
+    Template Format Example:
+        # Example 1: Google Sheets
+        For an example of how a Google Sheets file can be formatted to be loaded using LMRequestProcessorCatalog, see:
+        https://docs.google.com/spreadsheets/d/1CX9i45yEinv1UdB3s6uHNMj7mxr2-s1NFHfFDvMsq0E/edit?usp=drive_link
+
+        # Example 2: CSV
+        For an example of how a CSV file can be formatted to be loaded using LMRequestProcessorCatalog, see:
+        https://drive.google.com/file/d/1_2rSoxh3CR2KZxIyUmpowMrt0Lm0YqAb/view?usp=drive_link
+
+    Template Explanation:
+        The required columns are:
+        1. name (str): The name of the LM request processor.
+        2. system_template (str): The system template of the prompt builder.
+        3. user_template (str): The user template of the prompt builder.
+        4. key_defaults (json_str): The default values for the prompt template keys.
+        5. model_id (str): The model ID of the LM invoker.
+        6. credentials (str | json_str): The credentials of the LM invoker.
+        7. config (json_str): The additional configuration of the LM invoker.
+        8. output_parser_type (str): The type of the output parser.
+
+        Important Notes:
+        1. At least one of `system_template` or `user_template` must be filled.
+        2. `key_defaults` is optional. If filled, must be a dictionary containing the default values for the
+            prompt template keys. These default values will be applied when the corresponding keys are not provided
+            in the runtime input. If it is empty, the prompt template keys will not have default values.
+        3. The `model_id`:
+            3.1. Must be filled with the model ID of the LM invoker, e.g. "openai/gpt-4.1-nano".
+            3.2. Can be partially loaded from the environment variable using the "${ENV_VAR_KEY}" syntax,
+                e.g. "azure-openai/${AZURE_ENDPOINT}/${AZURE_DEPLOYMENT}".
+            3.3. For the available model ID formats, see: https://gdplabs.gitbook.io/sdk/resources/supported-models
+        4. `credentials` is optional. If it is filled, it can either be:
+            4.1. An environment variable name containing the API key (e.g. OPENAI_API_KEY).
+            4.2. An environment variable name containing the path to a credentials JSON file
+                (e.g. GOOGLE_CREDENTIALS_FILE_PATH). Currently only supported for Google Vertex AI.
+            4.3. A dictionary of credentials, with each value being an environment variable name corresponding to the
+                credential (e.g. {"api_key": "OPENAI_API_KEY"}). Currently supported for Bedrock and LangChain.
+            If it is empty, the LM invoker will use the default credentials loaded from the environment variables.
+        5. `config` is optional. If filled, must be a dictionary containing the configuration for the LM invoker.
+            If it is empty, the LM invoker will use the default configuration.
+        6. `output_parser_type` can either be:
+            6.1. none: No output parser will be used.
+            6.2. json: The JSONOutputParser will be used.
+    '''