mediapipe-nightly 0.10.21.post20250114__cp312-cp312-manylinux_2_28_x86_64.whl

mediapipe/tasks/python/core/base_options.py

@@ -0,0 +1,121 @@
+# Copyright 2022 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Base options for MediaPipe Task APIs."""
+
+import dataclasses
+import enum
+import os
+import platform
+from typing import Any, Optional
+
+from mediapipe.calculators.tensor import inference_calculator_pb2
+from mediapipe.tasks.cc.core.proto import acceleration_pb2
+from mediapipe.tasks.cc.core.proto import base_options_pb2
+from mediapipe.tasks.cc.core.proto import external_file_pb2
+from mediapipe.tasks.python.core.optional_dependencies import doc_controls
+
+_DelegateProto = inference_calculator_pb2.InferenceCalculatorOptions.Delegate
+_AccelerationProto = acceleration_pb2.Acceleration
+_BaseOptionsProto = base_options_pb2.BaseOptions
+_ExternalFileProto = external_file_pb2.ExternalFile
+
+
+@dataclasses.dataclass
+class BaseOptions:
+  """Base options for MediaPipe Tasks' Python APIs.
+
+  Represents external model asset used by the Task APIs. The files can be
+  specified by one of the following two ways:
+
+  (1) model asset file path in `model_asset_path`.
+  (2) model asset contents loaded in `model_asset_buffer`.
+
+  If more than one field of these fields is provided, they are used in this
+  precedence order.
+
+  Attributes:
+    model_asset_path: Path to the model asset file.
+    model_asset_buffer: The model asset file contents as bytes.
+    delegate: Acceleration to use. Supported values are GPU and CPU. GPU support
+      is currently limited to Ubuntu platforms.
+  """
+
+  class Delegate(enum.IntEnum):
+    CPU = 0
+    GPU = 1
+
+  model_asset_path: Optional[str] = None
+  model_asset_buffer: Optional[bytes] = None
+  delegate: Optional[Delegate] = None
+
+  @doc_controls.do_not_generate_docs
+  def to_pb2(self) -> _BaseOptionsProto:
+    """Generates a BaseOptions protobuf object."""
+    if self.model_asset_path is not None:
+      full_path = os.path.abspath(self.model_asset_path)
+    else:
+      full_path = None
+
+    platform_name = platform.system()
+
+    if self.delegate == BaseOptions.Delegate.GPU:
+      if platform_name in ['Linux', 'Darwin']:
+        acceleration_proto = _AccelerationProto(gpu=_DelegateProto.Gpu())
+      else:
+        raise NotImplementedError(
+            'GPU Delegate is not yet supported for ' + platform_name
+        )
+    elif self.delegate == BaseOptions.Delegate.CPU:
+      acceleration_proto = _AccelerationProto(tflite=_DelegateProto.TfLite())
+    else:
+      acceleration_proto = None
+
+    return _BaseOptionsProto(
+        model_asset=_ExternalFileProto(
+            file_name=full_path, file_content=self.model_asset_buffer
+        ),
+        acceleration=acceleration_proto,
+    )
+
+  @classmethod
+  @doc_controls.do_not_generate_docs
+  def create_from_pb2(cls, pb2_obj: _BaseOptionsProto) -> 'BaseOptions':
+    """Creates a `BaseOptions` object from the given protobuf object."""
+    delegate = None
+    if pb2_obj.acceleration is not None:
+      delegate = (
+          BaseOptions.Delegate.GPU
+          if pb2_obj.acceleration.gpu is not None
+          else BaseOptions.Delegate.CPU
+      )
+
+    return BaseOptions(
+        model_asset_path=pb2_obj.model_asset.file_name,
+        model_asset_buffer=pb2_obj.model_asset.file_content,
+        delegate=delegate,
+    )
+
+  def __eq__(self, other: Any) -> bool:
+    """Checks if this object is equal to the given object.
+
+    Args:
+      other: The object to be compared with.
+
+    Returns:
+      True if the objects are equal.
+    """
+    if not isinstance(other, BaseOptions):
+      return False
+
+    return self.to_pb2().__eq__(other.to_pb2())

mediapipe/tasks/python/core/optional_dependencies.py

@@ -0,0 +1,25 @@
+# Copyright 2022 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MediaPipe Tasks' common but optional dependencies."""
+
+# TensorFlow isn't a dependency of mediapipe pip package. It's only
+# required in the API docgen pipeline so we'll ignore it if tensorflow is not
+# installed.
+try:
+  from tensorflow.tools.docs import doc_controls
+except ModuleNotFoundError:
+  # Replace the real doc_controls.do_not_generate_docs with an no-op
+  doc_controls = lambda: None
+  no_op = lambda x: x
+  setattr(doc_controls, 'do_not_generate_docs', no_op)

mediapipe/tasks/python/core/task_info.py

@@ -0,0 +1,139 @@
+# Copyright 2022 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MediaPipe Tasks' task info data class."""
+
+import dataclasses
+from typing import Any, List
+from google.protobuf import any_pb2
+from mediapipe.calculators.core import flow_limiter_calculator_pb2
+from mediapipe.framework import calculator_options_pb2
+from mediapipe.framework import calculator_pb2
+from mediapipe.tasks.python.core.optional_dependencies import doc_controls
+
+
+@doc_controls.do_not_generate_docs
+@dataclasses.dataclass
+class TaskInfo:
+  """Specifications of a MediaPipe task graph.
+
+  Attributes:
+    task_graph: The MediaPipe task graph name.
+    input_streams: The list of graph input stream info strings in the form
+      TAG:name.
+    output_streams: The list of graph output stream info strings in the form
+      TAG:name.
+    task_options: The task-specific options object that can be converted to a
+      protobuf object.
+  """
+  task_graph: str
+  input_streams: List[str]
+  output_streams: List[str]
+  task_options: Any
+
+  def generate_graph_config(
+      self,
+      enable_flow_limiting: bool = False
+  ) -> calculator_pb2.CalculatorGraphConfig:
+    """Generates a MediaPipe Task CalculatorGraphConfig proto from TaskInfo.
+
+    Args:
+      enable_flow_limiting: Whether to add a flow limiter calculator into the
+        graph config to lower the overall graph latency for live streaming use
+        case.
+
+    Raises:
+      ValueError: Any required data fields (namely, `task_graph`,
+        `task_options`, `input_streams`, and  `output_streams`) is not
+        specified or `task_options` is not able to be converted to a protobuf
+        object.
+
+    Returns:
+      A CalculatorGraphConfig proto of the task graph.
+    """
+
+    def strip_tag_index(tag_index_name):
+      return tag_index_name.split(':')[-1]
+
+    def add_stream_name_prefix(tag_index_name):
+      splitted = tag_index_name.split(':')
+      splitted[-1] = 'throttled_' + splitted[-1]
+      return ':'.join(splitted)
+
+    if not self.task_graph or not self.task_options:
+      raise ValueError('Please provide both `task_graph` and `task_options`.')
+    if not self.input_streams or not self.output_streams:
+      raise ValueError(
+          'Both `input_streams` and `output_streams` must be non-empty.')
+    if not hasattr(self.task_options, 'to_pb2'):
+      raise ValueError(
+          '`task_options` doesn`t provide `to_pb2()` method to convert itself to be a protobuf object.'
+      )
+
+    task_options_proto = self.task_options.to_pb2()
+
+    node_config = calculator_pb2.CalculatorGraphConfig.Node(
+        calculator=self.task_graph,
+        input_stream=self.input_streams,
+        output_stream=self.output_streams,
+    )
+
+    if hasattr(task_options_proto, 'ext'):
+      # Use the extension mechanism for task_subgraph_options (proto2)
+      task_subgraph_options = calculator_options_pb2.CalculatorOptions()
+      task_subgraph_options.Extensions[task_options_proto.ext].CopyFrom(
+          task_options_proto
+      )
+      node_config.options.CopyFrom(task_subgraph_options)
+    else:
+      # Use the Any type for task_subgraph_options (proto3)
+      task_subgraph_options = any_pb2.Any()
+      task_subgraph_options.Pack(self.task_options.to_pb2())
+      node_config.node_options.append(task_subgraph_options)
+
+    if not enable_flow_limiting:
+      return calculator_pb2.CalculatorGraphConfig(
+          node=[node_config],
+          input_stream=self.input_streams,
+          output_stream=self.output_streams,
+      )
+    # When a FlowLimiterCalculator is inserted to lower the overall graph
+    # latency, the task doesn't guarantee that each input must have the
+    # corresponding output.
+    task_subgraph_inputs = [
+        add_stream_name_prefix(stream) for stream in self.input_streams
+    ]
+    finished_stream = 'FINISHED:' + strip_tag_index(self.output_streams[0])
+    flow_limiter_options = calculator_options_pb2.CalculatorOptions()
+    flow_limiter_options.Extensions[
+        flow_limiter_calculator_pb2.FlowLimiterCalculatorOptions.ext].CopyFrom(
+            flow_limiter_calculator_pb2.FlowLimiterCalculatorOptions(
+                max_in_flight=1, max_in_queue=1))
+    flow_limiter = calculator_pb2.CalculatorGraphConfig.Node(
+        calculator='FlowLimiterCalculator',
+        input_stream_info=[
+            calculator_pb2.InputStreamInfo(
+                tag_index='FINISHED', back_edge=True)
+        ],
+        input_stream=[strip_tag_index(stream) for stream in self.input_streams]
+        + [finished_stream],
+        output_stream=[
+            strip_tag_index(stream) for stream in task_subgraph_inputs
+        ],
+        options=flow_limiter_options)
+    config = calculator_pb2.CalculatorGraphConfig(
+        node=[node_config, flow_limiter],
+        input_stream=self.input_streams,
+        output_stream=self.output_streams,
+    )
+    return config

mediapipe/tasks/python/genai/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2024 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MediaPipe GenAI Python API."""

mediapipe/tasks/python/genai/bundler/__init__.py

@@ -0,0 +1,23 @@
+# Copyright 2024 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""MediaPipe Tasks GenAI Bundler API."""
+
+import mediapipe.tasks.python.genai.bundler.llm_bundler
+
+BundleConfig = llm_bundler.BundleConfig
+create_bundle = llm_bundler.create_bundle
+
+# Remove unnecessary modules to avoid duplication in API docs.
+del llm_bundler

mediapipe/tasks/python/genai/bundler/llm_bundler.py

@@ -0,0 +1,130 @@
+# Copyright 2024 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Functions to perform llm packing."""
+
+import dataclasses
+import enum
+from typing import List, Optional
+
+from mediapipe.tasks.python.metadata.metadata_writers import model_asset_bundle_utils
+from mediapipe.tasks.cc.genai.inference.proto import llm_params_pb2
+import sentencepiece
+
+
+@dataclasses.dataclass(frozen=True)
+class BundleConfig:
+  """Config for LLM Bundler.
+
+  Attributes:
+    tflite_model: Path to the multi-signature tflite model with "prefill" and
+      "decode" signatures converted using ODML Transformers APIs.
+    tokenizer_model: Path to the tokenizer model. Currently only SentencePience
+      tokenizer is supported. As such, tokenizer.model proto is expected to be
+      passed here.
+    start_token: Token that will be used to signify the beginning of a sequence.
+    stop_tokens: Tokens that will be used to signify the end of a sequence.
+    output_filename: Name of the generated `.task` file containing the Bundle.
+    enable_bytes_to_unicode_mapping: Enables GPT-2 style bytes to unicode
+      mapping. For more details see:
+      https://github.com/openai/gpt-2/blob/master/src/encoder.py#L9
+    system_prompt: The starting text would be feed to the model on the start of
+      each session, commonly called the System prompt. This is useful for
+      instruction tuned models and pre-conditioning the model behavior.
+    prompt_prefix: The prefix that will be added to each prompt passed to the
+      model.
+    prompt_suffix: The suffix that will be added to at the end of user prompt
+      just before generating the response.
+  """
+
+  tflite_model: str
+  tokenizer_model: str
+  start_token: str
+  stop_tokens: List[str]
+  output_filename: str
+  enable_bytes_to_unicode_mapping: bool = False
+  system_prompt: Optional[str] = None
+  prompt_prefix: Optional[str] = None
+  prompt_suffix: Optional[str] = None
+
+
+class _BundleTags(enum.Enum):
+  """Bundle tags."""
+
+  TF_LITE_PREFILL_DECODE = 1
+  TOKENIZER_MODEL = 2
+  METADATA = 3
+
+
+def _validate_config(config: BundleConfig):
+  """Validates the given config.
+
+  Args:
+    config: The config to validate.
+
+  Raises:
+    ValueError if the config is invalid. Invalid configs can be:
+    - tokenizer_model is not a valid SentencePiece model.
+    - start_token is not a valid token in the tokenizer_model.
+    - stop_tokens is not a list of valid tokens in the tokenizer_model.
+  """
+  if not isinstance(config.stop_tokens, list):
+    raise ValueError("stop_tokens must be a list of strings.")
+  if not config.stop_tokens:
+    raise ValueError("stop_tokens must be non-empty.")
+
+  try:
+    sp = sentencepiece.SentencePieceProcessor()
+    sp.Load(config.tokenizer_model)
+  except Exception as e:
+    raise ValueError(
+        f"Failed to load tokenizer model from {config.tokenizer_model}. "
+        "Please ensure you are passing a valid SentencePiece model."
+    ) from e
+
+
+def create_bundle(config: BundleConfig):
+  """Creates a bundle from the given config."""
+  _validate_config(config)
+
+  artifacts = {}
+  with open(config.tflite_model, "rb") as f:
+    artifacts[_BundleTags.TF_LITE_PREFILL_DECODE.name] = f.read()
+
+  with open(config.tokenizer_model, "rb") as f:
+    artifacts[_BundleTags.TOKENIZER_MODEL.name] = f.read()
+
+  params = llm_params_pb2.LlmParameters()
+  params.start_token = config.start_token
+  params.stop_tokens.extend(config.stop_tokens)
+  if config.enable_bytes_to_unicode_mapping:
+    params.input_output_normalizations.append(
+        llm_params_pb2.LlmParameters.INPUT_OUTPUT_NORMALIZATION_BYTES_TO_UNICODE
+    )
+  if config.system_prompt:
+    params.prompt_template.session_prefix = config.system_prompt
+  if config.prompt_prefix:
+    params.prompt_template.prompt_prefix = config.prompt_prefix
+  if config.prompt_suffix:
+    params.prompt_template.prompt_suffix = config.prompt_suffix
+  artifacts[_BundleTags.METADATA.name] = params.SerializeToString()
+
+  output_filename = config.output_filename
+  if not output_filename.endswith(".task"):
+    output_filename = config.output_filename + ".task"
+
+  model_asset_bundle_utils.create_model_asset_bundle(
+      artifacts,
+      output_filename,
+  )

mediapipe/tasks/python/genai/bundler/llm_bundler_test.py

@@ -0,0 +1,168 @@
+# Copyright 2024 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import string
+import zipfile
+
+from absl.testing import absltest
+
+from mediapipe.tasks.python.genai.bundler import llm_bundler
+from sentencepiece import sentencepiece_model_pb2
+
+
+class LlmBundlerTest(absltest.TestCase):
+
+  BOS = "[BOS]"
+  EOS = "[EOS]"
+
+  def _create_sp_model(self, out_dir: str, corrupt: bool = False) -> str:
+    """Helper function to create test SentencePiece model."""
+    sp_file_path = os.path.join(out_dir, "sp.model")
+    if corrupt:
+      with open(sp_file_path, "w") as f:
+        f.write("sp_model")
+      return sp_file_path
+
+    model = sentencepiece_model_pb2.ModelProto()
+    # Add an unk token.
+    model.pieces.add(
+        piece="<unk>",
+        score=0.0,
+        type=sentencepiece_model_pb2.ModelProto.SentencePiece.UNKNOWN,
+    )
+    # BOS and EOS are special control tokens.
+    model.pieces.add(
+        piece=self.BOS,
+        score=0.0,
+        type=sentencepiece_model_pb2.ModelProto.SentencePiece.CONTROL,
+    )
+    model.pieces.add(
+        piece=self.EOS,
+        score=0.0,
+        type=sentencepiece_model_pb2.ModelProto.SentencePiece.CONTROL,
+    )
+    # Add a few user defined tokens.
+    model.pieces.add(
+        piece="[INST]",
+        score=0.0,
+        type=sentencepiece_model_pb2.ModelProto.SentencePiece.USER_DEFINED,
+    )
+    model.pieces.add(
+        piece="[/INST]",
+        score=0.0,
+        type=sentencepiece_model_pb2.ModelProto.SentencePiece.USER_DEFINED,
+    )
+    model.pieces.add(
+        piece="[SYS_S]",
+        score=0.0,
+        type=sentencepiece_model_pb2.ModelProto.SentencePiece.USER_DEFINED,
+    )
+    model.pieces.add(
+        piece="[SYS_E]",
+        score=0.0,
+        type=sentencepiece_model_pb2.ModelProto.SentencePiece.USER_DEFINED,
+    )
+    # Add the rest of the alphabet as tokens
+    for letter in string.ascii_lowercase + string.ascii_uppercase:
+      model.pieces.add(
+          piece=letter,
+          score=0.0,
+          type=sentencepiece_model_pb2.ModelProto.SentencePiece.NORMAL,
+      )
+
+    model.normalizer_spec.add_dummy_prefix = False
+
+    with open(sp_file_path, "wb") as f:
+      f.write(model.SerializeToString())
+    return sp_file_path
+
+  def _create_tflite_model(self, out_dir: str) -> str:
+    """Helper function to create test tflite model."""
+    tflite_file_path = os.path.join(out_dir, "test.tflite")
+    with open(tflite_file_path, "w") as f:
+      f.write("tflite_model")
+    return tflite_file_path
+
+  def test_can_create_bundle(self):
+    tempdir = self.create_tempdir()
+    sp_file_path = self._create_sp_model(tempdir.full_path)
+    tflite_file_path = self._create_tflite_model(tempdir.full_path)
+    output_file = os.path.join(tempdir, "test.task")
+    config = llm_bundler.BundleConfig(
+        tflite_model=tflite_file_path,
+        tokenizer_model=sp_file_path,
+        start_token=self.BOS,
+        stop_tokens=[self.EOS],
+        output_filename=output_file,
+        enable_bytes_to_unicode_mapping=True,
+        prompt_prefix="<start_of_turn>user\n ",
+        prompt_suffix="<end_of_turn>\n<start_of_turn>model\n",
+    )
+    llm_bundler.create_bundle(config)
+    self.assertTrue(os.path.exists(output_file))
+    with zipfile.ZipFile(output_file) as zip_file:
+      self.assertLen(zip_file.filelist, 3)
+      self.assertEqual(zip_file.filelist[0].filename, "TF_LITE_PREFILL_DECODE")
+      self.assertEqual(zip_file.filelist[1].filename, "TOKENIZER_MODEL")
+      self.assertEqual(zip_file.filelist[2].filename, "METADATA")
+
+  def test_invalid_stop_tokens_raises_value_error(self):
+    tempdir = self.create_tempdir()
+    sp_file_path = self._create_sp_model(tempdir.full_path)
+    tflite_file_path = self._create_tflite_model(tempdir.full_path)
+    output_file = os.path.join(tempdir, "test.task")
+    config = llm_bundler.BundleConfig(
+        tflite_model=tflite_file_path,
+        tokenizer_model=sp_file_path,
+        start_token=self.BOS,
+        stop_tokens=self.EOS,
+        output_filename=output_file,
+    )
+    with self.assertRaisesRegex(
+        ValueError, "stop_tokens must be a list of strings"
+    ):
+      llm_bundler.create_bundle(config)
+
+    config = llm_bundler.BundleConfig(
+        tflite_model=tflite_file_path,
+        tokenizer_model=sp_file_path,
+        start_token=self.BOS,
+        stop_tokens=[],
+        output_filename=output_file,
+    )
+    with self.assertRaisesRegex(ValueError, "stop_tokens must be non-empty"):
+      llm_bundler.create_bundle(config)
+
+  def test_invalid_tokenizer_model_raises_value_error(self):
+    tempdir = self.create_tempdir()
+    sp_file_path = self._create_sp_model(tempdir.full_path, corrupt=True)
+    tflite_file_path = self._create_tflite_model(tempdir.full_path)
+    output_file = os.path.join(tempdir, "test.task")
+    config = llm_bundler.BundleConfig(
+        tflite_model=tflite_file_path,
+        tokenizer_model=sp_file_path,
+        start_token=self.BOS,
+        stop_tokens=[self.EOS],
+        output_filename=output_file,
+    )
+    with self.assertRaisesRegex(
+        ValueError,
+        "Failed to load tokenizer model from",
+    ):
+      llm_bundler.create_bundle(config)
+
+
+if __name__ == "__main__":
+  absltest.main()

mediapipe/tasks/python/genai/converter/__init__.py

@@ -0,0 +1,24 @@
+# Copyright 2022 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""MediaPipe Tasks GenAI Converter API."""
+
+import mediapipe.tasks.python.genai.converter.llm_converter
+
+ConversionConfig = llm_converter.ConversionConfig
+convert_checkpoint = llm_converter.convert_checkpoint
+
+# Remove unnecessary modules to avoid duplication in API docs.
+del mediapipe
+del llm_converter