gllm-inference-binary 0.5.9b1__cp311-cp311-macosx_10_9_universal2.macosx_13_0_x86_64.whl

gllm_inference/catalog/prompt_builder_catalog.pyi

@@ -0,0 +1,82 @@
+from _typeshed import Incomplete
+from gllm_inference.catalog.catalog import BaseCatalog as BaseCatalog
+from gllm_inference.prompt_builder.prompt_builder import PromptBuilder as PromptBuilder
+
+PROMPT_BUILDER_REQUIRED_COLUMNS: Incomplete
+logger: Incomplete
+
+class PromptBuilderCatalog(BaseCatalog[PromptBuilder]):
+    '''Loads multiple prompt builders from certain sources.
+
+    Attributes:
+        components (dict[str, PromptBuilder]): Dictionary of the loaded prompt builders.
+
+    Initialization:
+        # Example 1: Load from Google Sheets using client email and private key
+        ```python
+        catalog = PromptBuilderCatalog.from_gsheets(
+            sheet_id="...",
+            worksheet_id="...",
+            client_email="...",
+            private_key="...",
+        )
+        prompt_builder = catalog.name
+        ```
+
+        # Example 2: Load from Google Sheets using credential file
+        ```python
+        catalog = PromptBuilderCatalog.from_gsheets(
+            sheet_id="...",
+            worksheet_id="...",
+            credential_file_path="...",
+        )
+        prompt_builder = catalog.name
+        ```
+
+        # Example 3: Load from CSV
+        ```python
+        catalog = PromptBuilderCatalog.from_csv(csv_path="...")
+        prompt_builder = catalog.name
+        ```
+
+        # Example 4: Load from records
+        ```python
+        records=[
+            {
+                "name": "answer_question",
+                "system": (
+                    "You are helpful assistant.\\n"
+                    "Answer the following question based on the provided context.\\n"
+                    "```{context}```"
+                ),
+                "user": "{query}",
+                "key_defaults": \'{"context": "<default context>"}\',
+            },
+        ]
+        catalog = PromptBuilderCatalog.from_records(records=records)
+        prompt_builder = catalog.answer_question
+        ```
+
+    Template Example:
+        # Example 1: Google Sheets
+        For an example of how a Google Sheets file can be formatted to be loaded using PromptBuilderCatalog, see:
+        https://docs.google.com/spreadsheets/d/12IwSKv8hMhyWXSQnLx9LgCj0cxaR1f9gOmbEDGleurE/edit?usp=drive_link
+
+        # Example 2: CSV
+        For an example of how a CSV file can be formatted to be loaded using PromptBuilderCatalog, see:
+        https://drive.google.com/file/d/1KQgddMdbcZBZmroQFtjSl-TKLohq84Fz/view?usp=drive_link
+
+
+    Template explanation:
+        The required columns are:
+        1. name (str): The name of the prompt builder.
+        2. system (str): The system template of the prompt builder.
+        3. user (str): The user template of the prompt builder.
+        4. key_defaults (json_str): The default values for the prompt template keys.
+
+        Important Notes:
+        1. At least one of the `system` and `user` columns 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.
+    '''

gllm_inference/constants.pyi

@@ -0,0 +1,10 @@
+from _typeshed import Incomplete
+
+AZURE_OPENAI_URL_SUFFIX: str
+DOCUMENT_MIME_TYPES: Incomplete
+GOOGLE_SCOPES: Incomplete
+GRPC_ENABLE_RETRIES_KEY: str
+INVOKER_PROPAGATED_MAX_RETRIES: int
+INVOKER_DEFAULT_TIMEOUT: float
+HEX_REPR_LENGTH: int
+SECONDS_TO_MILLISECONDS: int

gllm_inference/em_invoker/__init__.pyi

@@ -0,0 +1,10 @@
+from gllm_inference.em_invoker.azure_openai_em_invoker import AzureOpenAIEMInvoker as AzureOpenAIEMInvoker
+from gllm_inference.em_invoker.bedrock_em_invoker import BedrockEMInvoker as BedrockEMInvoker
+from gllm_inference.em_invoker.google_em_invoker import GoogleEMInvoker as GoogleEMInvoker
+from gllm_inference.em_invoker.langchain_em_invoker import LangChainEMInvoker as LangChainEMInvoker
+from gllm_inference.em_invoker.openai_compatible_em_invoker import OpenAICompatibleEMInvoker as OpenAICompatibleEMInvoker
+from gllm_inference.em_invoker.openai_em_invoker import OpenAIEMInvoker as OpenAIEMInvoker
+from gllm_inference.em_invoker.twelevelabs_em_invoker import TwelveLabsEMInvoker as TwelveLabsEMInvoker
+from gllm_inference.em_invoker.voyage_em_invoker import VoyageEMInvoker as VoyageEMInvoker
+
+__all__ = ['AzureOpenAIEMInvoker', 'BedrockEMInvoker', 'GoogleEMInvoker', 'LangChainEMInvoker', 'OpenAIEMInvoker', 'OpenAICompatibleEMInvoker', 'TwelveLabsEMInvoker', 'VoyageEMInvoker']

gllm_inference/em_invoker/azure_openai_em_invoker.pyi

@@ -0,0 +1,88 @@
+from _typeshed import Incomplete
+from gllm_core.utils.retry import RetryConfig as RetryConfig
+from gllm_inference.constants import AZURE_OPENAI_URL_SUFFIX as AZURE_OPENAI_URL_SUFFIX, INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES
+from gllm_inference.em_invoker.openai_em_invoker import OpenAIEMInvoker as OpenAIEMInvoker
+from gllm_inference.em_invoker.schema.openai import Key as Key
+from gllm_inference.schema import ModelId as ModelId, ModelProvider as ModelProvider, TruncationConfig as TruncationConfig
+from typing import Any
+
+class AzureOpenAIEMInvoker(OpenAIEMInvoker):
+    '''An embedding model invoker to interact with Azure OpenAI embedding models.
+
+    Attributes:
+        model_id (str): The model ID of the embedding model.
+        model_provider (str): The provider of the embedding model.
+        model_name (str): The name of the Azure OpenAI embedding model deployment.
+        client (AsyncAzureOpenAI): The client for the Azure OpenAI API.
+        default_hyperparameters (dict[str, Any]): Default hyperparameters for invoking the embedding model.
+        retry_config (RetryConfig): The retry configuration for the embedding model.
+        truncation_config (TruncationConfig | None): The truncation configuration for the embedding model.
+
+    Input types:
+        The `AzureOpenAIEMInvoker` only supports text inputs.
+
+    Output format:
+        The `AzureOpenAIEMInvoker` can embed either:
+        1. A single content.
+           1. A single content is a single text.
+           2. The output will be a `Vector`, representing the embedding of the content.
+
+           # Example 1: Embedding a text content.
+           ```python
+           text = "This is a text"
+           result = await em_invoker.invoke(text)
+           ```
+
+           The above examples will return a `Vector` with a size of (embedding_size,).
+
+        2. A list of contents.
+           1. A list of contents is a list of texts.
+           2. The output will be a `list[Vector]`, where each element is a `Vector` representing the
+              embedding of each single content.
+
+           # Example: Embedding a list of contents.
+           ```python
+           text1 = "This is a text"
+           text2 = "This is another text"
+           text3 = "This is yet another text"
+           result = await em_invoker.invoke([text1, text2, text3])
+           ```
+
+           The above examples will return a `list[Vector]` with a size of (3, embedding_size).
+
+    Retry and timeout:
+        The `AzureOpenAIEMInvoker` supports retry and timeout configuration.
+        By default, the max retries is set to 0 and the timeout is set to 30.0 seconds.
+        They can be customized by providing a custom `RetryConfig` object to the `retry_config` parameter.
+
+        Retry config examples:
+        ```python
+        retry_config = RetryConfig(max_retries=0, timeout=0.0)  # No retry, no timeout
+        retry_config = RetryConfig(max_retries=0, timeout=10.0)  # No retry, 10.0 seconds timeout
+        retry_config = RetryConfig(max_retries=5, timeout=0.0)  # 5 max retries, no timeout
+        retry_config = RetryConfig(max_retries=5, timeout=10.0)  # 5 max retries, 10.0 seconds timeout
+        ```
+
+        Usage example:
+        ```python
+        em_invoker = AzureOpenAIEMInvoker(..., retry_config=retry_config)
+        ```
+    '''
+    client: Incomplete
+    def __init__(self, azure_endpoint: str, azure_deployment: str, api_key: str | None = None, api_version: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, retry_config: RetryConfig | None = None, truncation_config: TruncationConfig | None = None) -> None:
+        """Initializes a new instance of the AzureOpenAIEMInvoker class.
+
+        Args:
+            azure_endpoint (str): The endpoint of the Azure OpenAI service.
+            azure_deployment (str): The deployment name of the Azure OpenAI service.
+            api_key (str | None, optional): The API key for authenticating with Azure OpenAI. Defaults to None, in
+                which case the `AZURE_OPENAI_API_KEY` environment variable will be used.
+            api_version (str | None, optional): Deprecated parameter to be removed in v0.6. Defaults to None.
+            model_kwargs (dict[str, Any] | None, optional): Additional model parameters. Defaults to None.
+            default_hyperparameters (dict[str, Any] | None, optional): Default hyperparameters for invoking the model.
+                Defaults to None.
+            retry_config (RetryConfig | None, optional): The retry configuration for the embedding model.
+                Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
+            truncation_config (TruncationConfig | None, optional): Configuration for text truncation behavior.
+                Defaults to None, in which case no truncation is applied.
+        """

gllm_inference/em_invoker/bedrock_em_invoker.pyi

@@ -0,0 +1,106 @@
+from _typeshed import Incomplete
+from enum import StrEnum
+from gllm_core.utils.retry import RetryConfig as RetryConfig
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker as BaseEMInvoker
+from gllm_inference.em_invoker.schema.bedrock import InputType as InputType, Key as Key, OutputType as OutputType
+from gllm_inference.exceptions import BaseInvokerError as BaseInvokerError, convert_http_status_to_base_invoker_error as convert_http_status_to_base_invoker_error
+from gllm_inference.exceptions.provider_error_map import BEDROCK_ERROR_MAPPING as BEDROCK_ERROR_MAPPING
+from gllm_inference.schema import ModelId as ModelId, ModelProvider as ModelProvider, TruncationConfig as TruncationConfig, Vector as Vector
+from typing import Any
+
+class ModelType(StrEnum):
+    """Defines the type of the Bedrock embedding model."""
+    COHERE = 'cohere'
+    TITAN = 'titan'
+
+SUPPORTED_ATTACHMENTS: Incomplete
+
+class BedrockEMInvoker(BaseEMInvoker):
+    '''An embedding model invoker to interact with AWS Bedrock embedding models.
+
+    Attributes:
+        model_id (str): The model ID of the embedding model.
+        model_provider (str): The provider of the embedding model.
+        model_name (str): The name of the embedding model.
+        session (Session): The Bedrock client session.
+        client_kwargs (dict[str, Any]): The Bedrock client kwargs.
+        default_hyperparameters (dict[str, Any]): Default hyperparameters for invoking the embedding model.
+        retry_config (RetryConfig): The retry configuration for the embedding model.
+        truncation_config (TruncationConfig | None): The truncation configuration for the embedding model.
+
+    Input types:
+        The `BedrockEMInvoker` only supports text inputs.
+
+    Output format:
+        The `BedrockEMInvoker` can embed either:
+        1. A single content.
+           1. A single content is a single text.
+           2. The output will be a `Vector`, representing the embedding of the content.
+
+           # Example 1: Embedding a text content.
+           ```python
+           text = "This is a text"
+           result = await em_invoker.invoke(text)
+           ```
+
+           The above examples will return a `Vector` with a size of (embedding_size,).
+
+        2. A list of contents.
+           1. A list of contents is a list of texts.
+           2. The output will be a `list[Vector]`, where each element is a `Vector` representing the
+              embedding of each single content.
+
+           # Example: Embedding a list of contents.
+           ```python
+           text1 = "This is a text"
+           text2 = "This is another text"
+           text3 = "This is yet another text"
+           result = await em_invoker.invoke([text1, text2, text3])
+           ```
+
+           The above examples will return a `list[Vector]` with a size of (3, embedding_size).
+
+    Retry and timeout:
+        The `BedrockEMInvoker` supports retry and timeout configuration.
+        By default, the max retries is set to 0 and the timeout is set to 30.0 seconds.
+        They can be customized by providing a custom `RetryConfig` object to the `retry_config` parameter.
+
+        Retry config examples:
+        ```python
+        retry_config = RetryConfig(max_retries=0, timeout=0.0)  # No retry, no timeout
+        retry_config = RetryConfig(max_retries=0, timeout=10.0)  # No retry, 10.0 seconds timeout
+        retry_config = RetryConfig(max_retries=5, timeout=0.0)  # 5 max retries, no timeout
+        retry_config = RetryConfig(max_retries=5, timeout=10.0)  # 5 max retries, 10.0 seconds timeout
+        ```
+
+        Usage example:
+        ```python
+        em_invoker = BedrockEMInvoker(..., retry_config=retry_config)
+        ```
+    '''
+    session: Incomplete
+    client_kwargs: Incomplete
+    def __init__(self, model_name: str, access_key_id: str | None = None, secret_access_key: str | None = None, region_name: str = 'us-east-1', model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, retry_config: RetryConfig | None = None, truncation_config: TruncationConfig | None = None) -> None:
+        '''Initializes a new instance of the BedrockEMInvoker class.
+
+        Args:
+            model_name (str): The name of the Bedrock embedding model to be used.
+            access_key_id (str | None, optional): The AWS access key ID. Defaults to None, in which case
+                the `AWS_ACCESS_KEY_ID` environment variable will be used.
+            secret_access_key (str | None, optional): The AWS secret access key. Defaults to None, in which case
+                the `AWS_SECRET_ACCESS_KEY` environment variable will be used.
+            region_name (str, optional): The AWS region name. Defaults to "us-east-1".
+            model_kwargs (dict[str, Any] | None, optional): Additional keyword arguments for the Bedrock client.
+                Defaults to None.
+            default_hyperparameters (dict[str, Any] | None, optional): Default hyperparameters for invoking the model.
+                Defaults to None.
+            retry_config (RetryConfig | None, optional): The retry configuration for the embedding model.
+                Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
+            truncation_config (TruncationConfig | None, optional): Configuration for text truncation behavior.
+                Defaults to None, in which case no truncation is applied.
+
+        Raises:
+            ValueError: If the model name is not supported.
+            ValueError: If `access_key_id` or `secret_access_key` is neither provided nor set in the
+                `AWS_ACCESS_KEY_ID` or `AWS_SECRET_ACCESS_KEY` environment variables, respectively.
+        '''

gllm_inference/em_invoker/em_invoker.pyi

@@ -0,0 +1,90 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC
+from gllm_core.utils.retry import RetryConfig
+from gllm_inference.constants import DOCUMENT_MIME_TYPES as DOCUMENT_MIME_TYPES, INVOKER_DEFAULT_TIMEOUT as INVOKER_DEFAULT_TIMEOUT
+from gllm_inference.exceptions import BaseInvokerError as BaseInvokerError, convert_to_base_invoker_error as convert_to_base_invoker_error
+from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, EMContent as EMContent, ModelId as ModelId, TruncateSide as TruncateSide, TruncationConfig as TruncationConfig, Vector as Vector
+from typing import Any
+
+class BaseEMInvoker(ABC, metaclass=abc.ABCMeta):
+    """A base class for embedding model invokers used in Gen AI applications.
+
+    The `BaseEMInvoker` class provides a framework for invoking embedding models.
+
+    Attributes:
+        model_id (str): The model ID of the embedding model.
+        model_provider (str): The provider of the embedding model.
+        model_name (str): The name of the embedding model.
+        default_hyperparameters (dict[str, Any]): Default hyperparameters for invoking the
+            embedding model. Defaults to None, in which case an empty dictionary is used.
+        retry_config (RetryConfig): The retry configuration for the embedding model.
+            Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
+        truncation_config (TruncationConfig | None): The truncation configuration for the embedding model.
+            Defaults to None, in which case no truncation is applied.
+    """
+    default_hyperparameters: Incomplete
+    retry_config: Incomplete
+    truncation_config: Incomplete
+    def __init__(self, model_id: ModelId, default_hyperparameters: dict[str, Any] | None = None, supported_attachments: set[str] | None = None, retry_config: RetryConfig | None = None, truncation_config: TruncationConfig | None = None) -> None:
+        """Initializes a new instance of the BaseEMInvoker class.
+
+        Args:
+            model_id (ModelId): The model ID of the embedding model.
+            default_hyperparameters (dict[str, Any] | None, optional): Default hyperparameters for invoking the
+                embedding model. Defaults to None, in which case an empty dictionary is used.
+            supported_attachments (set[str] | None, optional): A set of supported attachment types. Defaults to None,
+                in which case an empty set is used (indicating that no attachments are supported).
+            retry_config (RetryConfig | None, optional): The retry configuration for the embedding model.
+                Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
+            truncation_config (TruncationConfig | None, optional): Configuration for text truncation behavior.
+                Defaults to None, in which case no truncation is applied.
+        """
+    @property
+    def model_id(self) -> str:
+        """The model ID of the embedding model.
+
+        Returns:
+            str: The model ID of the embedding model.
+        """
+    @property
+    def model_provider(self) -> str:
+        """The provider of the embedding model.
+
+        Returns:
+            str: The provider of the embedding model.
+        """
+    @property
+    def model_name(self) -> str:
+        """The name of the embedding model.
+
+        Returns:
+            str: The name of the embedding model.
+        """
+    async def invoke(self, content: EMContent | list[EMContent], hyperparameters: dict[str, Any] | None = None) -> Vector | list[Vector]:
+        """Invokes the embedding model with the provided content or list of contents.
+
+        This method invokes the embedding model with the provided content or list of contents.
+        It includes retry logic with exponential backoff for transient failures.
+
+        Args:
+            content (EMContent | list[EMContent]): The input or list of inputs to be embedded using the embedding model.
+            hyperparameters (dict[str, Any] | None, optional): A dictionary of hyperparameters for the embedding model.
+                Defaults to None, in which case the default hyperparameters are used.
+
+        Returns:
+            Vector | list[Vector]: The vector representations of the input contents:
+                1. If the input is an `EMContent`, the output is a `Vector`.
+                2. If the input is a `list[EMContent]`, the output is a `list[Vector]`.
+
+        Raises:
+            CancelledError: If the invocation is cancelled.
+            ModelNotFoundError: If the model is not found.
+            ProviderAuthError: If the model authentication fails.
+            ProviderInternalError: If the model internal error occurs.
+            ProviderInvalidArgsError: If the model parameters are invalid.
+            ProviderOverloadedError: If the model is overloaded.
+            ProviderRateLimitError: If the model rate limit is exceeded.
+            TimeoutError: If the invocation times out.
+            ValueError: If the input content is invalid.
+        """

gllm_inference/em_invoker/google_em_invoker.pyi

@@ -0,0 +1,129 @@
+from _typeshed import Incomplete
+from gllm_core.utils.retry import RetryConfig as RetryConfig
+from gllm_inference.constants import GOOGLE_SCOPES as GOOGLE_SCOPES, SECONDS_TO_MILLISECONDS as SECONDS_TO_MILLISECONDS
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker as BaseEMInvoker
+from gllm_inference.em_invoker.schema.google import Key as Key
+from gllm_inference.exceptions import BaseInvokerError as BaseInvokerError, convert_http_status_to_base_invoker_error as convert_http_status_to_base_invoker_error
+from gllm_inference.exceptions.provider_error_map import GOOGLE_ERROR_MAPPING as GOOGLE_ERROR_MAPPING
+from gllm_inference.schema import ModelId as ModelId, ModelProvider as ModelProvider, TruncationConfig as TruncationConfig, Vector as Vector
+from typing import Any
+
+SUPPORTED_ATTACHMENTS: Incomplete
+
+class GoogleEMInvoker(BaseEMInvoker):
+    '''An embedding model invoker to interact with Google embedding models.
+
+    Attributes:
+        model_id (str): The model ID of the embedding model.
+        model_provider (str): The provider of the embedding model.
+        model_name (str): The name of the embedding model.
+        client_params (dict[str, Any]): The Google client instance init parameters.
+        default_hyperparameters (dict[str, Any]): Default hyperparameters for invoking the embedding model.
+        retry_config (RetryConfig): The retry configuration for the embedding model.
+        truncation_config (TruncationConfig | None): The truncation configuration for the embedding model.
+
+    Initialization:
+        The `GoogleEMInvoker` can use either Google Gen AI or Google Vertex AI.
+
+        Google Gen AI is recommended for quick prototyping and development.
+        It requires a Gemini API key for authentication.
+
+        Usage example:
+        ```python
+        em_invoker = GoogleEMInvoker(
+            model_name="text-embedding-004",
+            api_key="your_api_key"
+        )
+        ```
+
+        Google Vertex AI is recommended to build production-ready applications.
+        It requires a service account JSON file for authentication.
+
+        Usage example:
+        ```python
+        em_invoker = GoogleEMInvoker(
+            model_name="text-embedding-004",
+            credentials_path="path/to/service_account.json"
+        )
+        ```
+
+        If neither `api_key` nor `credentials_path` is provided, Google Gen AI will be used by default.
+        The `GOOGLE_API_KEY` environment variable will be used for authentication.
+
+    Input types:
+        The `GoogleEMInvoker` only supports text inputs.
+
+    Output format:
+        The `GoogleEMInvoker` can embed either:
+        1. A single content.
+           1. A single content is a single text.
+           2. The output will be a `Vector`, representing the embedding of the content.
+
+           # Example 1: Embedding a text content.
+           ```python
+           text = "This is a text"
+           result = await em_invoker.invoke(text)
+           ```
+
+           The above examples will return a `Vector` with a size of (embedding_size,).
+
+        2. A list of contents.
+           1. A list of contents is a list of texts.
+           2. The output will be a `list[Vector]`, where each element is a `Vector` representing the
+              embedding of each single content.
+
+           # Example: Embedding a list of contents.
+           ```python
+           text1 = "This is a text"
+           text2 = "This is another text"
+           text3 = "This is yet another text"
+           result = await em_invoker.invoke([text1, text2, text3])
+           ```
+
+           The above examples will return a `list[Vector]` with a size of (3, embedding_size).
+
+    Retry and timeout:
+        The `GoogleEMInvoker` supports retry and timeout configuration.
+        By default, the max retries is set to 0 and the timeout is set to 30.0 seconds.
+        They can be customized by providing a custom `RetryConfig` object to the `retry_config` parameter.
+
+        Retry config examples:
+        ```python
+        retry_config = RetryConfig(max_retries=0, timeout=0.0)  # No retry, no timeout
+        retry_config = RetryConfig(max_retries=0, timeout=10.0)  # No retry, 10.0 seconds timeout
+        retry_config = RetryConfig(max_retries=5, timeout=0.0)  # 5 max retries, no timeout
+        retry_config = RetryConfig(max_retries=5, timeout=10.0)  # 5 max retries, 10.0 seconds timeout
+        ```
+
+        Usage example:
+        ```python
+        em_invoker = GoogleEMInvoker(..., retry_config=retry_config)
+        ```
+    '''
+    client_params: Incomplete
+    def __init__(self, model_name: str, api_key: str | None = None, credentials_path: str | None = None, project_id: str | None = None, location: str = 'us-central1', model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, retry_config: RetryConfig | None = None, truncation_config: TruncationConfig | None = None) -> None:
+        '''Initializes a new instance of the GoogleEMInvoker class.
+
+        Args:
+            model_name (str): The name of the model to use.
+            api_key (str | None, optional): Required for Google Gen AI authentication. Cannot be used together
+                with `credentials_path`. Defaults to None.
+            credentials_path (str | None, optional): Required for Google Vertex AI authentication. Path to the service
+                account credentials JSON file. Cannot be used together with `api_key`. Defaults to None.
+            project_id (str | None, optional): The Google Cloud project ID for Vertex AI. Only used when authenticating
+                with `credentials_path`. Defaults to None, in which case it will be loaded from the credentials file.
+            location (str, optional): The location of the Google Cloud project for Vertex AI. Only used when
+                authenticating with `credentials_path`. Defaults to "us-central1".
+            model_kwargs (dict[str, Any] | None, optional): Additional keyword arguments for the Google client.
+                Defaults to None.
+            default_hyperparameters (dict[str, Any] | None, optional): Default hyperparameters for invoking the model.
+                Defaults to None.
+            retry_config (RetryConfig | None, optional): The retry configuration for the embedding model.
+                Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
+            truncation_config (TruncationConfig | None, optional): Configuration for text truncation behavior.
+                Defaults to None, in which case no truncation is applied.
+
+        Note:
+            If neither `api_key` nor `credentials_path` is provided, Google Gen AI will be used by default.
+            The `GOOGLE_API_KEY` environment variable will be used for authentication.
+        '''

gllm_inference/em_invoker/langchain/__init__.pyi

@@ -0,0 +1,3 @@
+from gllm_inference.em_invoker.langchain.em_invoker_embeddings import EMInvokerEmbeddings as EMInvokerEmbeddings
+
+__all__ = ['EMInvokerEmbeddings']

gllm_inference/em_invoker/langchain/em_invoker_embeddings.pyi

@@ -0,0 +1,84 @@
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker as BaseEMInvoker
+from gllm_inference.schema import Attachment as Attachment, Vector as Vector
+from gllm_inference.utils.io_utils import DEFAULT_BASE64_ALLOWED_MIMETYPES as DEFAULT_BASE64_ALLOWED_MIMETYPES, base64_to_bytes as base64_to_bytes
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel
+from typing import Any
+
+class EMInvokerEmbeddings(BaseModel, Embeddings, arbitrary_types_allowed=True):
+    '''An adapter class that enables an `EMInvoker` to be used as a LangChain `Embeddings`.
+
+    Attributes:
+        em_invoker (BaseEMInvoker): The `EMInvoker` instance to be interacted with.
+        use_base64 (bool):
+            Whether to apply strict base64 encoding to the input.
+            1, If `True`, only inputs with specific MIME types (e.g. images,
+              audio, and video) will be converted into base64 strings before being sent.
+            2. If `False`, each input is treated as a raw string.
+
+            This ensures "strict" handling: base64 encoding is not applied
+            universally, but only when required for those MIME types.
+
+    Usage example:
+    ```python
+    from gllm_inference.em_invoker.langchain import EMInvokerEmbeddings
+    from gllm_inference.em_invoker import OpenAIEMInvoker
+
+    em_invoker = OpenAIEMInvoker(...)
+    embeddings = EMInvokerEmbeddings(em_invoker=em_invoker)
+    ```
+    '''
+    em_invoker: BaseEMInvoker
+    use_base64: bool
+    async def aembed_documents(self, texts: list[str], **kwargs: Any) -> list[Vector]:
+        """Asynchronously embed documents using the `EMInvoker`.
+
+        Args:
+            texts (list[str]): The list of texts to embed.
+            **kwargs (Any): Additional keyword arguments to pass to the EMInvoker's `invoke` method.
+
+        Returns:
+            list[Vector]: List of embeddings, one for each text.
+
+        Raises:
+            ValueError: If `texts` is not a list of strings.
+        """
+    async def aembed_query(self, text: str, **kwargs: Any) -> Vector:
+        """Asynchronously embed query using the `EMInvoker`.
+
+        Args:
+            text (str): The text to embed.
+            **kwargs (Any): Additional keyword arguments to pass to the EMInvoker's `invoke` method.
+
+        Returns:
+            Vector: Embeddings for the text.
+
+        Raises:
+            ValueError: If `text` is not a string.
+        """
+    def embed_documents(self, texts: list[str], **kwargs: Any) -> list[Vector]:
+        """Embed documents using the `EMInvoker`.
+
+        Args:
+            texts (list[str]): The list of texts to embed.
+            **kwargs (Any): Additional keyword arguments to pass to the EMInvoker's `invoke` method.
+
+        Returns:
+            list[Vector]: List of embeddings, one for each text.
+
+        Raises:
+            ValueError: If `texts` is not a list of strings.
+        """
+    def embed_query(self, text: str, **kwargs: Any) -> Vector:
+        """Embed query using the `EMInvoker`.
+
+        Args:
+            text (str): The text to embed.
+            **kwargs (Any): Additional keyword arguments to pass to the EMInvoker's `invoke` method.
+
+        Returns:
+            Vector: Embeddings for the text.
+
+        Raises:
+            ValueError: If `text` is not a string.
+        """

gllm_inference/em_invoker/langchain_em_invoker.pyi

@@ -0,0 +1,46 @@
+from _typeshed import Incomplete
+from gllm_core.utils.retry import RetryConfig
+from gllm_inference.constants import INVOKER_DEFAULT_TIMEOUT as INVOKER_DEFAULT_TIMEOUT, INVOKER_PROPAGATED_MAX_RETRIES as INVOKER_PROPAGATED_MAX_RETRIES
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker as BaseEMInvoker
+from gllm_inference.em_invoker.schema.langchain import Key as Key
+from gllm_inference.exceptions import BaseInvokerError as BaseInvokerError, InvokerRuntimeError as InvokerRuntimeError, build_debug_info as build_debug_info
+from gllm_inference.exceptions.provider_error_map import ALL_PROVIDER_ERROR_MAPPINGS as ALL_PROVIDER_ERROR_MAPPINGS, LANGCHAIN_ERROR_CODE_MAPPING as LANGCHAIN_ERROR_CODE_MAPPING
+from gllm_inference.schema import ModelId as ModelId, ModelProvider as ModelProvider, TruncationConfig as TruncationConfig, Vector as Vector
+from gllm_inference.utils import load_langchain_model as load_langchain_model, parse_model_data as parse_model_data
+from langchain_core.embeddings import Embeddings as Embeddings
+from typing import Any
+
+SUPPORTED_ATTACHMENTS: Incomplete
+
+class LangChainEMInvoker(BaseEMInvoker):
+    """A language model invoker to interact with LangChain's Embeddings.
+
+    Attributes:
+        model_id (str): The model ID of the embedding model.
+        model_provider (str): The provider of the embedding model.
+        model_name (str): The name of the embedding model.
+        em (Embeddings): The instance to interact with an embedding model defined using LangChain's Embeddings.
+        retry_config (RetryConfig): The retry configuration for the embedding model.
+        truncation_config (TruncationConfig | None): The truncation configuration for the embedding model.
+    """
+    model: Incomplete
+    def __init__(self, model: Embeddings | None = None, model_class_path: str | None = None, model_name: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, retry_config: RetryConfig | None = None, truncation_config: TruncationConfig | None = None) -> None:
+        '''Initializes a new instance of the LangChainEMInvoker class.
+
+        Args:
+            model (Embeddings | None, optional): The LangChain\'s Embeddings instance. If provided, will take
+                precedence over the `model_class_path` parameter. Defaults to None.
+            model_class_path (str | None, optional): The LangChain\'s Embeddings class path. Must be formatted as
+                "<package>.<class>" (e.g. "langchain_openai.OpenAIEmbeddings"). Ignored if `model` is provided.
+                Defaults to None.
+            model_name (str | None, optional): The model name. Only used if `model_class_path` is provided.
+                Defaults to None.
+            model_kwargs (dict[str, Any] | None, optional): The additional keyword arguments. Only used if
+                `model_class_path` is provided. Defaults to None.
+            default_hyperparameters (dict[str, Any] | None, optional): Default hyperparameters for invoking the model.
+                Defaults to None.
+            retry_config (RetryConfig | None, optional): The retry configuration for the embedding model.
+                Defaults to None, in which case a default config with no retry and 30.0 seconds timeout will be used.
+            truncation_config (TruncationConfig | None, optional): Configuration for text truncation behavior.
+                Defaults to None, in which case no truncation is applied.
+        '''