diff --git a/nemoguardrails/evaluate/cli/evaluate.py b/nemoguardrails/evaluate/cli/evaluate.py
index 55bc12046..d4ae126e3 100644
--- a/nemoguardrails/evaluate/cli/evaluate.py
+++ b/nemoguardrails/evaluate/cli/evaluate.py
@@ -133,6 +133,13 @@ def moderation(
     ),
     write_outputs: bool = typer.Option(True, help="Write outputs to file"),
     split: str = typer.Option("harmful", help="Whether prompts are harmful or helpful"),
+    enable_translation: bool = typer.Option(
+        False, help="Enable translation functionality"
+    ),
+    translation_config: str = typer.Option(
+        "nemoguardrails/evaluate/langproviders/configs/translation.yaml",
+        help="Path to translation configuration file",
+    ),
 ):
     """
     Evaluate the performance of the moderation rails defined in a Guardrails application.
@@ -150,6 +157,8 @@ def moderation(
             Defaults to "eval_outputs/moderation".
         write_outputs (bool): Write outputs to file. Defaults to True.
         split (str): Whether prompts are harmful or helpful. Defaults to "harmful".
+        enable_translation (bool): Enable translation functionality. Defaults to False.
+        translation_config (str): Path to translation configuration file. Defaults to None.
     """
     moderation_check = ModerationRailsEvaluation(
         config,
@@ -160,6 +169,8 @@ def moderation(
         output_dir,
         write_outputs,
         split,
+        enable_translation,
+        translation_config,
     )
     typer.echo(f"Starting the moderation evaluation for data: {dataset_path} ...")
     moderation_check.run()
@@ -178,6 +189,13 @@ def hallucination(
         "eval_outputs/hallucination", help="Output directory"
     ),
     write_outputs: bool = typer.Option(True, help="Write outputs to file"),
+    enable_translation: bool = typer.Option(
+        False, help="Enable translation functionality"
+    ),
+    translation_config: str = typer.Option(
+        "nemoguardrails/evaluate/langproviders/configs/translation.yaml",
+        help="Path to translation configuration file",
+    ),
 ):
     """
     Evaluate the performance of the hallucination rails defined in a Guardrails application.
@@ -190,6 +208,8 @@ def hallucination(
         num_samples (int): Number of samples to evaluate. Defaults to 50.
         output_dir (str): Output directory. Defaults to "eval_outputs/hallucination".
         write_outputs (bool): Write outputs to file. Defaults to True.
+        enable_translation (bool): Enable translation functionality. Defaults to False.
+        translation_config (str): Path to translation configuration file. Defaults to None.
     """
     hallucination_check = HallucinationRailsEvaluation(
         config,
@@ -197,6 +217,8 @@ def hallucination(
         num_samples,
         output_dir,
         write_outputs,
+        enable_translation,
+        translation_config,
     )
     typer.echo(f"Starting the hallucination evaluation for data: {dataset_path} ...")
     hallucination_check.run()
diff --git a/nemoguardrails/evaluate/evaluate_hallucination.py b/nemoguardrails/evaluate/evaluate_hallucination.py
index 886e37c25..4a11085bc 100644
--- a/nemoguardrails/evaluate/evaluate_hallucination.py
+++ b/nemoguardrails/evaluate/evaluate_hallucination.py
@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 import json
 import logging
 import os
@@ -22,7 +23,9 @@
 import typer
 
 from nemoguardrails import LLMRails
+from nemoguardrails.actions.llm.utils import llm_call
 from nemoguardrails.evaluate.utils import load_dataset
+from nemoguardrails.evaluate.utils_translate import normalize_text
 from nemoguardrails.llm.params import llm_params
 from nemoguardrails.llm.prompts import Task
 from nemoguardrails.llm.taskmanager import LLMTaskManager
@@ -40,6 +43,8 @@ def __init__(
         num_samples: int = 50,
         output_dir: str = "outputs/hallucination",
         write_outputs: bool = True,
+        enable_translation: bool = False,
+        translation_config: str = None,
     ):
         """
         A hallucination rails evaluation has the following parameters:
@@ -50,6 +55,8 @@ def __init__(
         - num_samples: number of samples to evaluate
         - output_dir: directory to write the hallucination predictions
         - write_outputs: whether to write the predictions to file
+        - enable_translation: whether to enable translation functionality
+        - translation_config: path to translation configuration file
         """
 
         self.config_path = config
@@ -60,18 +67,40 @@ def __init__(
         self.llm_task_manager = LLMTaskManager(self.rails_config)
 
         self.num_samples = num_samples
-        self.dataset = load_dataset(self.dataset_path)[: self.num_samples]
+        self.enable_translation = enable_translation
+        self.translation_config = translation_config
+
+        # Initialize translation provider if enabled
+        self.translator = None
+        if self.enable_translation:
+            try:
+                from nemoguardrails.evaluate.utils import _load_langprovider
+
+                self.translator = _load_langprovider(self.translation_config)
+            except Exception as e:
+                print(f"⚠ Translation provider not available: {e}")
+
+            # Load dataset with optional translation
+            self.dataset = load_dataset(
+                self.dataset_path, translation_config=self.translation_config
+            )[: self.num_samples]
+            logging.warning(f"Loaded {len(self.dataset)} samples with translation")
+        else:
+            self.dataset = load_dataset(self.dataset_path)[: self.num_samples]
+
         self.write_outputs = write_outputs
         self.output_dir = output_dir
 
         if not os.path.exists(self.output_dir):
             os.makedirs(self.output_dir)
 
+        self.english_translator = None
+
     def get_response_with_retries(self, prompt, max_tries=1):
         num_tries = 0
         while num_tries < max_tries:
             try:
-                response = self.llm(prompt)
+                response = asyncio.run(llm_call(prompt=prompt, llm=self.llm))
                 return response
             except:
                 num_tries += 1
@@ -153,8 +182,26 @@ def self_check_hallucination(self):
                     Task.SELF_CHECK_HALLUCINATION,
                     {"paragraph": paragraph, "statement": bot_response},
                 )
-                hallucination = self.llm(hallucination_check_prompt)
+                hallucination = asyncio.run(
+                    llm_call(prompt=hallucination_check_prompt, llm=self.llm)
+                )
                 hallucination = hallucination.lower().strip()
+                if self.enable_translation:
+                    from nemoguardrails.evaluate.utils_translate import (
+                        detect_language,
+                        setup_english_translator,
+                        translate_to_english,
+                    )
+
+                    lang = detect_language(hallucination)
+                    if self.english_translator is None:
+                        self.english_translator = setup_english_translator(
+                            self.translator, lang
+                        )
+                    hallucination = translate_to_english(
+                        self.english_translator, hallucination, lang
+                    )
+                    hallucination = normalize_text(hallucination)
 
                 prediction = {
                     "question": question,
@@ -194,7 +241,9 @@ def run(self):
                 f"{self.output_dir}/{dataset_name}_hallucination_predictions.json"
             )
             with open(output_path, "w") as f:
-                json.dump(hallucination_check_predictions, f, indent=4)
+                json.dump(
+                    hallucination_check_predictions, f, indent=4, ensure_ascii=False
+                )
             print(f"Predictions written to file {output_path}.json")
 
 
@@ -204,6 +253,12 @@ def main(
     num_samples: int = typer.Option(50, help="Number of samples to evaluate"),
     output_dir: str = typer.Option("outputs/hallucination", help="Output directory"),
     write_outputs: bool = typer.Option(True, help="Write outputs to file"),
+    enable_translation: bool = typer.Option(
+        False, help="Enable translation functionality"
+    ),
+    translation_config: str = typer.Option(
+        None, help="Path to translation configuration file"
+    ),
 ):
     """
     Main function to run the hallucination rails evaluation.
@@ -214,6 +269,8 @@ def main(
         num_samples (int): Number of samples to evaluate.
         output_dir (str): Output directory for predictions.
         write_outputs (bool): Whether to write the predictions to a file.
+        enable_translation (bool): Whether to enable translation functionality.
+        translation_config (str): Path to translation configuration file.
     """
     hallucination_check = HallucinationRailsEvaluation(
         config,
@@ -221,6 +278,8 @@ def main(
         num_samples,
         output_dir,
         write_outputs,
+        enable_translation,
+        translation_config,
     )
     hallucination_check.run()
 
diff --git a/nemoguardrails/evaluate/evaluate_moderation.py b/nemoguardrails/evaluate/evaluate_moderation.py
index 477c5e352..e48c7e3ba 100644
--- a/nemoguardrails/evaluate/evaluate_moderation.py
+++ b/nemoguardrails/evaluate/evaluate_moderation.py
@@ -15,6 +15,7 @@
 
 import asyncio
 import json
+import logging
 import os
 
 import tqdm
@@ -42,6 +43,8 @@ def __init__(
         output_dir: str = "outputs/moderation",
         write_outputs: bool = True,
         split: str = "harmful",
+        enable_translation: bool = False,
+        translation_config: str = None,
     ):
         """
         A moderation rails evaluation has the following parameters:
@@ -54,6 +57,8 @@ def __init__(
         - output_dir: directory to write the moderation predictions
         - write_outputs: whether to write the predictions to file
         - split: whether the dataset is harmful or helpful
+        - enable_translation: whether to enable translation functionality
+        - translation_config: path to translation configuration file
         """
 
         self.config_path = config
@@ -67,7 +72,29 @@ def __init__(
         self.check_output = check_output
 
         self.num_samples = num_samples
-        self.dataset = load_dataset(self.dataset_path)[: self.num_samples]
+        self.enable_translation = enable_translation
+        self.translation_config = translation_config
+
+        # Initialize translation provider if enabled
+        self.translator = None
+        if self.enable_translation:
+            try:
+                from nemoguardrails.evaluate.utils_translate import _load_langprovider
+
+                self.translator = _load_langprovider(self.translation_config)
+                print(f"✓ Translation provider initialized")
+            except Exception as e:
+                print(f"⚠ Translation provider not available: {e}")
+
+            # Load dataset with optional translation
+            if self.translator:
+                self.dataset = load_dataset(
+                    self.dataset_path, translation_config=self.translation_config
+                )[: self.num_samples]
+                logging.warning(f"Loaded {len(self.dataset)} samples with translation")
+        else:
+            self.dataset = load_dataset(self.dataset_path)[: self.num_samples]
+
         self.split = split
         self.write_outputs = write_outputs
         self.output_dir = output_dir
@@ -266,6 +293,6 @@ def run(self):
             )
 
             with open(output_path, "w") as f:
-                json.dump(moderation_check_predictions, f, indent=4)
+                json.dump(moderation_check_predictions, f, indent=4, ensure_ascii=False)
 
             print(f"Predictions written to file {output_path}")
diff --git a/nemoguardrails/evaluate/langproviders/README.md b/nemoguardrails/evaluate/langproviders/README.md
new file mode 100644
index 000000000..c67090aae
--- /dev/null
+++ b/nemoguardrails/evaluate/langproviders/README.md
@@ -0,0 +1,421 @@
+# Language Providers
+
+This directory contains translation providers used in the evaluation features of NeMo-Guardrails. These providers support dataset translation and multilingual evaluation.
+
+## Overview
+
+Language Providers offer an abstraction layer to handle different translation services (local or remote) in a unified way. All providers inherit from the `TranslationProvider` base class and provide a consistent interface.
+
+## Directory Structure
+
+```
+langproviders/
+├── base.py              # Base class TranslationProvider
+├── local.py             # Local translation providers
+├── remote.py            # Remote translation providers
+├── configs/             # Configuration files
+│   └── translation.yaml # Example translation config
+└── README.md            # This file
+```
+
+## Available Translation Providers
+
+### Local Providers
+
+#### LocalHFTranslator
+A local translation provider using Hugging Face models.
+
+**Supported Models:**
+- **M2M100**: Multilingual Many-to-Many translation models (supports 100 languages)
+  - https://huggingface.co/facebook/m2m100_1.2B
+  - https://huggingface.co/facebook/m2m100_418M
+- **MarianMT**: Helsinki-NLP/opus-mt-* models
+  - https://huggingface.co/docs/transformers/model_doc/marian
+
+**Example Configuration:**
+```yaml
+langproviders:
+  - language: en,ja
+    model_type: local.LocalHFTranslator
+    model_name: "Helsinki-NLP/opus-mt-{}"
+```
+
+**Features:**
+- No internet connection required
+- Privacy-friendly
+- Customizable model selection
+- Supports GPU/CPU
+
+### Remote Providers
+
+#### DeeplTranslator
+High-quality translation service using the DeepL API. Requires DeepL API key for using it.
+- https://www.deepl.com/en/translator
+
+**Example Configuration:**
+```yaml
+langproviders:
+  - language: en,ja
+    model_type: remote.DeeplTranslator
+```
+
+**Environment Variable:**
+```bash
+export DEEPL_API_KEY="your-api-key-here"
+```
+
+**Features:**
+- High-quality translations
+- Commercial use available
+
+#### RivaTranslator
+Translation service using NVIDIA Riva. Requires an API key for using it.
+- https://developer.nvidia.com/riva
+
+**Example Configuration:**
+
+**For Remote Riva Server:**
+```yaml
+langproviders:
+  - language: en,ja
+    model_type: remote.RivaTranslator
+    local_mode: false
+```
+
+**For Local Riva Server:**
+```yaml
+langproviders:
+  - language: en,ja
+    model_type: remote.RivaTranslator
+    local_mode: true
+    uri: "localhost:50051"
+```
+
+**Environment Variable:**
+```bash
+export RIVA_API_KEY="your-api-key-here"
+```
+
+**Features:**
+- Optimized for NVIDIA GPUs
+- Supports both local and cloud deployment
+- Low latency
+- Configurable endpoints via YAML
+
+## Usage
+
+### 1. Create a Configuration File
+
+Create a translation configuration file (e.g., `translation_config.yaml`):
+
+```yaml
+langproviders:
+  - language: en,ja
+    model_type: remote.DeeplTranslator
+```
+
+### 2. Use in Your Program
+
+```python
+from nemoguardrails.evaluate.utils_translate import _load_langprovider
+
+# Load the translation provider
+translator = _load_langprovider("translation_config.yaml")
+
+# Translate text
+translated_text = translator._translate("Hello, world!")
+print(translated_text)  # "こんにちは、世界！"
+```
+
+### 3. Translate a Dataset
+
+```python
+from nemoguardrails.evaluate.utils_translate import load_dataset
+
+# Load and translate a dataset
+translated_dataset = load_dataset(
+    "dataset.json",
+    translation_config="translation_config.yaml"
+)
+```
+
+### Translation with NeMo Guardrails Evaluation
+
+NeMo Guardrails supports multilingual evaluation through translation providers. This allows you to evaluate your guardrails configuration on datasets in different languages.
+
+#### Supported Evaluation Types
+
+**1. Moderation Evaluation**
+Evaluates input and output moderation rails on translated datasets.
+
+```bash
+nemoguardrails eval rail moderation \
+  --config examples/configs/llm/my_config \
+  --dataset-path nemoguardrails/evaluate/data/moderation/harmful.txt \
+  --translation-config translation_config.yaml \
+  --enable-translation \
+  --num-samples 50
+```
+
+**2. Hallucination Evaluation**
+Evaluates hallucination detection rails on translated datasets.
+
+```bash
+nemoguardrails eval rail hallucination \
+  --config examples/configs/llm/my_config \
+  --dataset-path nemoguardrails/evaluate/data/hallucination/sample.txt \
+  --translation-config translation_config.yaml \
+  --enable-translation \
+  --num-samples 50
+```
+
+**3. Fact-Checking Evaluation**
+Evaluates fact-checking rails on translated datasets.
+
+```bash
+nemoguardrails eval rail fact-checking \
+  --config examples/configs/llm/my_config \
+  --dataset-path nemoguardrails/evaluate/data/factchecking/sample.json \
+  --translation-config translation_config.yaml \
+  --enable-translation \
+  --num-samples 50
+```
+
+#### Translation Configuration Examples
+
+**For Japanese Translation (DeepL):**
+```yaml
+# translation_config.yaml
+langproviders:
+  - language: en,ja
+    model_type: remote.DeeplTranslator
+```
+
+**For Japanese Translation (Local HF):**
+```yaml
+# translation_config.yaml
+langproviders:
+  - language: en,ja
+    model_type: local.LocalHFTranslator
+    model_name: facebook/m2m100_1.2B
+```
+
+**For Chinese Translation:**
+```yaml
+# translation_config.yaml
+langproviders:
+  - language: en,zh
+    model_type: remote.DeeplTranslator
+```
+
+#### Translation Cache
+
+The evaluation system automatically caches translations to avoid repeated API calls and improve performance. Cache files are stored in the `translation_cache/` directory.
+
+**Cache Benefits:**
+- Faster subsequent evaluations
+- Reduced API costs
+- Consistent translations across runs
+
+**Cache Management:**
+```bash
+# Clear translation cache (if needed)
+rm -rf translation_cache/
+```
+
+#### Dataset Format Support
+
+The translation system supports both text and JSON datasets:
+
+**Text Files (.txt):**
+```
+Question 1
+Question 2
+Question 3
+```
+
+**JSON Files (.json):**
+```json
+[
+  {
+    "question": "What is the capital of France?",
+    "evidence": "Paris is the capital of France.",
+    "answer": "Paris"
+  }
+]
+```
+
+#### Evaluation Output
+
+Translated evaluations produce the same output format as regular evaluations, but with translated content:
+
+```json
+{
+  "question": "ディングウェルの畳み込み効果は、どのような環境で最もよく観察されますか？",
+  "hallucination_agreement": "no",
+  "bot_response": "ディングウェルの畳み込み効果は、高圧環境で最もよく観察されます。",
+  "extra_responses": [
+    "ディングウェルの畳み込み効果は、低圧環境で観察されます。",
+    "この効果は、常温環境で最もよく見られます。"
+  ]
+}
+```
+
+#### Best Practices
+
+1. **Use Local Providers for Privacy**: When working with sensitive data, use `LocalHFTranslator` instead of remote services.
+
+2. **Cache Management**: Keep translation caches for repeated evaluations, but clear them when switching between different translation providers.
+
+3. **Language Pair Validation**: Ensure your translation provider supports the desired language pair before running evaluations.
+
+4. **API Key Management**: For remote providers, set environment variables securely:
+   ```bash
+   export DEEPL_API_KEY="your-deepl-api-key"
+   export RIVA_API_KEY="your-riva-api-key"
+   ```
+
+5. **Sample Size**: Start with small sample sizes (`--num-samples 5-10`) to test your setup before running full evaluations.
+
+#### Troubleshooting Translation Issues
+
+**Common Issues:**
+
+1. **Translation Provider Not Available**
+   ```
+   ⚠ Translation provider not available: PluginConfigurationError: No configuration file provided
+   ```
+   **Solution:** Check that your translation config file exists and has correct syntax.
+
+2. **API Key Issues**
+   ```
+   Exception: Put the API key in the DEEPL_API_KEY environment variable
+   ```
+   **Solution:** Set the required environment variable for your chosen provider.
+
+3. **Unsupported Language Pair**
+   ```
+   Exception: Language pair en,xx is not supported
+   ```
+   **Solution:** Check the supported languages section and use a supported language pair.
+
+4. **Network Issues (Remote Providers)**
+   ```
+   ConnectionError: Failed to connect to translation service
+   ```
+   **Solution:** Check your internet connection and API service status.
+
+## Configuration Parameters
+
+### Common Parameters
+
+The following parameters pass by the yaml file.
+
+- **`language`**: Language pair for translation (e.g., `"en,ja"`)
+- **`model_type`**: Provider type (e.g., `"remote.DeeplTranslator"`)
+
+### LocalHFTranslator-specific Parameters
+
+- `model_name`: Model name (default: `"Helsinki-NLP/opus-mt-{}"`)
+
+#### Language Code Overrides (`lang_overrides`)
+
+Some language codes used in translation models differ from standard ISO codes. `LocalHFTranslator` uses an internal dictionary called `lang_overrides` to automatically convert certain language codes to the format expected by the model. For example, the code for Japanese is sometimes expected as `jap` instead of `ja` in some MarianMT models.
+
+- Example: If you specify `ja` (Japanese) as the target language, `LocalHFTranslator` will internally convert it to `jap` when constructing the model name for MarianMT.
+- This conversion is handled automatically; you do not need to change your configuration.
+- The current overrides are:
+  - `ja` → `jap`
+
+This mechanism ensures compatibility with Hugging Face model naming conventions and prevents errors when loading models for certain languages.
+
+### RivaTranslator-specific Parameters
+
+- `local_mode`: Flag to use a local server (default: `false`)
+
+## Supported Languages
+
+### LocalHFTranslator (M2M100)
+Supports 100 languages (see the [official documentation](https://huggingface.co/facebook/m2m100_418M#languages-covered) for details)
+
+### DeeplTranslator
+Supports languages (see the [official documentation](https://developers.deepl.com/docs/getting-started/supported-languages) for details) :
+
+### RivaTranslator
+Supports 77 languages (see the [official documentation](https://docs.nvidia.com/deeplearning/riva/user-guide/docs/translation/translation-overview.html#language-pairs-supported) for details) :
+
+## Error Handling
+
+### Common Errors
+
+1. **Configuration file not found**
+   ```
+   PluginConfigurationError: No configuration file provided
+   ```
+
+2. **API key not set**
+   ```
+   Exception: Put the API key in the DEEPL_API_KEY environment variable
+   ```
+
+3. **Unsupported language pair**
+   ```
+   Exception: Language pair en,xx is not supported
+   ```
+
+### Troubleshooting
+
+1. **Check environment variables**
+   ```bash
+   echo $DEEPL_API_KEY  # For DeepL
+   echo $RIVA_API_KEY   # For Riva
+   ```
+
+2. **Check configuration file syntax**
+   ```bash
+   python -c "import yaml; yaml.safe_load(open('translation_config.yaml'))"
+   ```
+
+3. **Check network connection** (for remote providers)
+
+## Environment Variable (ENV_VAR) Usage
+
+Some translation providers (such as RivaTranslator and DeeplTranslator) require an API key for authentication. Each provider expects the API key to be set in a specific environment variable. This environment variable is referenced in the provider implementation as `ENV_VAR`.
+
+- For **DeepL**, set the API key in `DEEPL_API_KEY`:
+  ```bash
+  export DEEPL_API_KEY="your-api-key-here"
+  ```
+- For **Riva**, set the API key in `RIVA_API_KEY`:
+  ```bash
+  export RIVA_API_KEY="your-api-key-here"
+  ```
+
+The provider will automatically load the API key from the corresponding environment variable at runtime. If the environment variable is not set or is empty, an error will be raised.
+
+This mechanism allows you to securely manage API keys for different translation services without hardcoding them in configuration files.
+
+## For Developers
+
+### Adding a New Provider
+
+1. Inherit from the `TranslationProvider` base class
+2. Implement the required methods:
+   - `_load_langprovider()`: Provider initialization
+   - `_translate(text: str) -> str`: Translation logic
+
+3. Add your provider to the appropriate file (`local.py` or `remote.py`)
+
+### Testing
+
+```bash
+# Run tests for translation providers
+python -m pytest tests/eval/translate/ -v
+```
+
+## Related Links
+
+- [NeMo-Guardrails Documentation](https://docs.nvidia.com/nemo/guardrails/latest/index.html)
+- [DeepL API Documentation](https://developers.deepl.com/)
+- [NVIDIA Riva Documentation](https://developer.nvidia.com/riva)
+- [Hugging Face Transformers](https://huggingface.co/docs/transformers/)
diff --git a/nemoguardrails/evaluate/langproviders/base.py b/nemoguardrails/evaluate/langproviders/base.py
new file mode 100644
index 000000000..d025f7d84
--- /dev/null
+++ b/nemoguardrails/evaluate/langproviders/base.py
@@ -0,0 +1,122 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+import logging
+import os
+import re
+import string
+import unicodedata
+from typing import List
+
+
+class TranslationProvider:
+    """Base class for objects that provision language translation services."""
+
+    def __init__(self, config: dict = None) -> None:
+        """
+        Initialize the translation provider with optional configuration.
+
+        Args:
+            config (dict, optional): Configuration dictionary containing translation provider settings.
+                Expected to have a 'langproviders' key with provider-specific configuration.
+
+        Attributes:
+            ENV_VAR (str): Name of the environment variable that should contain the API key for the translation provider.
+                If the subclass defines this attribute, the API key will be loaded from the specified environment variable.
+
+        Raises:
+            Exception: If config, langproviders_config, or language is missing or invalid.
+        """
+        self.language = ""
+        self.local_mode = False
+        self.config = config  # Store config for subclasses to access
+        if not config:
+            raise Exception(
+                "config must be provided for TranslationProvider initialization."
+            )
+        # Extract configuration from the config
+        langproviders_config = config.get("langproviders", {})
+        if not langproviders_config:
+            raise Exception("'langproviders' configuration is missing in config.")
+        # Get the first (and typically only) language provider config
+        found_config = False
+        for _, each_config in langproviders_config.items():
+            self.language = each_config.get("language", "")
+            model_type = each_config.get("model_type", "")
+            local_mode = each_config.get("local_mode", False)
+            if model_type == "remote.RivaTranslator":
+                self.local_mode = local_mode
+            found_config = True
+            break
+        if not found_config:
+            raise Exception(
+                "No valid language provider configuration found in 'langproviders'."
+            )
+        if not self.language:
+            raise Exception(
+                "'language' must be specified in the language provider configuration."
+            )
+        self.source_lang, self.target_lang = self.language.split(",")
+        if self.source_lang == self.target_lang:
+            raise Exception(
+                f"Source and target languages cannot be the same: {self.source_lang}"
+            )
+        # Validate environment variable and set API key before loading the provider
+        if hasattr(self, "ENV_VAR"):
+            self.key_env_var = self.ENV_VAR
+            self._validate_env_var()
+        self._load_langprovider()
+
+    def _load_langprovider(self):
+        raise NotImplementedError
+
+    def _translate(self, text: str) -> str:
+        raise NotImplementedError
+
+    def _get_response(self, input_text: str):
+        return self._translate(input_text)
+
+    def _translate_with_cache(self, text: str) -> str:
+        """Translate text with caching support."""
+        from nemoguardrails.evaluate.utils import get_translation_cache
+
+        cache = get_translation_cache()
+        target_lang = getattr(self, "target_lang", "unknown")
+
+        # Check cache first
+        cached_translation = cache.get(text, target_lang)
+        if cached_translation:
+            return cached_translation
+
+        # Translate and cache
+        translated_text = self._translate(text)
+        cache.set(text, target_lang, translated_text)
+
+        return translated_text
+
+    def _validate_env_var(self):
+        if hasattr(self, "key_env_var"):
+            if not hasattr(self, "api_key") or self.api_key is None:
+                self.api_key = os.getenv(self.key_env_var, default=None)
+            # Empty strings are also considered as not set
+            if self.api_key is None or self.api_key == "":
+                raise Exception(
+                    f'🛑 Put the API key in the {self.key_env_var} environment variable (this was empty)\n \
+                    e.g.: export {self.key_env_var}="XXXXXXX"'
+                )
diff --git a/nemoguardrails/evaluate/langproviders/configs/riva_local.yaml b/nemoguardrails/evaluate/langproviders/configs/riva_local.yaml
new file mode 100644
index 000000000..771d8d084
--- /dev/null
+++ b/nemoguardrails/evaluate/langproviders/configs/riva_local.yaml
@@ -0,0 +1,5 @@
+langproviders:
+  - language: en,ja
+    model_type: remote.RivaTranslator
+    local_mode: true
+    uri: "localhost:50051"
diff --git a/nemoguardrails/evaluate/langproviders/configs/riva_remote.yaml b/nemoguardrails/evaluate/langproviders/configs/riva_remote.yaml
new file mode 100644
index 000000000..402ffe4db
--- /dev/null
+++ b/nemoguardrails/evaluate/langproviders/configs/riva_remote.yaml
@@ -0,0 +1,7 @@
+langproviders:
+  - language: en,ja
+    model_type: remote.RivaTranslator
+    local_mode: false
+    uri: "grpc.nvcf.nvidia.com:443"
+    use_ssl: true
+    function_id: "647147c1-9c23-496c-8304-2e29e7574510"
diff --git a/nemoguardrails/evaluate/langproviders/configs/translation.yaml b/nemoguardrails/evaluate/langproviders/configs/translation.yaml
new file mode 100644
index 000000000..7a8d378a5
--- /dev/null
+++ b/nemoguardrails/evaluate/langproviders/configs/translation.yaml
@@ -0,0 +1,3 @@
+langproviders:
+  - language: en,ja
+    model_type: remote.DeeplTranslator
diff --git a/nemoguardrails/evaluate/langproviders/local.py b/nemoguardrails/evaluate/langproviders/local.py
new file mode 100644
index 000000000..c21c021e2
--- /dev/null
+++ b/nemoguardrails/evaluate/langproviders/local.py
@@ -0,0 +1,164 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+"""Local language providers & translators."""
+
+
+from typing import List
+
+import torch
+
+from nemoguardrails.evaluate.langproviders.base import TranslationProvider
+
+
+class LocalHFTranslator(TranslationProvider):
+    """Local translation using Huggingface transformer models: Many-2-Many m2m100 or MarianMT Helsinki-NLP/opus-mt-* models
+
+    Reference:
+      - https://huggingface.co/facebook/m2m100_1.2B
+      - https://huggingface.co/facebook/m2m100_418M
+      - https://huggingface.co/docs/transformers/model_doc/marian
+    """
+
+    DEFAULT_PARAMS = {
+        "model_name": "Helsinki-NLP/opus-mt-{}",
+    }
+    lang_overrides = {
+        "ja": "jap",
+    }
+
+    def __init__(self, config: dict = {}) -> None:
+        self._load_config(config=config)
+
+        import torch.multiprocessing as mp
+
+        # set_start_method for consistency, translation does not utilize multiprocessing
+        mp.set_start_method("spawn", force=True)
+
+        self.device = self._select_hf_device()
+        super().__init__(config=config)
+
+    def _load_config(self, config: dict = {}):
+        """Load configuration from config."""
+        if config:
+            # Extract configuration from the config
+            langproviders_config = config.get("langproviders", {})
+            # Get the first (and typically only) language provider config
+            for _, each_config in langproviders_config.items():
+                self.model_name = each_config.get(
+                    "model_name", self.DEFAULT_PARAMS["model_name"]
+                )
+                break
+        else:
+            self.model_name = self.DEFAULT_PARAMS["model_name"]
+
+    def _select_hf_device(self):
+        """Select the appropriate device for HuggingFace models."""
+        try:
+            if torch.cuda.is_available():
+                return "cuda"
+            else:
+                return "cpu"
+        except Exception as e:
+            return "cpu"
+
+    def _load_langprovider(self):
+        if "m2m100" in self.model_name:
+            from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
+
+            # fmt: off
+            # Reference: https://huggingface.co/facebook/m2m100_418M#languages-covered
+            lang_support = {
+                "af", "am", "ar", "ast", "az",
+                "ba", "be", "bg", "bn", "br",
+                "bs", "ca", "ceb", "cs", "cy",
+                "da", "de", "el", "en", "es",
+                "et", "fa", "ff", "fi", "fr",
+                "fy", "ga", "gd", "gl", "gu",
+                "ha", "he", "hi", "hr", "ht",
+                "hu", "hy", "id", "ig", "ilo",
+                "is", "it", "ja", "jv", "ka",
+                "kk", "km", "kn", "ko", "lb",
+                "lg", "ln", "lo", "lt", "lv",
+                "mg", "mk", "ml", "mn", "mr",
+                "ms", "my", "ne", "nl", "no",
+                "ns", "oc", "or", "pa", "pl",
+                "ps", "pt", "ro", "ru", "sd",
+                "si", "sk", "sl", "so", "sq",
+                "sr", "ss", "su", "sv", "sw",
+                "ta", "th", "tl", "tn", "tr",
+                "uk", "ur", "uz", "vi", "wo",
+                "xh", "yi", "yo", "zh", "zu",
+            }
+            # fmt: on
+            if not (
+                self.source_lang in lang_support and self.target_lang in lang_support
+            ):
+                raise Exception(
+                    f"Language pair {self.language} is not supported for this translation service."
+                )
+
+            self.model = M2M100ForConditionalGeneration.from_pretrained(
+                self.model_name
+            ).to(self.device)
+            self.tokenizer = M2M100Tokenizer.from_pretrained(self.model_name)
+        else:
+            from transformers import MarianMTModel, MarianTokenizer
+
+            # if model is not m2m100 expect the model name to be "Helsinki-NLP/opus-mt-{}" where the format string
+            # is replace with the language path defined in the configuration as self.source_lang-self.target_lang
+            # validation of all supported pairs is deferred in favor of allowing the download to raise exception
+            # when no published model exists with the pair requested in the name.
+            self.target_lang = self.lang_overrides.get(
+                self.target_lang, self.target_lang
+            )
+            model_suffix = f"{self.source_lang}-{self.target_lang}"
+            model_name = self.model_name.format(model_suffix)
+            # Save the processed model_name
+            self.model_name = model_name
+            self.model = MarianMTModel.from_pretrained(model_name).to(self.device)
+            self.tokenizer = MarianTokenizer.from_pretrained(model_name)
+
+    def _translate(self, text: str) -> str:
+        if "m2m100" in self.model_name:
+            self.tokenizer.src_lang = self.source_lang
+
+            encoded_text = self.tokenizer(text, return_tensors="pt").to(self.device)
+
+            translated = self.model.generate(
+                **encoded_text,
+                forced_bos_token_id=self.tokenizer.get_lang_id(self.target_lang),
+            )
+
+            translated_text = self.tokenizer.batch_decode(
+                translated, skip_special_tokens=True
+            )[0]
+
+            return translated_text
+        else:
+            # this assumes MarianMTModel type
+            source_text = self.tokenizer([text], return_tensors="pt").to(self.device)
+
+            translated = self.model.generate(**source_text)
+
+            translated_text = self.tokenizer.batch_decode(
+                translated, skip_special_tokens=True
+            )[0]
+
+            return translated_text
diff --git a/nemoguardrails/evaluate/langproviders/remote.py b/nemoguardrails/evaluate/langproviders/remote.py
new file mode 100644
index 000000000..05d4d8f83
--- /dev/null
+++ b/nemoguardrails/evaluate/langproviders/remote.py
@@ -0,0 +1,203 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+"""Translator that translates a prompt."""
+
+
+import logging
+
+from nemoguardrails.evaluate.langproviders.base import TranslationProvider
+
+VALIDATION_STRING = "A"  # just send a single ASCII character for a sanity check
+
+
+class RivaTranslator(TranslationProvider):
+    """Remote translation using NVIDIA Riva translation API
+
+    https://developer.nvidia.com/riva
+    """
+
+    ENV_VAR = "RIVA_API_KEY"
+    DEFAULT_PARAMS = {
+        "uri": "grpc.nvcf.nvidia.com:443",
+        "function_id": "647147c1-9c23-496c-8304-2e29e7574510",
+        "use_ssl": True,
+    }
+
+    # fmt: off
+    # Reference: https://docs.nvidia.com/nim/riva/nmt/latest/support-matrix.html#supported-languages
+    lang_support = [
+        "zh", "ru", "de", "es", "fr",
+        "da", "el", "fi", "hu", "it",
+        "lt", "lv", "nl", "no", "pl",
+        "pt", "ro", "sk", "sv", "ja",
+        "hi", "ko", "et", "sl", "bg",
+        "uk", "hr", "ar", "vi", "tr",
+        "id", "cs", "en"
+    ]
+    # fmt: on
+    # Applied when a service only supports regions specific codes
+    lang_overrides = {
+        "es": "es-US",
+        "zh": "zh-TW",
+        "pr": "pt-PT",
+    }
+
+    # avoid attempt to pickle the client attribute
+    def __getstate__(self) -> object:
+        self._clear_langprovider()
+        return dict(self.__dict__)
+
+    # restore the client attribute
+    def __setstate__(self, d) -> object:
+        self.__dict__.update(d)
+        self._load_langprovider()
+
+    def _clear_langprovider(self):
+        self.client = None
+
+    def _set_local_server(self):
+        # Only override uri from YAML if available, keep other params as default
+        self.uri = "0.0.0.0:50051"
+        if hasattr(self, "config") and self.config:
+            langproviders_config = self.config.get("langproviders", {})
+            for _, each_config in langproviders_config.items():
+                if each_config.get("model_type") == "remote.RivaTranslator":
+                    self.uri = each_config.get("uri", self.uri)
+                    break
+        self.use_ssl = False
+        # function_id remains default
+
+    def _load_langprovider(self):
+        if not (
+            self.source_lang in self.lang_support
+            and self.target_lang in self.lang_support
+        ):
+            raise Exception(
+                f"Language pair {self.language} is not supported for {self.__class__.__name__} services at {self.uri}."
+            )
+        self._source_lang = self.lang_overrides.get(self.source_lang, self.source_lang)
+        self._target_lang = self.lang_overrides.get(self.target_lang, self.target_lang)
+
+        # Read parameters from configuration
+        self.uri = self.DEFAULT_PARAMS["uri"]
+        self.use_ssl = self.DEFAULT_PARAMS["use_ssl"]
+        self.function_id = self.DEFAULT_PARAMS["function_id"]
+
+        try:
+            import riva.client
+        except ImportError as e:
+            raise ImportError(
+                "The 'riva.client' module was not found. Please install 'riva.client' to use Riva translation. See: https://developer.nvidia.com/riva"
+            ) from e
+
+        if self.local_mode:
+            self._set_local_server()
+
+        auth = riva.client.Auth(
+            None,
+            self.use_ssl,
+            self.uri,
+            [
+                ("function-id", self.function_id),
+                ("authorization", "Bearer " + self.api_key),
+            ],
+        )
+        self.client = riva.client.NeuralMachineTranslationClient(auth)
+        if not hasattr(self, "_tested"):
+            self.client.translate(
+                [VALIDATION_STRING], "", self._source_lang, self._target_lang
+            )  # exception handling is intentionally not implemented to raise on invalid config for remote services.
+            self._tested = True
+
+    # TODO: consider adding a backoff here and determining if a connection needs to be re-established
+    def _translate(self, text: str) -> str:
+        try:
+            if self.client is None:
+                self._load_langprovider()
+            response = self.client.translate(
+                [text], "", self._source_lang, self._target_lang
+            )
+            return response.translations[0].text
+        except Exception as e:
+            logging.error(f"Translation error: {str(e)}")
+            return text
+
+
+class DeeplTranslator(TranslationProvider):
+    """Remote translation using DeepL translation API
+
+    https://www.deepl.com/en/translator
+    """
+
+    ENV_VAR = "DEEPL_API_KEY"
+    DEFAULT_PARAMS = {}
+
+    # fmt: off
+    # Reference: https://developers.deepl.com/docs/resources/supported-languages
+    lang_support = [
+        "ar", "bg", "cs", "da", "de",
+        "en", "el", "es", "et", "fi",
+        "fr", "hu", "id", "it", "ja",
+        "ko", "lt", "lv", "nb", "nl",
+        "pl", "pt", "ro", "ru", "sk",
+        "sl", "sv", "tr", "uk", "zh",
+        "en"
+    ]
+    # fmt: on
+    # Applied when a service only supports regions specific codes
+    lang_overrides = {
+        "en": "en-US",
+    }
+
+    def _load_langprovider(self):
+        try:
+            from deepl import Translator
+        except ImportError as e:
+            raise ImportError(
+                "The 'deepl' module was not found. Please install 'deepl' to use DeepL translation. See: https://www.deepl.com/en/translator"
+            ) from e
+
+        if not (
+            self.source_lang in self.lang_support
+            and self.target_lang in self.lang_support
+        ):
+            raise Exception(
+                f"Language pair {self.language} is not supported for {self.__class__.__name__} services."
+            )
+        self._source_lang = self.source_lang
+        self._target_lang = self.lang_overrides.get(self.target_lang, self.target_lang)
+
+        self.client = Translator(self.api_key)
+        if not hasattr(self, "_tested"):
+            self.client.translate_text(
+                VALIDATION_STRING,
+                source_lang=self._source_lang,
+                target_lang=self._target_lang,
+            )  # exception handling is intentionally not implemented to raise on invalid config for remote services.
+            self._tested = True
+
+    def _translate(self, text: str) -> str:
+        try:
+            return self.client.translate_text(
+                text, source_lang=self._source_lang, target_lang=self._target_lang
+            ).text
+        except Exception as e:
+            logging.error(f"Translation error: {str(e)}")
+            return text
diff --git a/nemoguardrails/evaluate/utils.py b/nemoguardrails/evaluate/utils.py
index 7228cdd46..0a60c5f5d 100644
--- a/nemoguardrails/evaluate/utils.py
+++ b/nemoguardrails/evaluate/utils.py
@@ -14,7 +14,16 @@
 # limitations under the License.
 
 import json
+import os
 
+from tqdm import tqdm
+
+from nemoguardrails.evaluate.utils_translate import (
+    _extract_target_language,
+    _load_langprovider,
+    get_translation_cache,
+    get_translation_cache_name,
+)
 from nemoguardrails.llm.models.initializer import init_llm_model
 from nemoguardrails.rails.llm.config import Model
 
@@ -29,8 +38,8 @@ def initialize_llm(model_config: Model):
     )
 
 
-def load_dataset(dataset_path: str):
-    """Loads a dataset from a file."""
+def load_dataset(dataset_path: str, translation_config: str = None):
+    """Loads a dataset from a file with optional translation."""
 
     with open(dataset_path, "r") as f:
         if dataset_path.endswith(".json"):
@@ -38,4 +47,56 @@ def load_dataset(dataset_path: str):
         else:
             dataset = f.readlines()
 
+    # If translation is needed
+    if translation_config:
+        translator = _load_langprovider(translation_config)
+        translate_to = _extract_target_language(translation_config)
+        service_name = get_translation_cache_name(translator)
+        service_name = service_name + "_" + os.path.basename(dataset_path).split(".")[0]
+        cache = get_translation_cache(service_name)
+        translated_dataset = []
+
+        print(f"🔄 Starting translation to {translate_to}...")
+        print(f"📊 Total items to process: {len(dataset)}")
+
+        # Display progress bar with tqdm
+        for item in tqdm(dataset, desc="Translating", unit="item"):
+            if isinstance(item, dict):
+                # For JSON format, translate specific fields
+                translated_item = item.copy()
+                for field in ["answer", "question", "evidence"]:
+                    if field in translated_item:
+                        original_text = translated_item[field]
+                        # Check cache first
+                        cached_translation = cache.get(original_text, translate_to)
+                        if cached_translation:
+                            translated_item[field] = cached_translation
+                        else:
+                            # Translate and cache
+                            translated_text = translator._translate(original_text)
+                            translated_item[field] = translated_text
+                            cache.set(original_text, translate_to, translated_text)
+                translated_dataset.append(translated_item)
+            else:
+                # For text format
+                original_text = item.strip()
+                # Check cache first
+                cached_translation = cache.get(original_text, translate_to)
+                if cached_translation:
+                    translated_dataset.append(cached_translation)
+                else:
+                    # Translate and cache
+                    translated_text = translator._translate(original_text)
+                    translated_dataset.append(translated_text)
+                    cache.set(original_text, translate_to, translated_text)
+
+        # Print cache statistics
+        stats = cache.get_cache_stats()
+        print(f"✅ Translation completed!")
+        print(
+            f"📈 Translation cache stats: {stats['total_entries']} entries, {stats['cache_size_mb']:.2f} MB"
+        )
+
+        return translated_dataset
+
     return dataset
diff --git a/nemoguardrails/evaluate/utils_translate.py b/nemoguardrails/evaluate/utils_translate.py
new file mode 100644
index 000000000..c2279cf6f
--- /dev/null
+++ b/nemoguardrails/evaluate/utils_translate.py
@@ -0,0 +1,375 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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 hashlib
+import importlib
+import json
+import logging
+import os
+from pathlib import Path
+
+import yaml
+from tqdm import tqdm
+
+from nemoguardrails.evaluate.langproviders.base import TranslationProvider
+
+
+class TranslationCache:
+    """Cache for translation results to avoid repeated API calls."""
+
+    def __init__(
+        self, cache_dir: str = "translation_cache", service_name: str = "default"
+    ):
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(exist_ok=True)
+        # Generate cache file name based on service name
+        self.safe_service_name = (
+            service_name.replace("/", "_").replace("\\", "_").replace(":", "_")
+        )
+        self.cache_file = self.cache_dir / f"translations_{self.safe_service_name}.json"
+        logging.debug(f"cache_file: {self.cache_file}")
+        self.cache = self._load_cache()
+
+    def _load_cache(self):
+        """Load existing cache from file."""
+        if self.cache_file.exists():
+            try:
+                with open(self.cache_file, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, IOError) as e:
+                logging.warning(f"Failed to load translation cache: {e}")
+                return {}
+        return {}
+
+    def _save_cache(self):
+        """Save cache to file."""
+        try:
+            with open(self.cache_file, "w", encoding="utf-8") as f:
+                json.dump(self.cache, f, ensure_ascii=False, indent=2)
+        except IOError as e:
+            logging.error(f"Failed to save translation cache: {e}")
+
+    def _get_cache_key(self, text: str, target_lang: str) -> str:
+        """Generate cache key from text and target language."""
+        # Create a hash of the text and target language
+        content = f"{text}:{target_lang}"
+        return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+    def get(self, text: str, target_lang: str) -> str:
+        """Get translated text from cache if available."""
+        cache_key = self._get_cache_key(text, target_lang)
+        cache_value = self.cache.get(cache_key)
+        if cache_value is None:
+            return None
+        return cache_value["translation"]
+
+    def set(self, text: str, target_lang: str, translated_text: str):
+        """Store translated text in cache."""
+        cache_key = self._get_cache_key(text, target_lang)
+        self.cache[cache_key] = {
+            "original": text,
+            "translation": translated_text,
+            "target_lang": target_lang,
+        }
+        self._save_cache()
+
+    def get_cache_stats(self):
+        """Get statistics about the cache."""
+        cache_size_bytes = (
+            os.path.getsize(self.cache_file) if self.cache_file.exists() else 0
+        )
+        cache_size_mb = cache_size_bytes / (1024 * 1024)
+
+        return {
+            "total_entries": len(self.cache),
+            "cache_size_bytes": cache_size_bytes,
+            "cache_size_mb": cache_size_mb,
+            "cache_file": str(self.cache_file),
+        }
+
+
+# Global dictionary to store translation cache instances
+_translation_caches = {}
+
+
+def get_translation_cache(service_name: str = "default") -> TranslationCache:
+    """Get or create translation cache instance for the specified service."""
+    if service_name not in _translation_caches:
+        _translation_caches[service_name] = TranslationCache(service_name=service_name)
+    return _translation_caches[service_name]
+
+
+def get_translation_cache_name(translator: TranslationProvider) -> str:
+    # Get translation service information to create cache instance
+    service_name = translator.__class__.__name__
+
+    # For local services, include model name as well
+    if hasattr(translator, "model_name"):
+        # Generate safe filename from model name
+        safe_model_name = (
+            translator.model_name.replace("/", "_").replace("\\", "_").replace(":", "_")
+        )
+        service_name = f"{service_name}_{safe_model_name}"
+    return service_name
+
+
+def _translate_with_cache(
+    text: str, translator: TranslationProvider, cache: TranslationCache
+) -> str:
+    """Translate text with caching support."""
+    # Check cache first
+    cached_translation = cache.get(text, translator.target_lang)
+    if cached_translation:
+        return cached_translation
+
+    # Translate and cache
+    translated_text = translator._translate(text)
+    cache.set(text, translator.target_lang, translated_text)
+    return translated_text
+
+
+def detect_language(text: str) -> str:
+    """
+    Detect the language of the given text.
+
+    Args:
+        text (str): The text to detect language for.
+
+    Returns:
+        str: The detected language code (e.g., 'en', 'ja', 'es', etc.)
+    """
+    try:
+        from langdetect import detect
+
+        detect_language = detect(text)
+        return detect_language
+    except Exception as e:
+        logging.warning(f"Language detection failed: {e}")
+        return "en"  # Default to English if detection fails
+
+
+def setup_english_translator(translator, detect_language: str):
+    # Initialize English translator for fact checking if auto_translate_to_english is enabled
+    try:
+        # Create a translator specifically for English translation
+        # This will be used to translate non-English text to English for fact checking
+        import tempfile
+
+        import yaml
+
+        # Create config for English translation based on the original translator
+        english_config = {
+            "langproviders": [
+                {
+                    "model_type": translator.__class__.__module__.split(".")[-1]
+                    + "."
+                    + translator.__class__.__name__,
+                    "language": detect_language
+                    + ",en",  # auto-detect source language, translate to English
+                    "local_mode": getattr(translator, "local_mode", False),
+                }
+            ]
+        }
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".yml", delete=False) as f:
+            print("english_config:", english_config)
+            yaml.dump(english_config, f)
+            temp_config_path = f.name
+
+        try:
+            english_translator = _load_langprovider(temp_config_path)
+            print(f"✓ English translation provider initialized for fact checking")
+            return english_translator
+        finally:
+            os.unlink(temp_config_path)
+
+    except Exception as e:
+        print(f"⚠ English translation provider not available: {e}")
+
+
+def translate_to_english(
+    english_translator: TranslationProvider, text: str, source_lang: str
+) -> str:
+    """
+    Translate text to English if it's not already in English.
+
+    Args:
+        text (str): The text to translate.
+        source_lang (str): The source language code.
+
+    Returns:
+        str: The translated text (or original if already English).
+    """
+    if source_lang == "en":
+        return text
+
+    # Skip translation for simple yes/no responses
+    for check_text in ["yes", "no"]:
+        if check_text in text.lower().strip():
+            return text
+
+    if not english_translator:
+        logging.warning("No English translator available, using original text")
+        return text
+
+    try:
+        # Use the dedicated English translator
+        translated_text = english_translator._translate(text)
+        return translated_text
+
+    except Exception as e:
+        logging.warning(f"Translation to English failed: {e}")
+        return text
+
+
+def normalize_text(text: str) -> str:
+    """
+    Normalize hallucination_agreement values into 'yes' or 'no'.
+    """
+    import re
+
+    text = text.strip().lower()
+    text = re.sub(r"[。.,!?]", "", text)
+    return text
+
+
+def load_dataset(dataset_path: str, translation_config: str = None):
+    """Loads a dataset from a file with optional translation."""
+
+    with open(dataset_path, "r") as f:
+        if dataset_path.endswith(".json"):
+            dataset = json.load(f)
+        else:
+            dataset = f.readlines()
+
+    # If translation is needed
+    if translation_config:
+        translator = _load_langprovider(translation_config)
+        service_name = get_translation_cache_name(translator)
+        service_name = service_name + "_" + os.path.basename(dataset_path).split(".")[0]
+        cache = get_translation_cache(service_name)
+
+        translated_dataset = []
+
+        print(f"🔄 Starting translation...")
+        print(f"📊 Total items to process: {len(dataset)}")
+        print(f"🔧 Using translation service: {service_name}")
+
+        # Display progress bar with tqdm
+        for item in tqdm(dataset, desc="Translating", unit="item"):
+            if isinstance(item, dict):
+                # For JSON format, translate specific fields
+                translated_item = item.copy()
+                for field in ["answer", "question", "evidence"]:
+                    if field in translated_item:
+                        original_text = translated_item[field]
+                        translated_item[field] = _translate_with_cache(
+                            original_text, translator, cache
+                        )
+                translated_dataset.append(translated_item)
+            else:
+                # For text format
+                original_text = item.strip()
+                translated_text = _translate_with_cache(
+                    original_text, translator, cache
+                )
+                translated_dataset.append(translated_text)
+
+        # Print cache statistics
+        stats = cache.get_cache_stats()
+        print(f"✅ Translation completed!")
+        print(
+            f"📈 Translation cache stats: {stats['total_entries']} entries, {stats['cache_size_mb']:.2f} MB"
+        )
+        print(f"💾 Cache file: {stats['cache_file']}")
+
+        return translated_dataset
+
+    return dataset
+
+
+class PluginConfigurationError(Exception):
+    """Exception raised when a plugin configuration is invalid."""
+
+    pass
+
+
+def _load_plugin(path: str, config_root: dict):
+    """Load a plugin class from the given path."""
+    try:
+        # Split the path to get module and class name
+        module_path, class_name = path.rsplit(".", 1)
+
+        # Import the module
+        module = importlib.import_module(module_path)
+
+        # Get the class from the module
+        plugin_class = getattr(module, class_name)
+
+        # Create an instance with the config
+        instance = plugin_class(config_root)
+        return instance
+
+    except (ImportError, AttributeError, ValueError) as e:
+        raise PluginConfigurationError(
+            f"Failed to load plugin '{path}': {str(e)}"
+        ) from e
+
+
+def _extract_target_language(config_yaml: str) -> str:
+    """Extract target language from translation configuration file."""
+    with open(config_yaml, "r") as f:
+        config = yaml.safe_load(f)
+    language_service = config["langproviders"][0]
+    source_lang, target_lang = language_service["language"].split(",")
+    return target_lang
+
+
+def _load_langprovider(config_yaml: str = None) -> TranslationProvider:
+    """Load a single language provider based on the configuration provided."""
+    langprovider_instance = None
+
+    # If no config file is provided, raise an error
+    if config_yaml is None:
+        raise PluginConfigurationError(
+            "No configuration file provided. Please specify a translation configuration file."
+        )
+
+    with open(config_yaml, "r") as f:
+        config = yaml.safe_load(f)
+    language_service = config["langproviders"][0]
+    langprovider_config = {
+        "langproviders": {language_service["model_type"]: language_service}
+    }
+    logging.debug(f"language provision service: {language_service['language']}")
+    source_lang, target_lang = language_service["language"].split(",")
+    model_type = language_service["model_type"]
+    try:
+        if "." in model_type:
+            # For formats like remote.RivaTranslator
+            module_name, class_name = model_type.split(".", 1)
+            module_path = f"nemoguardrails.evaluate.langproviders.{module_name}"
+
+        path = f"{module_path}.{class_name}"
+        langprovider_instance = _load_plugin(
+            path=path,
+            config_root=langprovider_config,
+        )
+        print(f"langprovider_instance: {langprovider_instance}")
+    except Exception as e:
+        raise PluginConfigurationError(
+            f"Failed to load '{language_service['language']}' langprovider of type '{model_type}': {str(e)}"
+        ) from e
+    return langprovider_instance
diff --git a/poetry.lock b/poetry.lock
index 8a61cc252..7bfbddee9 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand.
+# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand.
 
 [[package]]
 name = "accessible-pygments"
@@ -902,6 +902,23 @@ files = [
 marshmallow = ">=3.18.0,<4.0.0"
 typing-inspect = ">=0.4.0,<1"
 
+[[package]]
+name = "deepl"
+version = "1.22.0"
+description = "Python library for the DeepL API."
+optional = false
+python-versions = "<4,>=3.6.2"
+files = [
+    {file = "deepl-1.22.0-py3-none-any.whl", hash = "sha256:df1ed8f4cd4cc6bb9078f3aa0a0b045cd9e3b813a6d3bce4d33b51aa836fddf1"},
+    {file = "deepl-1.22.0.tar.gz", hash = "sha256:eb09568e5996dff6a2c318d40a22bd67d3fcf04f2ec2b1af985b8d4b6cf096b6"},
+]
+
+[package.dependencies]
+requests = ">=2,<3"
+
+[package.extras]
+keyring = ["keyring (>=23.4.1,<24.0.0)"]
+
 [[package]]
 name = "deprecated"
 version = "1.2.18"
@@ -1427,87 +1444,156 @@ test = ["objgraph", "psutil"]
 
 [[package]]
 name = "grpcio"
-version = "1.70.0"
+version = "1.67.1"
 description = "HTTP/2-based RPC framework"
-optional = true
+optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "grpcio-1.70.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:95469d1977429f45fe7df441f586521361e235982a0b39e33841549143ae2851"},
-    {file = "grpcio-1.70.0-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:ed9718f17fbdb472e33b869c77a16d0b55e166b100ec57b016dc7de9c8d236bf"},
-    {file = "grpcio-1.70.0-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:374d014f29f9dfdb40510b041792e0e2828a1389281eb590df066e1cc2b404e5"},
-    {file = "grpcio-1.70.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2af68a6f5c8f78d56c145161544ad0febbd7479524a59c16b3e25053f39c87f"},
-    {file = "grpcio-1.70.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce7df14b2dcd1102a2ec32f621cc9fab6695effef516efbc6b063ad749867295"},
-    {file = "grpcio-1.70.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:c78b339869f4dbf89881e0b6fbf376313e4f845a42840a7bdf42ee6caed4b11f"},
-    {file = "grpcio-1.70.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:58ad9ba575b39edef71f4798fdb5c7b6d02ad36d47949cd381d4392a5c9cbcd3"},
-    {file = "grpcio-1.70.0-cp310-cp310-win32.whl", hash = "sha256:2b0d02e4b25a5c1f9b6c7745d4fa06efc9fd6a611af0fb38d3ba956786b95199"},
-    {file = "grpcio-1.70.0-cp310-cp310-win_amd64.whl", hash = "sha256:0de706c0a5bb9d841e353f6343a9defc9fc35ec61d6eb6111802f3aa9fef29e1"},
-    {file = "grpcio-1.70.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:17325b0be0c068f35770f944124e8839ea3185d6d54862800fc28cc2ffad205a"},
-    {file = "grpcio-1.70.0-cp311-cp311-macosx_10_14_universal2.whl", hash = "sha256:dbe41ad140df911e796d4463168e33ef80a24f5d21ef4d1e310553fcd2c4a386"},
-    {file = "grpcio-1.70.0-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:5ea67c72101d687d44d9c56068328da39c9ccba634cabb336075fae2eab0d04b"},
-    {file = "grpcio-1.70.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cb5277db254ab7586769e490b7b22f4ddab3876c490da0a1a9d7c695ccf0bf77"},
-    {file = "grpcio-1.70.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7831a0fc1beeeb7759f737f5acd9fdcda520e955049512d68fda03d91186eea"},
-    {file = "grpcio-1.70.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:27cc75e22c5dba1fbaf5a66c778e36ca9b8ce850bf58a9db887754593080d839"},
-    {file = "grpcio-1.70.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d63764963412e22f0491d0d32833d71087288f4e24cbcddbae82476bfa1d81fd"},
-    {file = "grpcio-1.70.0-cp311-cp311-win32.whl", hash = "sha256:bb491125103c800ec209d84c9b51f1c60ea456038e4734688004f377cfacc113"},
-    {file = "grpcio-1.70.0-cp311-cp311-win_amd64.whl", hash = "sha256:d24035d49e026353eb042bf7b058fb831db3e06d52bee75c5f2f3ab453e71aca"},
-    {file = "grpcio-1.70.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:ef4c14508299b1406c32bdbb9fb7b47612ab979b04cf2b27686ea31882387cff"},
-    {file = "grpcio-1.70.0-cp312-cp312-macosx_10_14_universal2.whl", hash = "sha256:aa47688a65643afd8b166928a1da6247d3f46a2784d301e48ca1cc394d2ffb40"},
-    {file = "grpcio-1.70.0-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:880bfb43b1bb8905701b926274eafce5c70a105bc6b99e25f62e98ad59cb278e"},
-    {file = "grpcio-1.70.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9e654c4b17d07eab259d392e12b149c3a134ec52b11ecdc6a515b39aceeec898"},
-    {file = "grpcio-1.70.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2394e3381071045a706ee2eeb6e08962dd87e8999b90ac15c55f56fa5a8c9597"},
-    {file = "grpcio-1.70.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:b3c76701428d2df01964bc6479422f20e62fcbc0a37d82ebd58050b86926ef8c"},
-    {file = "grpcio-1.70.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ac073fe1c4cd856ebcf49e9ed6240f4f84d7a4e6ee95baa5d66ea05d3dd0df7f"},
-    {file = "grpcio-1.70.0-cp312-cp312-win32.whl", hash = "sha256:cd24d2d9d380fbbee7a5ac86afe9787813f285e684b0271599f95a51bce33528"},
-    {file = "grpcio-1.70.0-cp312-cp312-win_amd64.whl", hash = "sha256:0495c86a55a04a874c7627fd33e5beaee771917d92c0e6d9d797628ac40e7655"},
-    {file = "grpcio-1.70.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:aa573896aeb7d7ce10b1fa425ba263e8dddd83d71530d1322fd3a16f31257b4a"},
-    {file = "grpcio-1.70.0-cp313-cp313-macosx_10_14_universal2.whl", hash = "sha256:d405b005018fd516c9ac529f4b4122342f60ec1cee181788249372524e6db429"},
-    {file = "grpcio-1.70.0-cp313-cp313-manylinux_2_17_aarch64.whl", hash = "sha256:f32090238b720eb585248654db8e3afc87b48d26ac423c8dde8334a232ff53c9"},
-    {file = "grpcio-1.70.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfa089a734f24ee5f6880c83d043e4f46bf812fcea5181dcb3a572db1e79e01c"},
-    {file = "grpcio-1.70.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f19375f0300b96c0117aca118d400e76fede6db6e91f3c34b7b035822e06c35f"},
-    {file = "grpcio-1.70.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:7c73c42102e4a5ec76608d9b60227d917cea46dff4d11d372f64cbeb56d259d0"},
-    {file = "grpcio-1.70.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:0a5c78d5198a1f0aa60006cd6eb1c912b4a1520b6a3968e677dbcba215fabb40"},
-    {file = "grpcio-1.70.0-cp313-cp313-win32.whl", hash = "sha256:fe9dbd916df3b60e865258a8c72ac98f3ac9e2a9542dcb72b7a34d236242a5ce"},
-    {file = "grpcio-1.70.0-cp313-cp313-win_amd64.whl", hash = "sha256:4119fed8abb7ff6c32e3d2255301e59c316c22d31ab812b3fbcbaf3d0d87cc68"},
-    {file = "grpcio-1.70.0-cp38-cp38-linux_armv7l.whl", hash = "sha256:8058667a755f97407fca257c844018b80004ae8035565ebc2812cc550110718d"},
-    {file = "grpcio-1.70.0-cp38-cp38-macosx_10_14_universal2.whl", hash = "sha256:879a61bf52ff8ccacbedf534665bb5478ec8e86ad483e76fe4f729aaef867cab"},
-    {file = "grpcio-1.70.0-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:0ba0a173f4feacf90ee618fbc1a27956bfd21260cd31ced9bc707ef551ff7dc7"},
-    {file = "grpcio-1.70.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:558c386ecb0148f4f99b1a65160f9d4b790ed3163e8610d11db47838d452512d"},
-    {file = "grpcio-1.70.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:412faabcc787bbc826f51be261ae5fa996b21263de5368a55dc2cf824dc5090e"},
-    {file = "grpcio-1.70.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3b0f01f6ed9994d7a0b27eeddea43ceac1b7e6f3f9d86aeec0f0064b8cf50fdb"},
-    {file = "grpcio-1.70.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:7385b1cb064734005204bc8994eed7dcb801ed6c2eda283f613ad8c6c75cf873"},
-    {file = "grpcio-1.70.0-cp38-cp38-win32.whl", hash = "sha256:07269ff4940f6fb6710951116a04cd70284da86d0a4368fd5a3b552744511f5a"},
-    {file = "grpcio-1.70.0-cp38-cp38-win_amd64.whl", hash = "sha256:aba19419aef9b254e15011b230a180e26e0f6864c90406fdbc255f01d83bc83c"},
-    {file = "grpcio-1.70.0-cp39-cp39-linux_armv7l.whl", hash = "sha256:4f1937f47c77392ccd555728f564a49128b6a197a05a5cd527b796d36f3387d0"},
-    {file = "grpcio-1.70.0-cp39-cp39-macosx_10_14_universal2.whl", hash = "sha256:0cd430b9215a15c10b0e7d78f51e8a39d6cf2ea819fd635a7214fae600b1da27"},
-    {file = "grpcio-1.70.0-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:e27585831aa6b57b9250abaf147003e126cd3a6c6ca0c531a01996f31709bed1"},
-    {file = "grpcio-1.70.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c1af8e15b0f0fe0eac75195992a63df17579553b0c4af9f8362cc7cc99ccddf4"},
-    {file = "grpcio-1.70.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cbce24409beaee911c574a3d75d12ffb8c3e3dd1b813321b1d7a96bbcac46bf4"},
-    {file = "grpcio-1.70.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:ff4a8112a79464919bb21c18e956c54add43ec9a4850e3949da54f61c241a4a6"},
-    {file = "grpcio-1.70.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5413549fdf0b14046c545e19cfc4eb1e37e9e1ebba0ca390a8d4e9963cab44d2"},
-    {file = "grpcio-1.70.0-cp39-cp39-win32.whl", hash = "sha256:b745d2c41b27650095e81dea7091668c040457483c9bdb5d0d9de8f8eb25e59f"},
-    {file = "grpcio-1.70.0-cp39-cp39-win_amd64.whl", hash = "sha256:a31d7e3b529c94e930a117b2175b2efd179d96eb3c7a21ccb0289a8ab05b645c"},
-    {file = "grpcio-1.70.0.tar.gz", hash = "sha256:8d1584a68d5922330025881e63a6c1b54cc8117291d382e4fa69339b6d914c56"},
+    {file = "grpcio-1.67.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:8b0341d66a57f8a3119b77ab32207072be60c9bf79760fa609c5609f2deb1f3f"},
+    {file = "grpcio-1.67.1-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:f5a27dddefe0e2357d3e617b9079b4bfdc91341a91565111a21ed6ebbc51b22d"},
+    {file = "grpcio-1.67.1-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:43112046864317498a33bdc4797ae6a268c36345a910de9b9c17159d8346602f"},
+    {file = "grpcio-1.67.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c9b929f13677b10f63124c1a410994a401cdd85214ad83ab67cc077fc7e480f0"},
+    {file = "grpcio-1.67.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7d1797a8a3845437d327145959a2c0c47c05947c9eef5ff1a4c80e499dcc6fa"},
+    {file = "grpcio-1.67.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:0489063974d1452436139501bf6b180f63d4977223ee87488fe36858c5725292"},
+    {file = "grpcio-1.67.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:9fd042de4a82e3e7aca44008ee2fb5da01b3e5adb316348c21980f7f58adc311"},
+    {file = "grpcio-1.67.1-cp310-cp310-win32.whl", hash = "sha256:638354e698fd0c6c76b04540a850bf1db27b4d2515a19fcd5cf645c48d3eb1ed"},
+    {file = "grpcio-1.67.1-cp310-cp310-win_amd64.whl", hash = "sha256:608d87d1bdabf9e2868b12338cd38a79969eaf920c89d698ead08f48de9c0f9e"},
+    {file = "grpcio-1.67.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:7818c0454027ae3384235a65210bbf5464bd715450e30a3d40385453a85a70cb"},
+    {file = "grpcio-1.67.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ea33986b70f83844cd00814cee4451055cd8cab36f00ac64a31f5bb09b31919e"},
+    {file = "grpcio-1.67.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:c7a01337407dd89005527623a4a72c5c8e2894d22bead0895306b23c6695698f"},
+    {file = "grpcio-1.67.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:80b866f73224b0634f4312a4674c1be21b2b4afa73cb20953cbbb73a6b36c3cc"},
+    {file = "grpcio-1.67.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f9fff78ba10d4250bfc07a01bd6254a6d87dc67f9627adece85c0b2ed754fa96"},
+    {file = "grpcio-1.67.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:8a23cbcc5bb11ea7dc6163078be36c065db68d915c24f5faa4f872c573bb400f"},
+    {file = "grpcio-1.67.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1a65b503d008f066e994f34f456e0647e5ceb34cfcec5ad180b1b44020ad4970"},
+    {file = "grpcio-1.67.1-cp311-cp311-win32.whl", hash = "sha256:e29ca27bec8e163dca0c98084040edec3bc49afd10f18b412f483cc68c712744"},
+    {file = "grpcio-1.67.1-cp311-cp311-win_amd64.whl", hash = "sha256:786a5b18544622bfb1e25cc08402bd44ea83edfb04b93798d85dca4d1a0b5be5"},
+    {file = "grpcio-1.67.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:267d1745894200e4c604958da5f856da6293f063327cb049a51fe67348e4f953"},
+    {file = "grpcio-1.67.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:85f69fdc1d28ce7cff8de3f9c67db2b0ca9ba4449644488c1e0303c146135ddb"},
+    {file = "grpcio-1.67.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:f26b0b547eb8d00e195274cdfc63ce64c8fc2d3e2d00b12bf468ece41a0423a0"},
+    {file = "grpcio-1.67.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4422581cdc628f77302270ff839a44f4c24fdc57887dc2a45b7e53d8fc2376af"},
+    {file = "grpcio-1.67.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1d7616d2ded471231c701489190379e0c311ee0a6c756f3c03e6a62b95a7146e"},
+    {file = "grpcio-1.67.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8a00efecde9d6fcc3ab00c13f816313c040a28450e5e25739c24f432fc6d3c75"},
+    {file = "grpcio-1.67.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:699e964923b70f3101393710793289e42845791ea07565654ada0969522d0a38"},
+    {file = "grpcio-1.67.1-cp312-cp312-win32.whl", hash = "sha256:4e7b904484a634a0fff132958dabdb10d63e0927398273917da3ee103e8d1f78"},
+    {file = "grpcio-1.67.1-cp312-cp312-win_amd64.whl", hash = "sha256:5721e66a594a6c4204458004852719b38f3d5522082be9061d6510b455c90afc"},
+    {file = "grpcio-1.67.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:aa0162e56fd10a5547fac8774c4899fc3e18c1aa4a4759d0ce2cd00d3696ea6b"},
+    {file = "grpcio-1.67.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:beee96c8c0b1a75d556fe57b92b58b4347c77a65781ee2ac749d550f2a365dc1"},
+    {file = "grpcio-1.67.1-cp313-cp313-manylinux_2_17_aarch64.whl", hash = "sha256:a93deda571a1bf94ec1f6fcda2872dad3ae538700d94dc283c672a3b508ba3af"},
+    {file = "grpcio-1.67.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0e6f255980afef598a9e64a24efce87b625e3e3c80a45162d111a461a9f92955"},
+    {file = "grpcio-1.67.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e838cad2176ebd5d4a8bb03955138d6589ce9e2ce5d51c3ada34396dbd2dba8"},
+    {file = "grpcio-1.67.1-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:a6703916c43b1d468d0756c8077b12017a9fcb6a1ef13faf49e67d20d7ebda62"},
+    {file = "grpcio-1.67.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:917e8d8994eed1d86b907ba2a61b9f0aef27a2155bca6cbb322430fc7135b7bb"},
+    {file = "grpcio-1.67.1-cp313-cp313-win32.whl", hash = "sha256:e279330bef1744040db8fc432becc8a727b84f456ab62b744d3fdb83f327e121"},
+    {file = "grpcio-1.67.1-cp313-cp313-win_amd64.whl", hash = "sha256:fa0c739ad8b1996bd24823950e3cb5152ae91fca1c09cc791190bf1627ffefba"},
+    {file = "grpcio-1.67.1-cp38-cp38-linux_armv7l.whl", hash = "sha256:178f5db771c4f9a9facb2ab37a434c46cb9be1a75e820f187ee3d1e7805c4f65"},
+    {file = "grpcio-1.67.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:0f3e49c738396e93b7ba9016e153eb09e0778e776df6090c1b8c91877cc1c426"},
+    {file = "grpcio-1.67.1-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:24e8a26dbfc5274d7474c27759b54486b8de23c709d76695237515bc8b5baeab"},
+    {file = "grpcio-1.67.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3b6c16489326d79ead41689c4b84bc40d522c9a7617219f4ad94bc7f448c5085"},
+    {file = "grpcio-1.67.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60e6a4dcf5af7bbc36fd9f81c9f372e8ae580870a9e4b6eafe948cd334b81cf3"},
+    {file = "grpcio-1.67.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:95b5f2b857856ed78d72da93cd7d09b6db8ef30102e5e7fe0961fe4d9f7d48e8"},
+    {file = "grpcio-1.67.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b49359977c6ec9f5d0573ea4e0071ad278ef905aa74e420acc73fd28ce39e9ce"},
+    {file = "grpcio-1.67.1-cp38-cp38-win32.whl", hash = "sha256:f5b76ff64aaac53fede0cc93abf57894ab2a7362986ba22243d06218b93efe46"},
+    {file = "grpcio-1.67.1-cp38-cp38-win_amd64.whl", hash = "sha256:804c6457c3cd3ec04fe6006c739579b8d35c86ae3298ffca8de57b493524b771"},
+    {file = "grpcio-1.67.1-cp39-cp39-linux_armv7l.whl", hash = "sha256:a25bdea92b13ff4d7790962190bf6bf5c4639876e01c0f3dda70fc2769616335"},
+    {file = "grpcio-1.67.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:cdc491ae35a13535fd9196acb5afe1af37c8237df2e54427be3eecda3653127e"},
+    {file = "grpcio-1.67.1-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:85f862069b86a305497e74d0dc43c02de3d1d184fc2c180993aa8aa86fbd19b8"},
+    {file = "grpcio-1.67.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ec74ef02010186185de82cc594058a3ccd8d86821842bbac9873fd4a2cf8be8d"},
+    {file = "grpcio-1.67.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01f616a964e540638af5130469451cf580ba8c7329f45ca998ab66e0c7dcdb04"},
+    {file = "grpcio-1.67.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:299b3d8c4f790c6bcca485f9963b4846dd92cf6f1b65d3697145d005c80f9fe8"},
+    {file = "grpcio-1.67.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:60336bff760fbb47d7e86165408126f1dded184448e9a4c892189eb7c9d3f90f"},
+    {file = "grpcio-1.67.1-cp39-cp39-win32.whl", hash = "sha256:5ed601c4c6008429e3d247ddb367fe8c7259c355757448d7c1ef7bd4a6739e8e"},
+    {file = "grpcio-1.67.1-cp39-cp39-win_amd64.whl", hash = "sha256:5db70d32d6703b89912af16d6d45d78406374a8b8ef0d28140351dd0ec610e98"},
+    {file = "grpcio-1.67.1.tar.gz", hash = "sha256:3dc2ed4cabea4dc14d5e708c2b426205956077cc5de419b4d4079315017e9732"},
 ]
 
 [package.extras]
-protobuf = ["grpcio-tools (>=1.70.0)"]
+protobuf = ["grpcio-tools (>=1.67.1)"]
 
 [[package]]
 name = "grpcio-status"
-version = "1.70.0"
+version = "1.67.1"
 description = "Status proto mapping for gRPC"
 optional = true
 python-versions = ">=3.8"
 files = [
-    {file = "grpcio_status-1.70.0-py3-none-any.whl", hash = "sha256:fc5a2ae2b9b1c1969cc49f3262676e6854aa2398ec69cb5bd6c47cd501904a85"},
-    {file = "grpcio_status-1.70.0.tar.gz", hash = "sha256:0e7b42816512433b18b9d764285ff029bde059e9d41f8fe10a60631bd8348101"},
+    {file = "grpcio_status-1.67.1-py3-none-any.whl", hash = "sha256:16e6c085950bdacac97c779e6a502ea671232385e6e37f258884d6883392c2bd"},
+    {file = "grpcio_status-1.67.1.tar.gz", hash = "sha256:2bf38395e028ceeecfd8866b081f61628114b384da7d51ae064ddc8d766a5d11"},
 ]
 
 [package.dependencies]
 googleapis-common-protos = ">=1.5.5"
-grpcio = ">=1.70.0"
+grpcio = ">=1.67.1"
 protobuf = ">=5.26.1,<6.0dev"
 
+[[package]]
+name = "grpcio-tools"
+version = "1.67.1"
+description = "Protobuf code generator for gRPC"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "grpcio_tools-1.67.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:c701aaa51fde1f2644bd94941aa94c337adb86f25cd03cf05e37387aaea25800"},
+    {file = "grpcio_tools-1.67.1-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:6a722bba714392de2386569c40942566b83725fa5c5450b8910e3832a5379469"},
+    {file = "grpcio_tools-1.67.1-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:0c7415235cb154e40b5ae90e2a172a0eb8c774b6876f53947cf0af05c983d549"},
+    {file = "grpcio_tools-1.67.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a4c459098c4934f9470280baf9ff8b38c365e147f33c8abc26039a948a664a5"},
+    {file = "grpcio_tools-1.67.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e89bf53a268f55c16989dab1cf0b32a5bff910762f138136ffad4146129b7a10"},
+    {file = "grpcio_tools-1.67.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:f09cb3e6bcb140f57b878580cf3b848976f67faaf53d850a7da9bfac12437068"},
+    {file = "grpcio_tools-1.67.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:616dd0c6686212ca90ff899bb37eb774798677e43dc6f78c6954470782d37399"},
+    {file = "grpcio_tools-1.67.1-cp310-cp310-win32.whl", hash = "sha256:58a66dbb3f0fef0396737ac09d6571a7f8d96a544ce3ed04c161f3d4fa8d51cc"},
+    {file = "grpcio_tools-1.67.1-cp310-cp310-win_amd64.whl", hash = "sha256:89ee7c505bdf152e67c2cced6055aed4c2d4170f53a2b46a7e543d3b90e7b977"},
+    {file = "grpcio_tools-1.67.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:6d80ddd87a2fb7131d242f7d720222ef4f0f86f53ec87b0a6198c343d8e4a86e"},
+    {file = "grpcio_tools-1.67.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b655425b82df51f3bd9fd3ba1a6282d5c9ce1937709f059cb3d419b224532d89"},
+    {file = "grpcio_tools-1.67.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:250241e6f9d20d0910a46887dfcbf2ec9108efd3b48f3fb95bb42d50d09d03f8"},
+    {file = "grpcio_tools-1.67.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6008f5a5add0b6f03082edb597acf20d5a9e4e7c55ea1edac8296c19e6a0ec8d"},
+    {file = "grpcio_tools-1.67.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5eff9818c3831fa23735db1fa39aeff65e790044d0a312260a0c41ae29cc2d9e"},
+    {file = "grpcio_tools-1.67.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:262ab7c40113f8c3c246e28e369661ddf616a351cb34169b8ba470c9a9c3b56f"},
+    {file = "grpcio_tools-1.67.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1eebd8c746adf5786fa4c3056258c21cc470e1eca51d3ed23a7fb6a697fe4e81"},
+    {file = "grpcio_tools-1.67.1-cp311-cp311-win32.whl", hash = "sha256:3eff92fb8ca1dd55e3af0ef02236c648921fb7d0e8ca206b889585804b3659ae"},
+    {file = "grpcio_tools-1.67.1-cp311-cp311-win_amd64.whl", hash = "sha256:1ed18281ee17e5e0f9f6ce0c6eb3825ca9b5a0866fc1db2e17fab8aca28b8d9f"},
+    {file = "grpcio_tools-1.67.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:bd5caef3a484e226d05a3f72b2d69af500dca972cf434bf6b08b150880166f0b"},
+    {file = "grpcio_tools-1.67.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:48a2d63d1010e5b218e8e758ecb2a8d63c0c6016434e9f973df1c3558917020a"},
+    {file = "grpcio_tools-1.67.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:baa64a6aa009bffe86309e236c81b02cd4a88c1ebd66f2d92e84e9b97a9ae857"},
+    {file = "grpcio_tools-1.67.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4ab318c40b5e3c097a159035fc3e4ecfbe9b3d2c9de189e55468b2c27639a6ab"},
+    {file = "grpcio_tools-1.67.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:50eba3e31f9ac1149463ad9182a37349850904f142cffbd957cd7f54ec320b8e"},
+    {file = "grpcio_tools-1.67.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:de6fbc071ecc4fe6e354a7939202191c1f1abffe37fbce9b08e7e9a5b93eba3d"},
+    {file = "grpcio_tools-1.67.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:db9e87f6ea4b0ce99b2651203480585fd9e8dd0dd122a19e46836e93e3a1b749"},
+    {file = "grpcio_tools-1.67.1-cp312-cp312-win32.whl", hash = "sha256:6a595a872fb720dde924c4e8200f41d5418dd6baab8cc1a3c1e540f8f4596351"},
+    {file = "grpcio_tools-1.67.1-cp312-cp312-win_amd64.whl", hash = "sha256:92eebb9b31031604ae97ea7657ae2e43149b0394af7117ad7e15894b6cc136dc"},
+    {file = "grpcio_tools-1.67.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:9a3b9510cc87b6458b05ad49a6dee38df6af37f9ee6aa027aa086537798c3d4a"},
+    {file = "grpcio_tools-1.67.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9e4c9b9fa9b905f15d414cb7bd007ba7499f8907bdd21231ab287a86b27da81a"},
+    {file = "grpcio_tools-1.67.1-cp313-cp313-manylinux_2_17_aarch64.whl", hash = "sha256:e11a98b41af4bc88b7a738232b8fa0306ad82c79fa5d7090bb607f183a57856f"},
+    {file = "grpcio_tools-1.67.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:de0fcfe61c26679d64b1710746f2891f359593f76894fcf492c37148d5694f00"},
+    {file = "grpcio_tools-1.67.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ae3b3e2ee5aad59dece65a613624c46a84c9582fc3642686537c6dfae8e47dc"},
+    {file = "grpcio_tools-1.67.1-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:9a630f83505b6471a3094a7a372a1240de18d0cd3e64f4fbf46b361bac2be65b"},
+    {file = "grpcio_tools-1.67.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:d85a1fcbacd3e08dc2b3d1d46b749351a9a50899fa35cf2ff040e1faf7d405ad"},
+    {file = "grpcio_tools-1.67.1-cp313-cp313-win32.whl", hash = "sha256:778470f025f25a1fca5a48c93c0a18af395b46b12dd8df7fca63736b85181f41"},
+    {file = "grpcio_tools-1.67.1-cp313-cp313-win_amd64.whl", hash = "sha256:6961da86e9856b4ddee0bf51ef6636b4bf9c29c0715aa71f3c8f027c45d42654"},
+    {file = "grpcio_tools-1.67.1-cp38-cp38-linux_armv7l.whl", hash = "sha256:c088dfbbe289bb171ca9c98fabbf7ecc8c1c51af2ba384ef32a4fdcb784b17e9"},
+    {file = "grpcio_tools-1.67.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11ce546daf8f8c04ee8d4a1673b4754cda4a0a9d505d820efd636e37f46b50c5"},
+    {file = "grpcio_tools-1.67.1-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:83fecb2f6119ef0eea68a091964898418c1969375d399956ff8d1741beb7b081"},
+    {file = "grpcio_tools-1.67.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d39c1aa6b26e2602d815b9cfa37faba48b2889680ae6baa002560cf0f0c69fac"},
+    {file = "grpcio_tools-1.67.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e975dc9fb61a77d88e739eb17b3361f369d03cc754217f02dd83ec7cfac32e38"},
+    {file = "grpcio_tools-1.67.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:6c6e5c5b15f2eedc2a81268d588d14a79a52020383bf87b3c7595df7b571504a"},
+    {file = "grpcio_tools-1.67.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:a974e0ce01806adba718e6eb8c385defe6805b18969b6914da7db55fb055ae45"},
+    {file = "grpcio_tools-1.67.1-cp38-cp38-win32.whl", hash = "sha256:35e9b0a82be9f425aa67ee1dc69ba02cf135aeee3f22c0455c5d1b01769bbdb4"},
+    {file = "grpcio_tools-1.67.1-cp38-cp38-win_amd64.whl", hash = "sha256:0436c97f29e654d2eccd7419907ee019caf7eea6bdc6ae91d98011f6c5f44f17"},
+    {file = "grpcio_tools-1.67.1-cp39-cp39-linux_armv7l.whl", hash = "sha256:718fbb6d68a3d000cb3cf381642660eade0e8c1b0bf7472b84b3367f5b56171d"},
+    {file = "grpcio_tools-1.67.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:062887d2e9cb8bc261c21a2b8da714092893ce62b4e072775eaa9b24dcbf3b31"},
+    {file = "grpcio_tools-1.67.1-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:59dbf14a1ce928bf03a58fa157034374411159ab5d32ad83cf146d9400eed618"},
+    {file = "grpcio_tools-1.67.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ac552fc9c76d50408d7141e1fd1eae69d85fbf7ae71da4d8877eaa07127fbe74"},
+    {file = "grpcio_tools-1.67.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c6583773400e441dc62d08b5a32357babef1a9f9f73c3ac328a75af550815a9"},
+    {file = "grpcio_tools-1.67.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:862108f90f2f6408908e5ea4584c5104f7caf419c6d73aa3ff36bf8284cca224"},
+    {file = "grpcio_tools-1.67.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:587c6326425f37dca2291f46b93e446c07ee781cea27725865b806b7a049ec56"},
+    {file = "grpcio_tools-1.67.1-cp39-cp39-win32.whl", hash = "sha256:d7d46a4405bd763525215b6e073888386587aef9b4a5ec125bf97ba897ac757d"},
+    {file = "grpcio_tools-1.67.1-cp39-cp39-win_amd64.whl", hash = "sha256:e2fc7980e8bab3ee5ab98b6fdc2a8fbaa4785f196d897531346176fda49a605c"},
+    {file = "grpcio_tools-1.67.1.tar.gz", hash = "sha256:d9657f5ddc62b52f58904e6054b7d8a8909ed08a1e28b734be3a707087bcf004"},
+]
+
+[package.dependencies]
+grpcio = ">=1.67.1"
+protobuf = ">=5.26.1,<6.0dev"
+setuptools = "*"
+
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -1519,6 +1605,26 @@ files = [
     {file = "h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1"},
 ]
 
+[[package]]
+name = "hf-xet"
+version = "1.1.5"
+description = "Fast transfer of large files with the Hugging Face Hub."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "hf_xet-1.1.5-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:f52c2fa3635b8c37c7764d8796dfa72706cc4eded19d638331161e82b0792e23"},
+    {file = "hf_xet-1.1.5-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:9fa6e3ee5d61912c4a113e0708eaaef987047616465ac7aa30f7121a48fc1af8"},
+    {file = "hf_xet-1.1.5-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc874b5c843e642f45fd85cda1ce599e123308ad2901ead23d3510a47ff506d1"},
+    {file = "hf_xet-1.1.5-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dbba1660e5d810bd0ea77c511a99e9242d920790d0e63c0e4673ed36c4022d18"},
+    {file = "hf_xet-1.1.5-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ab34c4c3104133c495785d5d8bba3b1efc99de52c02e759cf711a91fd39d3a14"},
+    {file = "hf_xet-1.1.5-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:83088ecea236d5113de478acb2339f92c95b4fb0462acaa30621fac02f5a534a"},
+    {file = "hf_xet-1.1.5-cp37-abi3-win_amd64.whl", hash = "sha256:73e167d9807d166596b4b2f0b585c6d5bd84a26dea32843665a8b58f6edba245"},
+    {file = "hf_xet-1.1.5.tar.gz", hash = "sha256:69ebbcfd9ec44fdc2af73441619eeb06b94ee34511bbcf57cd423820090f5694"},
+]
+
+[package.extras]
+tests = ["pytest"]
+
 [[package]]
 name = "httpcore"
 version = "1.0.9"
@@ -1577,18 +1683,19 @@ files = [
 
 [[package]]
 name = "huggingface-hub"
-version = "0.28.1"
+version = "0.33.2"
 description = "Client library to download and publish models, datasets and other repos on the huggingface.co hub"
 optional = false
 python-versions = ">=3.8.0"
 files = [
-    {file = "huggingface_hub-0.28.1-py3-none-any.whl", hash = "sha256:aa6b9a3ffdae939b72c464dbb0d7f99f56e649b55c3d52406f49e0a5a620c0a7"},
-    {file = "huggingface_hub-0.28.1.tar.gz", hash = "sha256:893471090c98e3b6efbdfdacafe4052b20b84d59866fb6f54c33d9af18c303ae"},
+    {file = "huggingface_hub-0.33.2-py3-none-any.whl", hash = "sha256:3749498bfa91e8cde2ddc2c1db92c79981f40e66434c20133b39e5928ac9bcc5"},
+    {file = "huggingface_hub-0.33.2.tar.gz", hash = "sha256:84221defaec8fa09c090390cd68c78b88e3c4c2b7befba68d3dc5aacbc3c2c5f"},
 ]
 
 [package.dependencies]
 filelock = "*"
 fsspec = ">=2023.5.0"
+hf-xet = {version = ">=1.1.2,<2.0.0", markers = "platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"arm64\" or platform_machine == \"aarch64\""}
 packaging = ">=20.9"
 pyyaml = ">=5.1"
 requests = "*"
@@ -1596,16 +1703,19 @@ tqdm = ">=4.42.1"
 typing-extensions = ">=3.7.4.3"
 
 [package.extras]
-all = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "fastapi", "gradio (>=4.0.0)", "jedi", "libcst (==1.4.0)", "mypy (==1.5.1)", "numpy", "pytest (>=8.1.1,<8.2.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures", "pytest-vcr", "pytest-xdist", "ruff (>=0.9.0)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)", "urllib3 (<2.0)"]
+all = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "authlib (>=1.3.2)", "fastapi", "gradio (>=4.0.0)", "httpx", "itsdangerous", "jedi", "libcst (==1.4.0)", "mypy (==1.15.0)", "mypy (>=1.14.1,<1.15.0)", "numpy", "pytest (>=8.1.1,<8.2.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures", "pytest-vcr", "pytest-xdist", "ruff (>=0.9.0)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)", "urllib3 (<2.0)"]
 cli = ["InquirerPy (==0.3.4)"]
-dev = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "fastapi", "gradio (>=4.0.0)", "jedi", "libcst (==1.4.0)", "mypy (==1.5.1)", "numpy", "pytest (>=8.1.1,<8.2.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures", "pytest-vcr", "pytest-xdist", "ruff (>=0.9.0)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)", "urllib3 (<2.0)"]
+dev = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "authlib (>=1.3.2)", "fastapi", "gradio (>=4.0.0)", "httpx", "itsdangerous", "jedi", "libcst (==1.4.0)", "mypy (==1.15.0)", "mypy (>=1.14.1,<1.15.0)", "numpy", "pytest (>=8.1.1,<8.2.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures", "pytest-vcr", "pytest-xdist", "ruff (>=0.9.0)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)", "urllib3 (<2.0)"]
 fastai = ["fastai (>=2.4)", "fastcore (>=1.3.27)", "toml"]
 hf-transfer = ["hf-transfer (>=0.1.4)"]
+hf-xet = ["hf-xet (>=1.1.2,<2.0.0)"]
 inference = ["aiohttp"]
-quality = ["libcst (==1.4.0)", "mypy (==1.5.1)", "ruff (>=0.9.0)"]
+mcp = ["aiohttp", "mcp (>=1.8.0)", "typer"]
+oauth = ["authlib (>=1.3.2)", "fastapi", "httpx", "itsdangerous"]
+quality = ["libcst (==1.4.0)", "mypy (==1.15.0)", "mypy (>=1.14.1,<1.15.0)", "ruff (>=0.9.0)"]
 tensorflow = ["graphviz", "pydot", "tensorflow"]
 tensorflow-testing = ["keras (<3.0)", "tensorflow"]
-testing = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "fastapi", "gradio (>=4.0.0)", "jedi", "numpy", "pytest (>=8.1.1,<8.2.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures", "pytest-vcr", "pytest-xdist", "soundfile", "urllib3 (<2.0)"]
+testing = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "authlib (>=1.3.2)", "fastapi", "gradio (>=4.0.0)", "httpx", "itsdangerous", "jedi", "numpy", "pytest (>=8.1.1,<8.2.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures", "pytest-vcr", "pytest-xdist", "soundfile", "urllib3 (<2.0)"]
 torch = ["safetensors[torch]", "torch"]
 typing = ["types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)"]
 
@@ -2723,6 +2833,24 @@ files = [
     {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"},
 ]
 
+[[package]]
+name = "networkx"
+version = "3.2.1"
+description = "Python package for creating and manipulating graphs and networks"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "networkx-3.2.1-py3-none-any.whl", hash = "sha256:f18c69adc97877c42332c170849c96cefa91881c99a7cb3e95b7c659ebdc1ec2"},
+    {file = "networkx-3.2.1.tar.gz", hash = "sha256:9f1bb5cf3409bf324e0a722c20bdb4c20ee39bf1c30ce8ae499c8502b0b5e0c6"},
+]
+
+[package.extras]
+default = ["matplotlib (>=3.5)", "numpy (>=1.22)", "pandas (>=1.4)", "scipy (>=1.9,!=1.11.0,!=1.11.1)"]
+developer = ["changelist (==0.4)", "mypy (>=1.1)", "pre-commit (>=3.2)", "rtoml"]
+doc = ["nb2plots (>=0.7)", "nbconvert (<7.9)", "numpydoc (>=1.6)", "pillow (>=9.4)", "pydata-sphinx-theme (>=0.14)", "sphinx (>=7)", "sphinx-gallery (>=0.14)", "texext (>=0.6.7)"]
+extra = ["lxml (>=4.6)", "pydot (>=1.4.2)", "pygraphviz (>=1.11)", "sympy (>=1.10)"]
+test = ["pytest (>=7.2)", "pytest-cov (>=4.0)"]
+
 [[package]]
 name = "nodeenv"
 version = "1.9.1"
@@ -2843,6 +2971,215 @@ files = [
     {file = "numpy-2.2.5.tar.gz", hash = "sha256:a9c0d994680cd991b1cb772e8b297340085466a6fe964bc9d4e80f5e2f43c291"},
 ]
 
+[[package]]
+name = "nvidia-cublas-cu12"
+version = "12.6.4.1"
+description = "CUBLAS native runtime libraries"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_cublas_cu12-12.6.4.1-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08ed2686e9875d01b58e3cb379c6896df8e76c75e0d4a7f7dace3d7b6d9ef8eb"},
+    {file = "nvidia_cublas_cu12-12.6.4.1-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:235f728d6e2a409eddf1df58d5b0921cf80cfa9e72b9f2775ccb7b4a87984668"},
+    {file = "nvidia_cublas_cu12-12.6.4.1-py3-none-win_amd64.whl", hash = "sha256:9e4fa264f4d8a4eb0cdbd34beadc029f453b3bafae02401e999cf3d5a5af75f8"},
+]
+
+[[package]]
+name = "nvidia-cuda-cupti-cu12"
+version = "12.6.80"
+description = "CUDA profiling tools runtime libs."
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:166ee35a3ff1587f2490364f90eeeb8da06cd867bd5b701bf7f9a02b78bc63fc"},
+    {file = "nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_aarch64.whl", hash = "sha256:358b4a1d35370353d52e12f0a7d1769fc01ff74a191689d3870b2123156184c4"},
+    {file = "nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6768bad6cab4f19e8292125e5f1ac8aa7d1718704012a0e3272a6f61c4bce132"},
+    {file = "nvidia_cuda_cupti_cu12-12.6.80-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a3eff6cdfcc6a4c35db968a06fcadb061cbc7d6dde548609a941ff8701b98b73"},
+    {file = "nvidia_cuda_cupti_cu12-12.6.80-py3-none-win_amd64.whl", hash = "sha256:bbe6ae76e83ce5251b56e8c8e61a964f757175682bbad058b170b136266ab00a"},
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc-cu12"
+version = "12.6.77"
+description = "NVRTC native runtime libraries"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:5847f1d6e5b757f1d2b3991a01082a44aad6f10ab3c5c0213fa3e25bddc25a13"},
+    {file = "nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:35b0cc6ee3a9636d5409133e79273ce1f3fd087abb0532d2d2e8fff1fe9efc53"},
+    {file = "nvidia_cuda_nvrtc_cu12-12.6.77-py3-none-win_amd64.whl", hash = "sha256:f7007dbd914c56bd80ea31bc43e8e149da38f68158f423ba845fc3292684e45a"},
+]
+
+[[package]]
+name = "nvidia-cuda-runtime-cu12"
+version = "12.6.77"
+description = "CUDA Runtime native Libraries"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6116fad3e049e04791c0256a9778c16237837c08b27ed8c8401e2e45de8d60cd"},
+    {file = "nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:d461264ecb429c84c8879a7153499ddc7b19b5f8d84c204307491989a365588e"},
+    {file = "nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba3b56a4f896141e25e19ab287cd71e52a6a0f4b29d0d31609f60e3b4d5219b7"},
+    {file = "nvidia_cuda_runtime_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a84d15d5e1da416dd4774cb42edf5e954a3e60cc945698dc1d5be02321c44dc8"},
+    {file = "nvidia_cuda_runtime_cu12-12.6.77-py3-none-win_amd64.whl", hash = "sha256:86c58044c824bf3c173c49a2dbc7a6c8b53cb4e4dca50068be0bf64e9dab3f7f"},
+]
+
+[[package]]
+name = "nvidia-cudnn-cu12"
+version = "9.5.1.17"
+description = "cuDNN runtime libraries"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_cudnn_cu12-9.5.1.17-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:9fd4584468533c61873e5fda8ca41bac3a38bcb2d12350830c69b0a96a7e4def"},
+    {file = "nvidia_cudnn_cu12-9.5.1.17-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:30ac3869f6db17d170e0e556dd6cc5eee02647abc31ca856634d5a40f82c15b2"},
+    {file = "nvidia_cudnn_cu12-9.5.1.17-py3-none-win_amd64.whl", hash = "sha256:d7af0f8a4f3b4b9dbb3122f2ef553b45694ed9c384d5a75bab197b8eefb79ab8"},
+]
+
+[package.dependencies]
+nvidia-cublas-cu12 = "*"
+
+[[package]]
+name = "nvidia-cufft-cu12"
+version = "11.3.0.4"
+description = "CUFFT native runtime libraries"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d16079550df460376455cba121db6564089176d9bac9e4f360493ca4741b22a6"},
+    {file = "nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8510990de9f96c803a051822618d42bf6cb8f069ff3f48d93a8486efdacb48fb"},
+    {file = "nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ccba62eb9cef5559abd5e0d54ceed2d9934030f51163df018532142a8ec533e5"},
+    {file = "nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_x86_64.whl", hash = "sha256:768160ac89f6f7b459bee747e8d175dbf53619cfe74b2a5636264163138013ca"},
+    {file = "nvidia_cufft_cu12-11.3.0.4-py3-none-win_amd64.whl", hash = "sha256:6048ebddfb90d09d2707efb1fd78d4e3a77cb3ae4dc60e19aab6be0ece2ae464"},
+]
+
+[package.dependencies]
+nvidia-nvjitlink-cu12 = "*"
+
+[[package]]
+name = "nvidia-cufile-cu12"
+version = "1.11.1.6"
+description = "cuFile GPUDirect libraries"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_cufile_cu12-1.11.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc23469d1c7e52ce6c1d55253273d32c565dd22068647f3aa59b3c6b005bf159"},
+    {file = "nvidia_cufile_cu12-1.11.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:8f57a0051dcf2543f6dc2b98a98cb2719c37d3cee1baba8965d57f3bbc90d4db"},
+]
+
+[[package]]
+name = "nvidia-curand-cu12"
+version = "10.3.7.77"
+description = "CURAND native runtime libraries"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:6e82df077060ea28e37f48a3ec442a8f47690c7499bff392a5938614b56c98d8"},
+    {file = "nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a42cd1344297f70b9e39a1e4f467a4e1c10f1da54ff7a85c12197f6c652c8bdf"},
+    {file = "nvidia_curand_cu12-10.3.7.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:99f1a32f1ac2bd134897fc7a203f779303261268a65762a623bf30cc9fe79117"},
+    {file = "nvidia_curand_cu12-10.3.7.77-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:7b2ed8e95595c3591d984ea3603dd66fe6ce6812b886d59049988a712ed06b6e"},
+    {file = "nvidia_curand_cu12-10.3.7.77-py3-none-win_amd64.whl", hash = "sha256:6d6d935ffba0f3d439b7cd968192ff068fafd9018dbf1b85b37261b13cfc9905"},
+]
+
+[[package]]
+name = "nvidia-cusolver-cu12"
+version = "11.7.1.2"
+description = "CUDA solver native runtime libraries"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0ce237ef60acde1efc457335a2ddadfd7610b892d94efee7b776c64bb1cac9e0"},
+    {file = "nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e9e49843a7707e42022babb9bcfa33c29857a93b88020c4e4434656a655b698c"},
+    {file = "nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6cf28f17f64107a0c4d7802be5ff5537b2130bfc112f25d5a30df227058ca0e6"},
+    {file = "nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:dbbe4fc38ec1289c7e5230e16248365e375c3673c9c8bac5796e2e20db07f56e"},
+    {file = "nvidia_cusolver_cu12-11.7.1.2-py3-none-win_amd64.whl", hash = "sha256:6813f9d8073f555444a8705f3ab0296d3e1cb37a16d694c5fc8b862a0d8706d7"},
+]
+
+[package.dependencies]
+nvidia-cublas-cu12 = "*"
+nvidia-cusparse-cu12 = "*"
+nvidia-nvjitlink-cu12 = "*"
+
+[[package]]
+name = "nvidia-cusparse-cu12"
+version = "12.5.4.2"
+description = "CUSPARSE native runtime libraries"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d25b62fb18751758fe3c93a4a08eff08effedfe4edf1c6bb5afd0890fe88f887"},
+    {file = "nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7aa32fa5470cf754f72d1116c7cbc300b4e638d3ae5304cfa4a638a5b87161b1"},
+    {file = "nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7556d9eca156e18184b94947ade0fba5bb47d69cec46bf8660fd2c71a4b48b73"},
+    {file = "nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_x86_64.whl", hash = "sha256:23749a6571191a215cb74d1cdbff4a86e7b19f1200c071b3fcf844a5bea23a2f"},
+    {file = "nvidia_cusparse_cu12-12.5.4.2-py3-none-win_amd64.whl", hash = "sha256:4acb8c08855a26d737398cba8fb6f8f5045d93f82612b4cfd84645a2332ccf20"},
+]
+
+[package.dependencies]
+nvidia-nvjitlink-cu12 = "*"
+
+[[package]]
+name = "nvidia-cusparselt-cu12"
+version = "0.6.3"
+description = "NVIDIA cuSPARSELt"
+optional = false
+python-versions = "*"
+files = [
+    {file = "nvidia_cusparselt_cu12-0.6.3-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8371549623ba601a06322af2133c4a44350575f5a3108fb75f3ef20b822ad5f1"},
+    {file = "nvidia_cusparselt_cu12-0.6.3-py3-none-manylinux2014_x86_64.whl", hash = "sha256:e5c8a26c36445dd2e6812f1177978a24e2d37cacce7e090f297a688d1ec44f46"},
+    {file = "nvidia_cusparselt_cu12-0.6.3-py3-none-win_amd64.whl", hash = "sha256:3b325bcbd9b754ba43df5a311488fca11a6b5dc3d11df4d190c000cf1a0765c7"},
+]
+
+[[package]]
+name = "nvidia-nccl-cu12"
+version = "2.26.2"
+description = "NVIDIA Collective Communication Library (NCCL) Runtime"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_nccl_cu12-2.26.2-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c196e95e832ad30fbbb50381eb3cbd1fadd5675e587a548563993609af19522"},
+    {file = "nvidia_nccl_cu12-2.26.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:694cf3879a206553cc9d7dbda76b13efaf610fdb70a50cba303de1b0d1530ac6"},
+]
+
+[[package]]
+name = "nvidia-nvjitlink-cu12"
+version = "12.6.85"
+description = "Nvidia JIT LTO Library"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_nvjitlink_cu12-12.6.85-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:eedc36df9e88b682efe4309aa16b5b4e78c2407eac59e8c10a6a47535164369a"},
+    {file = "nvidia_nvjitlink_cu12-12.6.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cf4eaa7d4b6b543ffd69d6abfb11efdeb2db48270d94dfd3a452c24150829e41"},
+    {file = "nvidia_nvjitlink_cu12-12.6.85-py3-none-win_amd64.whl", hash = "sha256:e61120e52ed675747825cdd16febc6a0730537451d867ee58bee3853b1b13d1c"},
+]
+
+[[package]]
+name = "nvidia-nvtx-cu12"
+version = "12.6.77"
+description = "NVIDIA Tools Extension"
+optional = false
+python-versions = ">=3"
+files = [
+    {file = "nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f44f8d86bb7d5629988d61c8d3ae61dddb2015dee142740536bc7481b022fe4b"},
+    {file = "nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_aarch64.whl", hash = "sha256:adcaabb9d436c9761fca2b13959a2d237c5f9fd406c8e4b723c695409ff88059"},
+    {file = "nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b90bed3df379fa79afbd21be8e04a0314336b8ae16768b58f2d34cb1d04cd7d2"},
+    {file = "nvidia_nvtx_cu12-12.6.77-py3-none-manylinux2014_x86_64.whl", hash = "sha256:6574241a3ec5fdc9334353ab8c479fe75841dbe8f4532a8fc97ce63503330ba1"},
+    {file = "nvidia_nvtx_cu12-12.6.77-py3-none-win_amd64.whl", hash = "sha256:2fb11a4af04a5e6c84073e6404d26588a34afd35379f0855a99797897efa75c0"},
+]
+
+[[package]]
+name = "nvidia-riva-client"
+version = "2.21.0"
+description = "Python implementation of the Riva Client API"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "nvidia_riva_client-2.21.0-py3-none-any.whl", hash = "sha256:76478a9c14f774c169a07f541912ae6e979db672d4898959e4412ae15d529520"},
+]
+
+[package.dependencies]
+grpcio = "1.67.1"
+grpcio-tools = "1.67.1"
+setuptools = "78.1.1"
+
 [[package]]
 name = "nvidia-sphinx-theme"
 version = "0.0.8"
@@ -4280,7 +4617,7 @@ typing-extensions = {version = ">=4.4.0", markers = "python_version < \"3.13\""}
 name = "regex"
 version = "2024.11.6"
 description = "Alternative regular expression module, to replace re."
-optional = true
+optional = false
 python-versions = ">=3.8"
 files = [
     {file = "regex-2024.11.6-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ff590880083d60acc0433f9c3f713c51f7ac6ebb9adf889c79a261ecf541aa91"},
@@ -4573,20 +4910,119 @@ files = [
 [package.dependencies]
 pyasn1 = ">=0.1.3"
 
+[[package]]
+name = "safetensors"
+version = "0.5.3"
+description = ""
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "safetensors-0.5.3-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:bd20eb133db8ed15b40110b7c00c6df51655a2998132193de2f75f72d99c7073"},
+    {file = "safetensors-0.5.3-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:21d01c14ff6c415c485616b8b0bf961c46b3b343ca59110d38d744e577f9cce7"},
+    {file = "safetensors-0.5.3-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:11bce6164887cd491ca75c2326a113ba934be596e22b28b1742ce27b1d076467"},
+    {file = "safetensors-0.5.3-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4a243be3590bc3301c821da7a18d87224ef35cbd3e5f5727e4e0728b8172411e"},
+    {file = "safetensors-0.5.3-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8bd84b12b1670a6f8e50f01e28156422a2bc07fb16fc4e98bded13039d688a0d"},
+    {file = "safetensors-0.5.3-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:391ac8cab7c829452175f871fcaf414aa1e292b5448bd02620f675a7f3e7abb9"},
+    {file = "safetensors-0.5.3-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cead1fa41fc54b1e61089fa57452e8834f798cb1dc7a09ba3524f1eb08e0317a"},
+    {file = "safetensors-0.5.3-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1077f3e94182d72618357b04b5ced540ceb71c8a813d3319f1aba448e68a770d"},
+    {file = "safetensors-0.5.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:799021e78287bac619c7b3f3606730a22da4cda27759ddf55d37c8db7511c74b"},
+    {file = "safetensors-0.5.3-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:df26da01aaac504334644e1b7642fa000bfec820e7cef83aeac4e355e03195ff"},
+    {file = "safetensors-0.5.3-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:32c3ef2d7af8b9f52ff685ed0bc43913cdcde135089ae322ee576de93eae5135"},
+    {file = "safetensors-0.5.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:37f1521be045e56fc2b54c606d4455573e717b2d887c579ee1dbba5f868ece04"},
+    {file = "safetensors-0.5.3-cp38-abi3-win32.whl", hash = "sha256:cfc0ec0846dcf6763b0ed3d1846ff36008c6e7290683b61616c4b040f6a54ace"},
+    {file = "safetensors-0.5.3-cp38-abi3-win_amd64.whl", hash = "sha256:836cbbc320b47e80acd40e44c8682db0e8ad7123209f69b093def21ec7cafd11"},
+    {file = "safetensors-0.5.3.tar.gz", hash = "sha256:b6b0d6ecacec39a4fdd99cc19f4576f5219ce858e6fd8dbe7609df0b8dc56965"},
+]
+
+[package.extras]
+all = ["safetensors[jax]", "safetensors[numpy]", "safetensors[paddlepaddle]", "safetensors[pinned-tf]", "safetensors[quality]", "safetensors[testing]", "safetensors[torch]"]
+dev = ["safetensors[all]"]
+jax = ["flax (>=0.6.3)", "jax (>=0.3.25)", "jaxlib (>=0.3.25)", "safetensors[numpy]"]
+mlx = ["mlx (>=0.0.9)"]
+numpy = ["numpy (>=1.21.6)"]
+paddlepaddle = ["paddlepaddle (>=2.4.1)", "safetensors[numpy]"]
+pinned-tf = ["safetensors[numpy]", "tensorflow (==2.18.0)"]
+quality = ["black (==22.3)", "click (==8.0.4)", "flake8 (>=3.8.3)", "isort (>=5.5.4)"]
+tensorflow = ["safetensors[numpy]", "tensorflow (>=2.11.0)"]
+testing = ["h5py (>=3.7.0)", "huggingface-hub (>=0.12.1)", "hypothesis (>=6.70.2)", "pytest (>=7.2.0)", "pytest-benchmark (>=4.0.0)", "safetensors[numpy]", "setuptools-rust (>=1.5.2)"]
+torch = ["safetensors[numpy]", "torch (>=1.10)"]
+
+[[package]]
+name = "sentencepiece"
+version = "0.2.0"
+description = "SentencePiece python wrapper"
+optional = false
+python-versions = "*"
+files = [
+    {file = "sentencepiece-0.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:188779e1298a1c8b8253c7d3ad729cb0a9891e5cef5e5d07ce4592c54869e227"},
+    {file = "sentencepiece-0.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bed9cf85b296fa2b76fc2547b9cbb691a523864cebaee86304c43a7b4cb1b452"},
+    {file = "sentencepiece-0.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d7b67e724bead13f18db6e1d10b6bbdc454af574d70efbb36f27d90387be1ca3"},
+    {file = "sentencepiece-0.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fde4b08cfe237be4484c6c7c2e2c75fb862cfeab6bd5449ce4caeafd97b767a"},
+    {file = "sentencepiece-0.2.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c378492056202d1c48a4979650981635fd97875a00eabb1f00c6a236b013b5e"},
+    {file = "sentencepiece-0.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1380ce6540a368de2ef6d7e6ba14ba8f3258df650d39ba7d833b79ee68a52040"},
+    {file = "sentencepiece-0.2.0-cp310-cp310-win32.whl", hash = "sha256:a1151d6a6dd4b43e552394aed0edfe9292820272f0194bd56c7c1660a0c06c3d"},
+    {file = "sentencepiece-0.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:d490142b0521ef22bc1085f061d922a2a6666175bb6b42e588ff95c0db6819b2"},
+    {file = "sentencepiece-0.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:17982700c4f6dbb55fa3594f3d7e5dd1c8659a274af3738e33c987d2a27c9d5c"},
+    {file = "sentencepiece-0.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7c867012c0e8bcd5bdad0f791609101cb5c66acb303ab3270218d6debc68a65e"},
+    {file = "sentencepiece-0.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7fd6071249c74f779c5b27183295b9202f8dedb68034e716784364443879eaa6"},
+    {file = "sentencepiece-0.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27f90c55a65013cbb8f4d7aab0599bf925cde4adc67ae43a0d323677b5a1c6cb"},
+    {file = "sentencepiece-0.2.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b293734059ef656dcd65be62ff771507bea8fed0a711b6733976e1ed3add4553"},
+    {file = "sentencepiece-0.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e58b47f933aca74c6a60a79dcb21d5b9e47416256c795c2d58d55cec27f9551d"},
+    {file = "sentencepiece-0.2.0-cp311-cp311-win32.whl", hash = "sha256:c581258cf346b327c62c4f1cebd32691826306f6a41d8c4bec43b010dee08e75"},
+    {file = "sentencepiece-0.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:0993dbc665f4113017892f1b87c3904a44d0640eda510abcacdfb07f74286d36"},
+    {file = "sentencepiece-0.2.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:ea5f536e32ea8ec96086ee00d7a4a131ce583a1b18d130711707c10e69601cb2"},
+    {file = "sentencepiece-0.2.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d0cb51f53b6aae3c36bafe41e86167c71af8370a039f542c43b0cce5ef24a68c"},
+    {file = "sentencepiece-0.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3212121805afc58d8b00ab4e7dd1f8f76c203ddb9dc94aa4079618a31cf5da0f"},
+    {file = "sentencepiece-0.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2a3149e3066c2a75e0d68a43eb632d7ae728c7925b517f4c05c40f6f7280ce08"},
+    {file = "sentencepiece-0.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:632f3594d3e7ac8b367bca204cb3fd05a01d5b21455acd097ea4c0e30e2f63d7"},
+    {file = "sentencepiece-0.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f295105c6bdbb05bd5e1b0cafbd78ff95036f5d3641e7949455a3f4e5e7c3109"},
+    {file = "sentencepiece-0.2.0-cp312-cp312-win32.whl", hash = "sha256:fb89f811e5efd18bab141afc3fea3de141c3f69f3fe9e898f710ae7fe3aab251"},
+    {file = "sentencepiece-0.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7a673a72aab81fef5ebe755c6e0cc60087d1f3a4700835d40537183c1703a45f"},
+    {file = "sentencepiece-0.2.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:4547683f330289ec4f093027bfeb87f9ef023b2eb6f879fdc4a8187c7e0ffb90"},
+    {file = "sentencepiece-0.2.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cd6175f7eaec7142d2bf6f6597ce7db4c9ac89acf93fcdb17410c3a8b781eeb"},
+    {file = "sentencepiece-0.2.0-cp36-cp36m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:859ba1acde782609a0910a26a60e16c191a82bf39b5621107552c0cd79fad00f"},
+    {file = "sentencepiece-0.2.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcbbef6cc277f8f18f36959e305f10b1c620442d75addc79c21d7073ae581b50"},
+    {file = "sentencepiece-0.2.0-cp36-cp36m-win32.whl", hash = "sha256:536b934e244829e3fe6c4f198652cd82da48adb9aa145c9f00889542726dee3d"},
+    {file = "sentencepiece-0.2.0-cp36-cp36m-win_amd64.whl", hash = "sha256:0a91aaa3c769b52440df56fafda683b3aa48e3f2169cf7ee5b8c8454a7f3ae9b"},
+    {file = "sentencepiece-0.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:787e480ca4c1d08c9985a7eb1eae4345c107729c99e9b5a9a00f2575fc7d4b4b"},
+    {file = "sentencepiece-0.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4d158189eb2ecffea3a51edf6d25e110b3678ec47f1a40f2d541eafbd8f6250"},
+    {file = "sentencepiece-0.2.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d1e5ca43013e8935f25457a4fca47e315780172c3e821b4b13a890668911c792"},
+    {file = "sentencepiece-0.2.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7140d9e5a74a0908493bb4a13f1f16a401297bd755ada4c707e842fbf6f0f5bf"},
+    {file = "sentencepiece-0.2.0-cp37-cp37m-win32.whl", hash = "sha256:6cf333625234f247ab357b0bd9836638405ea9082e1543d5b8408f014979dcbf"},
+    {file = "sentencepiece-0.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:ff88712338b01031910e8e61e7239aff3ce8869ee31a47df63cb38aadd591bea"},
+    {file = "sentencepiece-0.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:20813a68d4c221b1849c62c30e1281ea81687894d894b8d4a0f4677d9311e0f5"},
+    {file = "sentencepiece-0.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:926ef920ae2e8182db31d3f5d081ada57804e3e1d3a8c4ef8b117f9d9fb5a945"},
+    {file = "sentencepiece-0.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:89f65f69636b7e9c015b79dff9c9985a9bc7d19ded6f79ef9f1ec920fdd73ecf"},
+    {file = "sentencepiece-0.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f67eae0dbe6f2d7d6ba50a354623d787c99965f068b81e145d53240198021b0"},
+    {file = "sentencepiece-0.2.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:98501e075f35dd1a1d5a20f65be26839fcb1938752ec61539af008a5aa6f510b"},
+    {file = "sentencepiece-0.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e3d1d2cc4882e8d6a1adf9d5927d7716f80617fc693385661caff21888972269"},
+    {file = "sentencepiece-0.2.0-cp38-cp38-win32.whl", hash = "sha256:b99a308a2e5e569031ab164b74e6fab0b6f37dfb493c32f7816225f4d411a6dd"},
+    {file = "sentencepiece-0.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:cdb701eec783d3ec86b7cd4c763adad8eaf6b46db37ee1c36e5e6c44b3fe1b5f"},
+    {file = "sentencepiece-0.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:1e0f9c4d0a6b0af59b613175f019916e28ade076e21242fd5be24340d8a2f64a"},
+    {file = "sentencepiece-0.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:298f21cc1366eb60311aedba3169d30f885c363ddbf44214b0a587d2908141ad"},
+    {file = "sentencepiece-0.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3f1ec95aa1e5dab11f37ac7eff190493fd87770f7a8b81ebc9dd768d1a3c8704"},
+    {file = "sentencepiece-0.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b06b70af54daa4b4904cbb90b4eb6d35c9f3252fdc86c9c32d5afd4d30118d8"},
+    {file = "sentencepiece-0.2.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22e37bac44dd6603388cb598c64ff7a76e41ca774646f21c23aadfbf5a2228ab"},
+    {file = "sentencepiece-0.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0461324897735512a32d222e3d886e24ad6a499761952b6bda2a9ee6e4313ea5"},
+    {file = "sentencepiece-0.2.0-cp39-cp39-win32.whl", hash = "sha256:38aed822fb76435fa1f12185f10465a94ab9e51d5e8a9159e9a540ce926f0ffd"},
+    {file = "sentencepiece-0.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:d8cf876516548b5a1d6ac4745d8b554f5c07891d55da557925e5c13ff0b4e6ad"},
+    {file = "sentencepiece-0.2.0.tar.gz", hash = "sha256:a52c19171daaf2e697dc6cbe67684e0fa341b1248966f6aebb541de654d15843"},
+]
+
 [[package]]
 name = "setuptools"
-version = "75.8.0"
+version = "78.1.1"
 description = "Easily download, build, install, upgrade, and uninstall Python packages"
-optional = true
+optional = false
 python-versions = ">=3.9"
 files = [
-    {file = "setuptools-75.8.0-py3-none-any.whl", hash = "sha256:e3982f444617239225d675215d51f6ba05f845d4eec313da4418fdbb56fb27e3"},
-    {file = "setuptools-75.8.0.tar.gz", hash = "sha256:c5afc8f407c626b8313a86e10311dd3f661c6cd9c09d4bf8c15c0e11f9f2b0e6"},
+    {file = "setuptools-78.1.1-py3-none-any.whl", hash = "sha256:c3a9c4211ff4c309edb8b8c4f1cbfa7ae324c4ba9f91ff254e3d305b9fd54561"},
+    {file = "setuptools-78.1.1.tar.gz", hash = "sha256:fcc17fd9cd898242f6b4adfaca46137a9edef687f43e6f78469692a5e70d851d"},
 ]
 
 [package.extras]
 check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)", "ruff (>=0.8.0)"]
-core = ["importlib_metadata (>=6)", "jaraco.collections", "jaraco.functools (>=4)", "jaraco.text (>=3.7)", "more_itertools", "more_itertools (>=8.8)", "packaging", "packaging (>=24.2)", "platformdirs (>=4.2.2)", "tomli (>=2.0.1)", "wheel (>=0.43.0)"]
+core = ["importlib_metadata (>=6)", "jaraco.functools (>=4)", "jaraco.text (>=3.7)", "more_itertools", "more_itertools (>=8.8)", "packaging (>=24.2)", "platformdirs (>=4.2.2)", "tomli (>=2.0.1)", "wheel (>=0.43.0)"]
 cover = ["pytest-cov"]
 doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier", "towncrier (<24.7)"]
 enabler = ["pytest-enabler (>=2.2)"]
@@ -5508,6 +5944,67 @@ files = [
     {file = "tomlkit-0.13.2.tar.gz", hash = "sha256:fff5fe59a87295b278abd31bec92c15d9bc4a06885ab12bcea52c71119392e79"},
 ]
 
+[[package]]
+name = "torch"
+version = "2.7.1"
+description = "Tensors and Dynamic neural networks in Python with strong GPU acceleration"
+optional = false
+python-versions = ">=3.9.0"
+files = [
+    {file = "torch-2.7.1-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:a103b5d782af5bd119b81dbcc7ffc6fa09904c423ff8db397a1e6ea8fd71508f"},
+    {file = "torch-2.7.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:fe955951bdf32d182ee8ead6c3186ad54781492bf03d547d31771a01b3d6fb7d"},
+    {file = "torch-2.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:885453d6fba67d9991132143bf7fa06b79b24352f4506fd4d10b309f53454162"},
+    {file = "torch-2.7.1-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:d72acfdb86cee2a32c0ce0101606f3758f0d8bb5f8f31e7920dc2809e963aa7c"},
+    {file = "torch-2.7.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:236f501f2e383f1cb861337bdf057712182f910f10aeaf509065d54d339e49b2"},
+    {file = "torch-2.7.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:06eea61f859436622e78dd0cdd51dbc8f8c6d76917a9cf0555a333f9eac31ec1"},
+    {file = "torch-2.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:8273145a2e0a3c6f9fd2ac36762d6ee89c26d430e612b95a99885df083b04e52"},
+    {file = "torch-2.7.1-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:aea4fc1bf433d12843eb2c6b2204861f43d8364597697074c8d38ae2507f8730"},
+    {file = "torch-2.7.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:27ea1e518df4c9de73af7e8a720770f3628e7f667280bce2be7a16292697e3fa"},
+    {file = "torch-2.7.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c33360cfc2edd976c2633b3b66c769bdcbbf0e0b6550606d188431c81e7dd1fc"},
+    {file = "torch-2.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:d8bf6e1856ddd1807e79dc57e54d3335f2b62e6f316ed13ed3ecfe1fc1df3d8b"},
+    {file = "torch-2.7.1-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:787687087412c4bd68d315e39bc1223f08aae1d16a9e9771d95eabbb04ae98fb"},
+    {file = "torch-2.7.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:03563603d931e70722dce0e11999d53aa80a375a3d78e6b39b9f6805ea0a8d28"},
+    {file = "torch-2.7.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:d632f5417b6980f61404a125b999ca6ebd0b8b4bbdbb5fbbba44374ab619a412"},
+    {file = "torch-2.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:23660443e13995ee93e3d844786701ea4ca69f337027b05182f5ba053ce43b38"},
+    {file = "torch-2.7.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:0da4f4dba9f65d0d203794e619fe7ca3247a55ffdcbd17ae8fb83c8b2dc9b585"},
+    {file = "torch-2.7.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:e08d7e6f21a617fe38eeb46dd2213ded43f27c072e9165dc27300c9ef9570934"},
+    {file = "torch-2.7.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:30207f672328a42df4f2174b8f426f354b2baa0b7cca3a0adb3d6ab5daf00dc8"},
+    {file = "torch-2.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:79042feca1c634aaf6603fe6feea8c6b30dfa140a6bbc0b973e2260c7e79a22e"},
+    {file = "torch-2.7.1-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:988b0cbc4333618a1056d2ebad9eb10089637b659eb645434d0809d8d937b946"},
+    {file = "torch-2.7.1-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:e0d81e9a12764b6f3879a866607c8ae93113cbcad57ce01ebde63eb48a576369"},
+    {file = "torch-2.7.1-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:8394833c44484547ed4a47162318337b88c97acdb3273d85ea06e03ffff44998"},
+    {file = "torch-2.7.1-cp39-cp39-win_amd64.whl", hash = "sha256:df41989d9300e6e3c19ec9f56f856187a6ef060c3662fe54f4b6baf1fc90bd19"},
+    {file = "torch-2.7.1-cp39-none-macosx_11_0_arm64.whl", hash = "sha256:a737b5edd1c44a5c1ece2e9f3d00df9d1b3fb9541138bee56d83d38293fb6c9d"},
+]
+
+[package.dependencies]
+filelock = "*"
+fsspec = "*"
+jinja2 = "*"
+networkx = "*"
+nvidia-cublas-cu12 = {version = "12.6.4.1", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-cuda-cupti-cu12 = {version = "12.6.80", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-cuda-nvrtc-cu12 = {version = "12.6.77", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-cuda-runtime-cu12 = {version = "12.6.77", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-cudnn-cu12 = {version = "9.5.1.17", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-cufft-cu12 = {version = "11.3.0.4", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-cufile-cu12 = {version = "1.11.1.6", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-curand-cu12 = {version = "10.3.7.77", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-cusolver-cu12 = {version = "11.7.1.2", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-cusparse-cu12 = {version = "12.5.4.2", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-cusparselt-cu12 = {version = "0.6.3", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-nccl-cu12 = {version = "2.26.2", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-nvjitlink-cu12 = {version = "12.6.85", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+nvidia-nvtx-cu12 = {version = "12.6.77", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+setuptools = {version = "*", markers = "python_version >= \"3.12\""}
+sympy = ">=1.13.3"
+triton = {version = "3.3.1", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""}
+typing-extensions = ">=4.10.0"
+
+[package.extras]
+opt-einsum = ["opt-einsum (>=3.3)"]
+optree = ["optree (>=0.13.0)"]
+
 [[package]]
 name = "tornado"
 version = "6.5.1"
@@ -5577,6 +6074,101 @@ notebook = ["ipywidgets (>=6)"]
 slack = ["slack-sdk"]
 telegram = ["requests"]
 
+[[package]]
+name = "transformers"
+version = "4.53.1"
+description = "State-of-the-art Machine Learning for JAX, PyTorch and TensorFlow"
+optional = false
+python-versions = ">=3.9.0"
+files = [
+    {file = "transformers-4.53.1-py3-none-any.whl", hash = "sha256:c84f3c3e41c71fdf2c60c8a893e1cd31191b0cb463385f4c276302d2052d837b"},
+    {file = "transformers-4.53.1.tar.gz", hash = "sha256:da5a9f66ad480bc2a7f75bc32eaf735fd20ac56af4325ca4ce994021ceb37710"},
+]
+
+[package.dependencies]
+filelock = "*"
+huggingface-hub = ">=0.30.0,<1.0"
+numpy = ">=1.17"
+packaging = ">=20.0"
+pyyaml = ">=5.1"
+regex = "!=2019.12.17"
+requests = "*"
+safetensors = ">=0.4.3"
+tokenizers = ">=0.21,<0.22"
+tqdm = ">=4.27"
+
+[package.extras]
+accelerate = ["accelerate (>=0.26.0)"]
+all = ["Pillow (>=10.0.1,<=15.0)", "Pillow (>=10.0.1,<=15.0)", "accelerate (>=0.26.0)", "accelerate (>=0.26.0)", "av", "codecarbon (>=2.8.1)", "flax (>=0.4.1,<=0.7.0)", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1,<0.14.0)", "kernels (>=0.6.1,<0.7)", "librosa", "num2words", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "phonemizer", "protobuf", "pyctcdecode (>=0.4.0)", "ray[tune] (>=2.7.0)", "scipy (<1.13.0)", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "tensorflow (>2.9,<2.16)", "tensorflow-text (<2.16)", "tf2onnx", "timm (<=1.0.11)", "tokenizers (>=0.21,<0.22)", "torch (>=2.1)", "torchaudio", "torchvision"]
+audio = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)"]
+benchmark = ["optimum-benchmark (>=0.3.0)"]
+codecarbon = ["codecarbon (>=2.8.1)"]
+deepspeed = ["accelerate (>=0.26.0)", "deepspeed (>=0.9.3)"]
+deepspeed-testing = ["GitPython (<3.1.19)", "accelerate (>=0.26.0)", "beautifulsoup4", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "datasets (!=2.5.0)", "deepspeed (>=0.9.3)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "nltk (<=3.8.1)", "optuna", "parameterized", "protobuf", "psutil", "pydantic", "pytest (>=7.2.0)", "pytest-asyncio", "pytest-order", "pytest-rerunfailures", "pytest-rich", "pytest-timeout", "pytest-xdist", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (==0.11.2)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "sentencepiece (>=0.1.91,!=0.1.92)", "sentencepiece (>=0.1.91,!=0.1.92)", "tensorboard", "timeout-decorator"]
+dev = ["GitPython (<3.1.19)", "GitPython (<3.1.19)", "Pillow (>=10.0.1,<=15.0)", "Pillow (>=10.0.1,<=15.0)", "accelerate (>=0.26.0)", "accelerate (>=0.26.0)", "av", "beautifulsoup4", "codecarbon (>=2.8.1)", "cookiecutter (==1.7.3)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "datasets (!=2.5.0)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "flax (>=0.4.1,<=0.7.0)", "fugashi (>=1.0)", "ipadic (>=1.0.0,<2.0)", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "kenlm", "keras-nlp (>=0.3.1,<0.14.0)", "kernels (>=0.6.1,<0.7)", "libcst", "librosa", "nltk (<=3.8.1)", "num2words", "onnxconverter-common", "optax (>=0.0.8,<=0.1.4)", "optuna", "pandas (<2.3.0)", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pydantic", "pytest (>=7.2.0)", "pytest-asyncio", "pytest-order", "pytest-rerunfailures", "pytest-rich", "pytest-timeout", "pytest-xdist", "ray[tune] (>=2.7.0)", "rhoknp (>=1.1.0,<1.3.1)", "rich", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (==0.11.2)", "ruff (==0.11.2)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "scipy (<1.13.0)", "sentencepiece (>=0.1.91,!=0.1.92)", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "sudachidict_core (>=20220729)", "sudachipy (>=0.6.6)", "tensorboard", "tensorflow (>2.9,<2.16)", "tensorflow-text (<2.16)", "tf2onnx", "timeout-decorator", "timm (<=1.0.11)", "tokenizers (>=0.21,<0.22)", "torch (>=2.1)", "torchaudio", "torchvision", "unidic (>=1.0.2)", "unidic_lite (>=1.0.7)", "urllib3 (<2.0.0)"]
+dev-tensorflow = ["GitPython (<3.1.19)", "GitPython (<3.1.19)", "Pillow (>=10.0.1,<=15.0)", "beautifulsoup4", "cookiecutter (==1.7.3)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "datasets (!=2.5.0)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "kenlm", "keras-nlp (>=0.3.1,<0.14.0)", "libcst", "librosa", "nltk (<=3.8.1)", "onnxconverter-common", "onnxconverter-common", "onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)", "pandas (<2.3.0)", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pydantic", "pytest (>=7.2.0)", "pytest-asyncio", "pytest-order", "pytest-rerunfailures", "pytest-rich", "pytest-timeout", "pytest-xdist", "rich", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (==0.11.2)", "ruff (==0.11.2)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "sentencepiece (>=0.1.91,!=0.1.92)", "tensorboard", "tensorflow (>2.9,<2.16)", "tensorflow-text (<2.16)", "tf2onnx", "tf2onnx", "timeout-decorator", "tokenizers (>=0.21,<0.22)", "urllib3 (<2.0.0)"]
+dev-torch = ["GitPython (<3.1.19)", "GitPython (<3.1.19)", "Pillow (>=10.0.1,<=15.0)", "Pillow (>=10.0.1,<=15.0)", "accelerate (>=0.26.0)", "beautifulsoup4", "codecarbon (>=2.8.1)", "cookiecutter (==1.7.3)", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "datasets (!=2.5.0)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "fugashi (>=1.0)", "ipadic (>=1.0.0,<2.0)", "kenlm", "kernels (>=0.6.1,<0.7)", "libcst", "librosa", "nltk (<=3.8.1)", "num2words", "onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)", "optuna", "pandas (<2.3.0)", "parameterized", "phonemizer", "protobuf", "psutil", "pyctcdecode (>=0.4.0)", "pydantic", "pytest (>=7.2.0)", "pytest-asyncio", "pytest-order", "pytest-rerunfailures", "pytest-rich", "pytest-timeout", "pytest-xdist", "ray[tune] (>=2.7.0)", "rhoknp (>=1.1.0,<1.3.1)", "rich", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (==0.11.2)", "ruff (==0.11.2)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "scikit-learn", "sentencepiece (>=0.1.91,!=0.1.92)", "sentencepiece (>=0.1.91,!=0.1.92)", "sigopt", "sudachidict_core (>=20220729)", "sudachipy (>=0.6.6)", "tensorboard", "timeout-decorator", "timm (<=1.0.11)", "tokenizers (>=0.21,<0.22)", "torch (>=2.1)", "torchaudio", "torchvision", "unidic (>=1.0.2)", "unidic_lite (>=1.0.7)", "urllib3 (<2.0.0)"]
+flax = ["flax (>=0.4.1,<=0.7.0)", "jax (>=0.4.1,<=0.4.13)", "jaxlib (>=0.4.1,<=0.4.13)", "optax (>=0.0.8,<=0.1.4)", "scipy (<1.13.0)"]
+flax-speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)"]
+ftfy = ["ftfy"]
+hf-xet = ["hf_xet"]
+hub-kernels = ["kernels (>=0.6.1,<0.7)"]
+integrations = ["kernels (>=0.6.1,<0.7)", "optuna", "ray[tune] (>=2.7.0)", "sigopt"]
+ja = ["fugashi (>=1.0)", "ipadic (>=1.0.0,<2.0)", "rhoknp (>=1.1.0,<1.3.1)", "sudachidict_core (>=20220729)", "sudachipy (>=0.6.6)", "unidic (>=1.0.2)", "unidic_lite (>=1.0.7)"]
+modelcreation = ["cookiecutter (==1.7.3)"]
+natten = ["natten (>=0.14.6,<0.15.0)"]
+num2words = ["num2words"]
+onnx = ["onnxconverter-common", "onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)", "tf2onnx"]
+onnxruntime = ["onnxruntime (>=1.4.0)", "onnxruntime-tools (>=1.4.2)"]
+open-telemetry = ["opentelemetry-api", "opentelemetry-exporter-otlp", "opentelemetry-sdk"]
+optuna = ["optuna"]
+quality = ["GitPython (<3.1.19)", "datasets (!=2.5.0)", "libcst", "pandas (<2.3.0)", "rich", "ruff (==0.11.2)", "urllib3 (<2.0.0)"]
+ray = ["ray[tune] (>=2.7.0)"]
+retrieval = ["datasets (!=2.5.0)", "faiss-cpu"]
+ruff = ["ruff (==0.11.2)"]
+sagemaker = ["sagemaker (>=2.31.0)"]
+sentencepiece = ["protobuf", "sentencepiece (>=0.1.91,!=0.1.92)"]
+serving = ["fastapi", "pydantic", "starlette", "uvicorn"]
+sigopt = ["sigopt"]
+sklearn = ["scikit-learn"]
+speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)", "torchaudio"]
+testing = ["GitPython (<3.1.19)", "beautifulsoup4", "cookiecutter (==1.7.3)", "datasets (!=2.5.0)", "datasets (!=2.5.0)", "dill (<0.3.5)", "evaluate (>=0.2.0)", "faiss-cpu", "nltk (<=3.8.1)", "parameterized", "psutil", "pydantic", "pytest (>=7.2.0)", "pytest-asyncio", "pytest-order", "pytest-rerunfailures", "pytest-rich", "pytest-timeout", "pytest-xdist", "rjieba", "rouge-score (!=0.0.7,!=0.0.8,!=0.1,!=0.1.1)", "ruff (==0.11.2)", "sacrebleu (>=1.4.12,<2.0.0)", "sacremoses", "sentencepiece (>=0.1.91,!=0.1.92)", "tensorboard", "timeout-decorator"]
+tf = ["keras-nlp (>=0.3.1,<0.14.0)", "onnxconverter-common", "tensorflow (>2.9,<2.16)", "tensorflow-text (<2.16)", "tf2onnx"]
+tf-cpu = ["keras (>2.9,<2.16)", "keras-nlp (>=0.3.1,<0.14.0)", "onnxconverter-common", "tensorflow-cpu (>2.9,<2.16)", "tensorflow-probability (<0.24)", "tensorflow-text (<2.16)", "tf2onnx"]
+tf-speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)"]
+tiktoken = ["blobfile", "tiktoken"]
+timm = ["timm (<=1.0.11)"]
+tokenizers = ["tokenizers (>=0.21,<0.22)"]
+torch = ["accelerate (>=0.26.0)", "torch (>=2.1)"]
+torch-speech = ["kenlm", "librosa", "phonemizer", "pyctcdecode (>=0.4.0)", "torchaudio"]
+torch-vision = ["Pillow (>=10.0.1,<=15.0)", "torchvision"]
+torchhub = ["filelock", "huggingface-hub (>=0.30.0,<1.0)", "importlib_metadata", "numpy (>=1.17)", "packaging (>=20.0)", "protobuf", "regex (!=2019.12.17)", "requests", "sentencepiece (>=0.1.91,!=0.1.92)", "tokenizers (>=0.21,<0.22)", "torch (>=2.1)", "tqdm (>=4.27)"]
+video = ["av"]
+vision = ["Pillow (>=10.0.1,<=15.0)"]
+
+[[package]]
+name = "triton"
+version = "3.3.1"
+description = "A language and compiler for custom Deep Learning operations"
+optional = false
+python-versions = "*"
+files = [
+    {file = "triton-3.3.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b74db445b1c562844d3cfad6e9679c72e93fdfb1a90a24052b03bb5c49d1242e"},
+    {file = "triton-3.3.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b31e3aa26f8cb3cc5bf4e187bf737cbacf17311e1112b781d4a059353dfd731b"},
+    {file = "triton-3.3.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9999e83aba21e1a78c1f36f21bce621b77bcaa530277a50484a7cb4a822f6e43"},
+    {file = "triton-3.3.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b89d846b5a4198317fec27a5d3a609ea96b6d557ff44b56c23176546023c4240"},
+    {file = "triton-3.3.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3198adb9d78b77818a5388bff89fa72ff36f9da0bc689db2f0a651a67ce6a42"},
+    {file = "triton-3.3.1-cp39-cp39-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f6139aeb04a146b0b8e0fbbd89ad1e65861c57cfed881f21d62d3cb94a36bab7"},
+]
+
+[package.dependencies]
+setuptools = ">=40.8.0"
+
+[package.extras]
+build = ["cmake (>=3.20)", "lit"]
+tests = ["autopep8", "isort", "llnl-hatchet", "numpy", "pytest", "pytest-forked", "pytest-xdist", "scipy (>=1.7.1)"]
+tutorials = ["matplotlib", "pandas", "tabulate"]
+
 [[package]]
 name = "typer"
 version = "0.15.1"
@@ -6207,4 +6799,4 @@ tracing = ["aiofiles", "opentelemetry-api", "opentelemetry-sdk"]
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.9,!=3.9.7,<3.14"
-content-hash = "21afb705795e1fa98317667365ac57bd18a7cc7a4726f7919c163efcf0cf1091"
+content-hash = "ae318be5185e021c199af45df1d0c82aa3f8e7e6f8b13f7f5be2e9f5c506bd23"
diff --git a/pyproject.toml b/pyproject.toml
index e19c14b04..6374c172b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -110,6 +110,7 @@ gcp = ["google-cloud-language"]
 tracing = ["opentelemetry-api", "opentelemetry-sdk", "aiofiles"]
 nvidia = ["langchain-nvidia-ai-endpoints"]
 jailbreak = ["yara-python"]
+translation = ["deepl", "nvidia-riva-client", "torch", "transformers", "sentencepiece", "langdetect"]
 # Poetry does not support recursive dependencies, so we need to add all the dependencies here.
 # I also support their decision. There is no PEP for recursive dependencies, but it has been supported in pip since version 21.2.
 # It is here for backward compatibility.
@@ -126,6 +127,11 @@ all = [
   "aiofiles",
   "langchain-nvidia-ai-endpoints",
   "yara-python",
+  "deepl",
+  "nvidia-riva-client",
+  "torch",
+  "transformers",
+  "sentencepiece"
 ]
 
 [tool.poetry.group.dev]
diff --git a/tests/eval/translate/test_langprovider_base.py b/tests/eval/translate/test_langprovider_base.py
new file mode 100644
index 000000000..08d228736
--- /dev/null
+++ b/tests/eval/translate/test_langprovider_base.py
@@ -0,0 +1,303 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from nemoguardrails.evaluate.langproviders.base import TranslationProvider
+
+
+class MockTranslationProvider(TranslationProvider):
+    """Mock implementation of TranslationProvider for testing."""
+
+    ENV_VAR = "MOCK_API_KEY"
+
+    def _load_langprovider(self):
+        """Mock implementation of _load_langprovider."""
+        self.loaded = True
+
+    def _translate(self, text: str) -> str:
+        """Mock implementation of _translate."""
+        return f"translated_{text}"
+
+
+class TestTranslationProvider:
+    """Test cases for TranslationProvider base class."""
+
+    def test_init_with_config(self):
+        """Test initialization with valid configuration."""
+        config = {
+            "langproviders": {
+                "mock.MockTranslator": {
+                    "language": "en,ja",
+                    "model_type": "mock.MockTranslator",
+                }
+            }
+        }
+
+        with patch.dict(os.environ, {"MOCK_API_KEY": "test_key"}):
+            provider = MockTranslationProvider(config)
+
+            assert provider.language == "en,ja"
+            assert provider.source_lang == "en"
+            assert provider.target_lang == "ja"
+            assert provider.api_key == "test_key"
+            assert provider.key_env_var == "MOCK_API_KEY"
+            assert hasattr(provider, "loaded")
+            assert provider.loaded is True
+
+    def test_init_without_config(self):
+        """Test initialization without configuration."""
+        with pytest.raises(Exception):
+            provider = MockTranslationProvider()
+
+    def test_init_same_source_target_language(self):
+        """Test initialization with same source and target language raises exception."""
+        config = {
+            "langproviders": {
+                "mock.MockTranslator": {
+                    "language": "en,en",
+                    "model_type": "mock.MockTranslator",
+                }
+            }
+        }
+
+        with pytest.raises(Exception) as exc_info:
+            MockTranslationProvider(config)
+
+        assert "Source and target languages cannot be the same: en" in str(
+            exc_info.value
+        )
+
+    def test_init_missing_env_var(self):
+        """Test initialization with missing environment variable raises exception."""
+        config = {
+            "langproviders": {
+                "mock.MockTranslator": {
+                    "language": "en,ja",
+                    "model_type": "mock.MockTranslator",
+                }
+            }
+        }
+
+        # Ensure the environment variable is not set
+        if "MOCK_API_KEY" in os.environ:
+            del os.environ["MOCK_API_KEY"]
+
+        with pytest.raises(Exception) as exc_info:
+            MockTranslationProvider(config)
+
+        assert "Put the API key in the MOCK_API_KEY environment variable" in str(
+            exc_info.value
+        )
+
+    def test_init_with_existing_api_key(self):
+        """Test initialization when api_key is already set."""
+        config = {
+            "langproviders": {
+                "mock.MockTranslator": {
+                    "language": "en,ja",
+                    "model_type": "mock.MockTranslator",
+                }
+            }
+        }
+
+        # Create provider with existing api_key
+        provider = MockTranslationProvider.__new__(MockTranslationProvider)
+        provider.api_key = "existing_key"
+
+        with patch.object(provider, "_load_langprovider"):
+            provider.__init__(config)
+
+            assert provider.api_key == "existing_key"
+
+    def test_get_response(self):
+        """Test _get_response method."""
+        config = {
+            "langproviders": {
+                "mock.MockTranslator": {
+                    "language": "en,ja",
+                    "model_type": "mock.MockTranslator",
+                }
+            }
+        }
+
+        with patch.dict(os.environ, {"MOCK_API_KEY": "test_key"}):
+            provider = MockTranslationProvider(config)
+
+            result = provider._get_response("hello")
+            assert result == "translated_hello"
+
+    def test_validate_env_var_without_env_var_attr(self):
+        """Test _validate_env_var when class doesn't have ENV_VAR attribute."""
+
+        class NoEnvVarProvider(TranslationProvider):
+            def _load_langprovider(self):
+                pass
+
+            def _translate(self, text: str) -> str:
+                return text
+
+        config = {
+            "langproviders": {
+                "mock.NoEnvVarProvider": {
+                    "language": "en,ja",
+                    "model_type": "mock.NoEnvVarProvider",
+                }
+            }
+        }
+
+        # Should not raise exception when no ENV_VAR attribute
+        provider = NoEnvVarProvider(config)
+        assert not hasattr(provider, "key_env_var")
+
+    def test_validate_env_var_with_empty_env_var(self):
+        """Test _validate_env_var with empty environment variable."""
+        config = {
+            "langproviders": {
+                "mock.MockTranslator": {
+                    "language": "en,ja",
+                    "model_type": "mock.MockTranslator",
+                }
+            }
+        }
+
+        with patch.dict(os.environ, {"MOCK_API_KEY": ""}):
+            with pytest.raises(Exception) as exc_info:
+                MockTranslationProvider(config)
+
+            assert "Put the API key in the MOCK_API_KEY environment variable" in str(
+                exc_info.value
+            )
+
+    def test_config_with_multiple_langproviders(self):
+        """Test initialization with multiple language providers (should use first one)."""
+        config = {
+            "langproviders": {
+                "mock.MockTranslator1": {
+                    "language": "en,ja",
+                    "model_type": "mock.MockTranslator1",
+                },
+                "mock.MockTranslator2": {
+                    "language": "ja,en",
+                    "model_type": "mock.MockTranslator2",
+                },
+            }
+        }
+
+        with patch.dict(os.environ, {"MOCK_API_KEY": "test_key"}):
+            provider = MockTranslationProvider(config)
+
+            # Should use the first language provider
+            assert provider.language == "en,ja"
+            assert provider.source_lang == "en"
+            assert provider.target_lang == "ja"
+
+    def test_config_with_empty_langproviders(self):
+        """Test initialization with empty langproviders configuration."""
+        config = {"langproviders": {}}
+        with pytest.raises(Exception):
+            provider = MockTranslationProvider(config)
+
+    def test_translate_method_implementation(self):
+        """Test that _translate method is properly called."""
+        config = {
+            "langproviders": {
+                "mock.MockTranslator": {
+                    "language": "en,ja",
+                    "model_type": "mock.MockTranslator",
+                }
+            }
+        }
+
+        with patch.dict(os.environ, {"MOCK_API_KEY": "test_key"}):
+            provider = MockTranslationProvider(config)
+
+            # Test direct _translate call
+            result = provider._translate("test message")
+            assert result == "translated_test message"
+
+            # Test through _get_response
+            result = provider._get_response("another message")
+            assert result == "translated_another message"
+
+    def test_language_parsing_edge_cases(self):
+        """Test language parsing with various edge cases."""
+        test_cases = [
+            ("en,ja", ("en", "ja")),
+            ("ja,en", ("ja", "en")),
+            ("fr,de", ("fr", "de")),
+        ]
+
+        for language_pair, expected in test_cases:
+            config = {
+                "langproviders": {
+                    "mock.MockTranslator": {
+                        "language": language_pair,
+                        "model_type": "mock.MockTranslator",
+                    }
+                }
+            }
+
+            with patch.dict(os.environ, {"MOCK_API_KEY": "test_key"}):
+                provider = MockTranslationProvider(config)
+
+                assert provider.source_lang == expected[0]
+                assert provider.target_lang == expected[1]
+
+    def test_error_message_format(self):
+        """Test that error messages are properly formatted."""
+        config = {
+            "langproviders": {
+                "mock.MockTranslator": {
+                    "language": "en,en",
+                    "model_type": "mock.MockTranslator",
+                }
+            }
+        }
+
+        with pytest.raises(Exception) as exc_info:
+            MockTranslationProvider(config)
+
+        error_message = str(exc_info.value)
+        assert "Source and target languages cannot be the same: en" in error_message
+
+    def test_env_var_error_message_format(self):
+        """Test that environment variable error messages are properly formatted."""
+        config = {
+            "langproviders": {
+                "mock.MockTranslator": {
+                    "language": "en,ja",
+                    "model_type": "mock.MockTranslator",
+                }
+            }
+        }
+
+        # Ensure the environment variable is not set
+        if "MOCK_API_KEY" in os.environ:
+            del os.environ["MOCK_API_KEY"]
+
+        with pytest.raises(Exception) as exc_info:
+            MockTranslationProvider(config)
+
+        error_message = str(exc_info.value)
+        assert "MOCK_API_KEY" in error_message
+        assert "environment variable" in error_message
+        assert "export MOCK_API_KEY=" in error_message
diff --git a/tests/eval/translate/test_load_langprovider.py b/tests/eval/translate/test_load_langprovider.py
new file mode 100644
index 000000000..978d888f1
--- /dev/null
+++ b/tests/eval/translate/test_load_langprovider.py
@@ -0,0 +1,312 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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 shutil
+import tempfile
+from unittest.mock import MagicMock, patch
+
+import pytest
+import yaml
+
+from nemoguardrails.evaluate.utils_translate import (
+    PluginConfigurationError,
+    _load_langprovider,
+    load_dataset,
+)
+
+
+class TestLoadLangProvider:
+    """Test cases for _load_langprovider function."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        # Create a temporary config file for testing
+        self.temp_dir = tempfile.mkdtemp()
+        self.test_config_path = os.path.join(self.temp_dir, "test_translation.yaml")
+
+        # Create test configuration
+        test_config = {
+            "langproviders": [
+                {"language": "en,ja", "model_type": "remote.DeeplTranslator"}
+            ]
+        }
+
+        with open(self.test_config_path, "w") as f:
+            yaml.dump(test_config, f)
+
+    def teardown_method(self):
+        """Clean up test fixtures."""
+        if os.path.exists(self.test_config_path):
+            os.remove(self.test_config_path)
+        if os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+
+    @patch("nemoguardrails.evaluate.utils_translate._load_plugin")
+    def test_load_langprovider_success(self, mock_load_plugin):
+        """Test successful loading of language provider."""
+        # Mock the plugin loader to return a mock LangProvider instance
+        mock_provider = MagicMock()
+        mock_load_plugin.return_value = mock_provider
+
+        # Call the function
+        result = _load_langprovider(self.test_config_path)
+
+        # Verify the result
+        assert result == mock_provider
+
+        # Verify _load_plugin was called with correct arguments
+        mock_load_plugin.assert_called_once_with(
+            path="nemoguardrails.evaluate.langproviders.remote.DeeplTranslator",
+            config_root={
+                "langproviders": {
+                    "remote.DeeplTranslator": {
+                        "language": "en,ja",
+                        "model_type": "remote.DeeplTranslator",
+                    }
+                }
+            },
+        )
+
+    def test_load_langprovider_default_config(self):
+        """Test loading with default configuration file."""
+        # Call without specifying config path should raise an error
+        with pytest.raises(PluginConfigurationError) as exc_info:
+            _load_langprovider()
+
+        assert "No configuration file provided" in str(exc_info.value)
+
+    def test_load_langprovider_invalid_config_file(self):
+        """Test loading with non-existent configuration file."""
+        invalid_path = "/path/to/nonexistent/config.yaml"
+
+        with pytest.raises(FileNotFoundError):
+            _load_langprovider(invalid_path)
+
+    def test_load_langprovider_invalid_yaml(self):
+        """Test loading with invalid YAML configuration."""
+        # Create invalid YAML file
+        invalid_config_path = os.path.join(self.temp_dir, "invalid.yaml")
+        with open(invalid_config_path, "w") as f:
+            f.write("invalid: yaml: content: [")
+
+        with pytest.raises(yaml.YAMLError):
+            _load_langprovider(invalid_config_path)
+
+    def test_load_langprovider_missing_langproviders_key(self):
+        """Test loading with configuration missing 'langproviders' key."""
+        # Create config without langproviders key
+        invalid_config = {"other_key": "value"}
+        invalid_config_path = os.path.join(self.temp_dir, "invalid_config.yaml")
+
+        with open(invalid_config_path, "w") as f:
+            yaml.dump(invalid_config, f)
+
+        with pytest.raises(KeyError):
+            _load_langprovider(invalid_config_path)
+
+    def test_load_langprovider_empty_langproviders_list(self):
+        """Test loading with empty langproviders list."""
+        # Create config with empty langproviders list
+        empty_config = {"langproviders": []}
+        empty_config_path = os.path.join(self.temp_dir, "empty_config.yaml")
+
+        with open(empty_config_path, "w") as f:
+            yaml.dump(empty_config, f)
+
+        with pytest.raises(IndexError):
+            _load_langprovider(empty_config_path)
+
+    @patch("nemoguardrails.evaluate.utils_translate._load_plugin")
+    def test_load_langprovider_plugin_load_error(self, mock_load_plugin):
+        """Test handling of plugin loading errors."""
+        # Mock _load_plugin to raise an exception
+        mock_load_plugin.side_effect = ImportError("Module not found")
+
+        with pytest.raises(PluginConfigurationError) as exc_info:
+            _load_langprovider(self.test_config_path)
+
+        assert (
+            "Failed to load 'en,ja' langprovider of type 'remote.DeeplTranslator'"
+            in str(exc_info.value)
+        )
+
+    def test_load_langprovider_config_structure(self):
+        """Test that the function correctly processes the configuration structure."""
+        with patch(
+            "nemoguardrails.evaluate.utils_translate._load_plugin"
+        ) as mock_load_plugin:
+            mock_provider = MagicMock()
+            mock_load_plugin.return_value = mock_provider
+
+            # Call the function
+            _load_langprovider(self.test_config_path)
+
+            # Verify the config structure passed to _load_plugin
+            call_args = mock_load_plugin.call_args
+            config_root = call_args[1]["config_root"]
+
+            assert "langproviders" in config_root
+            assert "remote.DeeplTranslator" in config_root["langproviders"]
+            assert (
+                config_root["langproviders"]["remote.DeeplTranslator"]["language"]
+                == "en,ja"
+            )
+            assert (
+                config_root["langproviders"]["remote.DeeplTranslator"]["model_type"]
+                == "remote.DeeplTranslator"
+            )
+
+    def test_load_langprovider_different_model_type(self):
+        """Test loading with different model type."""
+        # Create config with different model type
+        different_config = {
+            "langproviders": [
+                {"language": "ja,en", "model_type": "local.LocalTranslator"}
+            ]
+        }
+        different_config_path = os.path.join(self.temp_dir, "different_config.yaml")
+
+        with open(different_config_path, "w") as f:
+            yaml.dump(different_config, f)
+
+        with patch(
+            "nemoguardrails.evaluate.utils_translate._load_plugin"
+        ) as mock_load_plugin:
+            mock_provider = MagicMock()
+            mock_load_plugin.return_value = mock_provider
+
+            result = _load_langprovider(different_config_path)
+
+            assert result == mock_provider
+            mock_load_plugin.assert_called_once_with(
+                path="nemoguardrails.evaluate.langproviders.local.LocalTranslator",
+                config_root={
+                    "langproviders": {
+                        "local.LocalTranslator": {
+                            "language": "ja,en",
+                            "model_type": "local.LocalTranslator",
+                        }
+                    }
+                },
+            )
+
+    @patch("nemoguardrails.evaluate.utils_translate._load_langprovider")
+    def test_load_dataset_with_local_translator_model_name(
+        self, mock_load_langprovider
+    ):
+        """Test that local translator with model_name creates appropriate cache filename."""
+        # Create a mock translator with model_name attribute
+        mock_translator = MagicMock()
+        mock_translator.__class__.__name__ = "LocalHFTranslator"
+        mock_translator.model_name = "facebook/m2m100_1.2B"
+        mock_translator.target_lang = "ja"
+        mock_translator._translate.return_value = "翻訳されたテキスト"
+        mock_load_langprovider.return_value = mock_translator
+
+        # Create test dataset file
+        test_dataset_path = os.path.join(self.temp_dir, "test_dataset.txt")
+        with open(test_dataset_path, "w") as f:
+            f.write("Hello world\n")
+
+        # Create test translation config
+        test_translation_config = os.path.join(
+            self.temp_dir, "test_translation_config.yaml"
+        )
+        test_config = {
+            "langproviders": [
+                {
+                    "language": "en,ja",
+                    "model_type": "local.LocalHFTranslator",
+                    "model_name": "facebook/m2m100_1.2B",
+                }
+            ]
+        }
+        with open(test_translation_config, "w") as f:
+            yaml.dump(test_config, f)
+
+        # Call load_dataset
+        with patch(
+            "nemoguardrails.evaluate.utils_translate.get_translation_cache"
+        ) as mock_get_cache:
+            mock_cache = MagicMock()
+            mock_get_cache.return_value = mock_cache
+            mock_cache.get.return_value = None  # No cached translation
+            mock_cache.get_cache_stats.return_value = {
+                "total_entries": 0,
+                "cache_size_bytes": 0,
+                "cache_size_mb": 0.0,
+                "cache_file": "test_cache.json",
+            }
+
+            result = load_dataset(test_dataset_path, test_translation_config)
+
+            # Verify that get_translation_cache was called with the expected service name
+            expected_service_name = (
+                "LocalHFTranslator_facebook_m2m100_1.2B_test_dataset"
+            )
+            mock_get_cache.assert_called_once_with(expected_service_name)
+
+    @patch("nemoguardrails.evaluate.utils_translate._load_langprovider")
+    def test_load_dataset_with_remote_translator_no_model_name(
+        self, mock_load_langprovider
+    ):
+        """Test that remote translator without model_name uses class name only."""
+        # Create a mock translator without model_name attribute
+        mock_translator = MagicMock()
+        mock_translator.__class__.__name__ = "DeeplTranslator"
+        mock_translator.target_lang = "ja"
+        mock_translator._translate.return_value = "翻訳されたテキスト"
+        # model_name属性を明示的に削除
+        if hasattr(mock_translator, "model_name"):
+            del mock_translator.model_name
+        mock_load_langprovider.return_value = mock_translator
+
+        # Create test dataset file
+        test_dataset_path = os.path.join(self.temp_dir, "test_dataset.txt")
+        with open(test_dataset_path, "w") as f:
+            f.write("Hello world\n")
+
+        # Create test translation config
+        test_translation_config = os.path.join(
+            self.temp_dir, "test_translation_config.yaml"
+        )
+        test_config = {
+            "langproviders": [
+                {"language": "en,ja", "model_type": "remote.DeeplTranslator"}
+            ]
+        }
+        with open(test_translation_config, "w") as f:
+            yaml.dump(test_config, f)
+
+        # Call load_dataset
+        with patch(
+            "nemoguardrails.evaluate.utils_translate.get_translation_cache"
+        ) as mock_get_cache:
+            mock_cache = MagicMock()
+            mock_get_cache.return_value = mock_cache
+            mock_cache.get.return_value = None  # No cached translation
+            mock_cache.get_cache_stats.return_value = {
+                "total_entries": 0,
+                "cache_size_bytes": 0,
+                "cache_size_mb": 0.0,
+                "cache_file": "test_cache.json",
+            }
+
+            result = load_dataset(test_dataset_path, test_translation_config)
+
+            # Verify that get_translation_cache was called with the expected service name
+            expected_service_name = "DeeplTranslator_test_dataset"
+            mock_get_cache.assert_called_once_with(expected_service_name)
diff --git a/tests/eval/translate/test_local_hf_translator.py b/tests/eval/translate/test_local_hf_translator.py
new file mode 100644
index 000000000..7707ea867
--- /dev/null
+++ b/tests/eval/translate/test_local_hf_translator.py
@@ -0,0 +1,393 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# torchとtorch.multiprocessingをモック
+sys.modules["torch"] = MagicMock()
+sys.modules["torch.multiprocessing"] = MagicMock()
+# transformersとそのクラスもモック
+sys.modules["transformers"] = MagicMock()
+sys.modules["transformers.MarianMTModel"] = MagicMock()
+sys.modules["transformers.MarianTokenizer"] = MagicMock()
+sys.modules["transformers.M2M100ForConditionalGeneration"] = MagicMock()
+sys.modules["transformers.M2M100Tokenizer"] = MagicMock()
+
+from nemoguardrails.evaluate.langproviders.local import LocalHFTranslator
+
+
+class TestLocalHFTranslator:
+    """Test cases for LocalHFTranslator class."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.config = {
+            "langproviders": {
+                "local.LocalHFTranslator": {
+                    "language": "en,ja",
+                    "model_type": "local.LocalHFTranslator",
+                    "model_name": "Helsinki-NLP/opus-mt-{}",
+                    "hf_args": {"device": "cpu"},
+                }
+            }
+        }
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_init_with_valid_config(self, mock_torch, mock_set_start_method):
+        """Test initialization with valid configuration."""
+        mock_torch.cuda.is_available.return_value = False
+
+        with patch("transformers.MarianMTModel") as mock_model_class:
+            with patch("transformers.MarianTokenizer") as mock_tokenizer_class:
+                mock_model = MagicMock()
+                mock_model_to = MagicMock()
+                mock_model_class.from_pretrained.return_value.to.return_value = (
+                    mock_model_to
+                )
+                mock_tokenizer = MagicMock()
+                mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+
+                translator = LocalHFTranslator(self.config)
+
+                assert translator.language == "en,ja"
+                assert translator.source_lang == "en"
+                assert translator.target_lang == "jap"
+                assert translator.model_name == "Helsinki-NLP/opus-mt-en-jap"
+                # hf_argsのassertは削除
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_init_with_cuda_available(self, mock_torch, mock_set_start_method):
+        """Test initialization when CUDA is available."""
+        mock_torch.cuda.is_available.return_value = True
+
+        with patch("transformers.MarianMTModel") as mock_model_class:
+            with patch("transformers.MarianTokenizer") as mock_tokenizer_class:
+                mock_model = MagicMock()
+                mock_model_to = MagicMock()
+                mock_model_class.from_pretrained.return_value.to.return_value = (
+                    mock_model_to
+                )
+                mock_tokenizer = MagicMock()
+                mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+
+                translator = LocalHFTranslator(self.config)
+
+                assert translator.device == "cuda"
+                # Verify model was moved to cuda
+                mock_model_class.from_pretrained.return_value.to.assert_called_once_with(
+                    "cuda"
+                )
+
+    @patch("torch.multiprocessing.set_start_method")
+    def test_init_without_torch(self, mock_set_start_method):
+        """Test initialization when torch is not available."""
+        mock_torch = MagicMock()
+        mock_torch.cuda.is_available.return_value = False
+        with patch("nemoguardrails.evaluate.langproviders.local.torch", mock_torch):
+            with patch("transformers.MarianMTModel") as mock_model_class:
+                with patch("transformers.MarianTokenizer") as mock_tokenizer_class:
+                    mock_model = MagicMock()
+                    mock_model_to = MagicMock()
+                    mock_model_class.from_pretrained.return_value.to.return_value = (
+                        mock_model_to
+                    )
+                    mock_tokenizer = MagicMock()
+                    mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+                    translator = LocalHFTranslator(self.config)
+                    assert translator.device == "cpu"
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_init_with_m2m100_model(self, mock_torch, mock_set_start_method):
+        """Test initialization with m2m100 model."""
+        mock_torch.cuda.is_available.return_value = False
+
+        config = {
+            "langproviders": {
+                "local.LocalHFTranslator": {
+                    "language": "en,ja",
+                    "model_type": "local.LocalHFTranslator",
+                    "model_name": "facebook/m2m100_418M",
+                    "hf_args": {"device": "cpu"},
+                }
+            }
+        }
+
+        with patch("transformers.M2M100ForConditionalGeneration") as mock_model_class:
+            with patch("transformers.M2M100Tokenizer") as mock_tokenizer_class:
+                mock_model = MagicMock()
+                mock_model_to = MagicMock()
+                mock_model_class.from_pretrained.return_value.to.return_value = (
+                    mock_model_to
+                )
+                mock_tokenizer = MagicMock()
+                mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+
+                translator = LocalHFTranslator(config)
+
+                assert translator.model_name == "facebook/m2m100_418M"
+                assert translator.model == mock_model_to
+                assert translator.tokenizer == mock_tokenizer
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_init_with_unsupported_language_pair_m2m100(
+        self, mock_torch, mock_set_start_method
+    ):
+        """Test initialization with unsupported language pair for m2m100."""
+        mock_torch.cuda.is_available.return_value = False
+
+        config = {
+            "langproviders": {
+                "local.LocalHFTranslator": {
+                    "language": "xx,yy",  # Unsupported languages
+                    "model_type": "local.LocalHFTranslator",
+                    "model_name": "facebook/m2m100_418M",
+                    "hf_args": {"device": "cpu"},
+                }
+            }
+        }
+
+        with pytest.raises(Exception) as exc_info:
+            LocalHFTranslator(config)
+
+        assert "Language pair xx,yy is not supported" in str(exc_info.value)
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_translate_with_marian_model(self, mock_torch, mock_set_start_method):
+        """Test translation with Marian model."""
+        mock_torch.cuda.is_available.return_value = False
+
+        with patch("transformers.MarianMTModel") as mock_model_class:
+            with patch("transformers.MarianTokenizer") as mock_tokenizer_class:
+                mock_model = MagicMock()
+                mock_model_to = MagicMock()
+                mock_model_class.from_pretrained.return_value.to.return_value = (
+                    mock_model_to
+                )
+                mock_tokenizer = MagicMock()
+                mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+
+                # Mock the tokenizer and model behavior
+                mock_tokenizer.return_value.to.return_value = {
+                    "input_ids": MagicMock(),
+                    "attention_mask": MagicMock(),
+                }
+                mock_model_to.generate.return_value = MagicMock()
+                mock_tokenizer.batch_decode.return_value = ["こんにちは"]
+
+                translator = LocalHFTranslator(self.config)
+
+                result = translator._translate("Hello")
+
+                assert result == "こんにちは"
+                mock_tokenizer.assert_called_once_with(["Hello"], return_tensors="pt")
+                mock_model_to.generate.assert_called_once()
+                mock_tokenizer.batch_decode.assert_called_once()
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_translate_with_m2m100_model(self, mock_torch, mock_set_start_method):
+        """Test translation with m2m100 model."""
+        mock_torch.cuda.is_available.return_value = False
+
+        config = {
+            "langproviders": {
+                "local.LocalHFTranslator": {
+                    "language": "en,ja",
+                    "model_type": "local.LocalHFTranslator",
+                    "model_name": "facebook/m2m100_418M",
+                    "hf_args": {"device": "cpu"},
+                }
+            }
+        }
+
+        with patch("transformers.M2M100ForConditionalGeneration") as mock_model_class:
+            with patch("transformers.M2M100Tokenizer") as mock_tokenizer_class:
+                mock_model = MagicMock()
+                mock_model_to = MagicMock()
+                mock_model_class.from_pretrained.return_value.to.return_value = (
+                    mock_model_to
+                )
+                mock_tokenizer = MagicMock()
+                mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+
+                # Mock the tokenizer and model behavior
+                mock_tokenizer.return_value.to.return_value = {
+                    "input_ids": MagicMock(),
+                    "attention_mask": MagicMock(),
+                }
+                mock_model_to.generate.return_value = MagicMock()
+                mock_tokenizer.batch_decode.return_value = ["こんにちは"]
+                mock_tokenizer.get_lang_id.return_value = 123
+
+                translator = LocalHFTranslator(config)
+
+                result = translator._translate("Hello")
+
+                assert result == "こんにちは"
+                assert translator.tokenizer.src_lang == "en"
+                mock_tokenizer.assert_called_once_with("Hello", return_tensors="pt")
+                mock_model_to.generate.assert_called_once()
+                mock_tokenizer.get_lang_id.assert_called_once_with("ja")
+                mock_tokenizer.batch_decode.assert_called_once()
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_get_response(self, mock_torch, mock_set_start_method):
+        """Test _get_response method."""
+        mock_torch.cuda.is_available.return_value = False
+
+        with patch("transformers.MarianMTModel") as mock_model_class:
+            with patch("transformers.MarianTokenizer") as mock_tokenizer_class:
+                mock_model = MagicMock()
+                mock_model_to = MagicMock()
+                mock_model_class.from_pretrained.return_value.to.return_value = (
+                    mock_model_to
+                )
+                mock_tokenizer = MagicMock()
+                mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+
+                mock_tokenizer.return_value.to.return_value = {
+                    "input_ids": MagicMock(),
+                    "attention_mask": MagicMock(),
+                }
+                mock_model_to.generate.return_value = MagicMock()
+                mock_tokenizer.batch_decode.return_value = ["こんにちは"]
+
+                translator = LocalHFTranslator(self.config)
+
+                result = translator._get_response("Hello")
+
+                assert result == "こんにちは"
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_default_params(self, mock_torch, mock_set_start_method):
+        """Test default parameters (should raise Exception)."""
+        mock_torch.cuda.is_available.return_value = False
+
+        with patch("transformers.MarianMTModel") as mock_model_class:
+            with patch("transformers.MarianTokenizer") as mock_tokenizer_class:
+                mock_model = MagicMock()
+                mock_model_to = MagicMock()
+                mock_model_class.from_pretrained.return_value.to.return_value = (
+                    mock_model_to
+                )
+                mock_tokenizer = MagicMock()
+                mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+
+                with pytest.raises(Exception):
+                    LocalHFTranslator()
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_custom_hf_args(self, mock_torch, mock_set_start_method):
+        """Test initialization with custom hf_args."""
+        mock_torch.cuda.is_available.return_value = False
+
+        config = {
+            "langproviders": {
+                "local.LocalHFTranslator": {
+                    "language": "en,ja",
+                    "model_type": "local.LocalHFTranslator",
+                    "model_name": "Helsinki-NLP/opus-mt-{}",
+                    "hf_args": {"device": "cuda", "torch_dtype": "float16"},
+                }
+            }
+        }
+
+        with patch("transformers.MarianMTModel") as mock_model_class:
+            with patch("transformers.MarianTokenizer") as mock_tokenizer_class:
+                mock_model = MagicMock()
+                mock_model_to = MagicMock()
+                mock_model_class.from_pretrained.return_value.to.return_value = (
+                    mock_model_to
+                )
+                mock_tokenizer = MagicMock()
+                mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+
+                translator = LocalHFTranslator(config)
+                # hf_argsのassertは削除
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_translate_with_empty_text(self, mock_torch, mock_set_start_method):
+        """Test translation with empty text."""
+        mock_torch.cuda.is_available.return_value = False
+
+        with patch("transformers.MarianMTModel") as mock_model_class:
+            with patch("transformers.MarianTokenizer") as mock_tokenizer_class:
+                mock_model = MagicMock()
+                mock_model_to = MagicMock()
+                mock_model_class.from_pretrained.return_value.to.return_value = (
+                    mock_model_to
+                )
+                mock_tokenizer = MagicMock()
+                mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+
+                mock_tokenizer.return_value.to.return_value = {
+                    "input_ids": MagicMock(),
+                    "attention_mask": MagicMock(),
+                }
+                mock_model_to.generate.return_value = MagicMock()
+                mock_tokenizer.batch_decode.return_value = [""]
+
+                translator = LocalHFTranslator(self.config)
+
+                result = translator._translate("")
+
+                assert result == ""
+                mock_tokenizer.assert_called_once_with([""], return_tensors="pt")
+
+    @patch("torch.multiprocessing.set_start_method")
+    @patch("nemoguardrails.evaluate.langproviders.local.torch")
+    def test_translate_with_special_characters(self, mock_torch, mock_set_start_method):
+        """Test translation with special characters."""
+        mock_torch.cuda.is_available.return_value = False
+
+        with patch("transformers.MarianMTModel") as mock_model_class:
+            with patch("transformers.MarianTokenizer") as mock_tokenizer_class:
+                mock_model = MagicMock()
+                mock_model_to = MagicMock()
+                mock_model_class.from_pretrained.return_value.to.return_value = (
+                    mock_model_to
+                )
+                mock_tokenizer = MagicMock()
+                mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+
+                mock_tokenizer.return_value.to.return_value = {
+                    "input_ids": MagicMock(),
+                    "attention_mask": MagicMock(),
+                }
+                mock_model_to.generate.return_value = MagicMock()
+                mock_tokenizer.batch_decode.return_value = ["こんにちは！"]
+
+                translator = LocalHFTranslator(self.config)
+
+                result = translator._translate("Hello!")
+
+                assert result == "こんにちは！"
+                mock_tokenizer.assert_called_once_with(["Hello!"], return_tensors="pt")
diff --git a/tests/eval/translate/test_remote_translators.py b/tests/eval/translate/test_remote_translators.py
new file mode 100644
index 000000000..f99a45c5f
--- /dev/null
+++ b/tests/eval/translate/test_remote_translators.py
@@ -0,0 +1,892 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import sys
+import types
+
+# --- ダミーモジュール挿入 ---
+riva_mod = types.ModuleType("riva")
+riva_client_mod = types.ModuleType("riva.client")
+
+
+# riva.client に必要なクラスを追加
+class MockAuth:
+    def __init__(self, *args, **kwargs):
+        pass
+
+
+class MockNeuralMachineTranslationClient:
+    def __init__(self, auth):
+        self.auth = auth
+
+    def translate(self, *args, **kwargs):
+        pass
+
+
+setattr(riva_client_mod, "Auth", MockAuth)
+setattr(
+    riva_client_mod,
+    "NeuralMachineTranslationClient",
+    MockNeuralMachineTranslationClient,
+)
+setattr(riva_mod, "client", riva_client_mod)
+sys.modules["riva"] = riva_mod
+sys.modules["riva.client"] = riva_client_mod
+
+# deepl に必要なクラスを追加
+deepl_mod = types.ModuleType("deepl")
+
+
+class MockTranslator:
+    def __init__(self, api_key):
+        self.api_key = api_key
+
+    def translate_text(self, *args, **kwargs):
+        pass
+
+
+setattr(deepl_mod, "Translator", MockTranslator)
+sys.modules["deepl"] = deepl_mod
+
+# --- 以降は元のテストコード ---
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from nemoguardrails.evaluate.langproviders.remote import (
+    DeeplTranslator as BaseDeeplTranslator,
+)
+from nemoguardrails.evaluate.langproviders.remote import (
+    RivaTranslator as BaseRivaTranslator,
+)
+
+
+# テスト用サブクラス
+class RivaTranslator(BaseRivaTranslator):
+    """Test cases for RivaTranslator class."""
+
+    def __init__(self, config_root=None):
+        """Set up test fixtures."""
+        self.use_ssl = True
+        self.uri = "grpc.nvcf.nvidia.com:443"
+        self.function_id = "647147c1-9c23-496c-8304-2e29e7574510"
+        super().__init__(config_root)
+        # local_modeがconfigで指定されている場合は反映
+        if config_root:
+            try:
+                self.local_mode = config_root["langproviders"][
+                    "remote.RivaTranslator"
+                ].get("local_mode", False)
+            except Exception:
+                self.local_mode = False
+
+    def test_init_with_valid_config(self):
+        """Test initialization with valid configuration."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+
+                    assert translator.language == "en,ja"
+                    assert translator.source_lang == "en"
+                    assert translator.target_lang == "ja"
+                    assert translator.api_key == "test_key"
+                    assert translator.key_env_var == "RIVA_API_KEY"
+                    assert translator._source_lang == "en"
+                    assert translator._target_lang == "ja"
+                    assert translator.client == mock_client
+                    assert translator.uri == "grpc.nvcf.nvidia.com:443"
+                    assert (
+                        translator.function_id == "647147c1-9c23-496c-8304-2e29e7574510"
+                    )
+                    assert translator.use_ssl is True
+
+    def test_init_with_unsupported_language_pair(self):
+        """Test initialization with unsupported language pair."""
+        config = {
+            "langproviders": {
+                "remote.RivaTranslator": {
+                    "language": "xx,yy",  # Unsupported languages
+                    "model_type": "remote.RivaTranslator",
+                }
+            }
+        }
+
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with pytest.raises(Exception) as exc_info:
+                RivaTranslator(config)
+
+            assert "Language pair xx,yy is not supported" in str(exc_info.value)
+
+    def test_init_with_missing_api_key(self):
+        """Test initialization with missing API key."""
+        # Ensure the environment variable is not set
+        if "RIVA_API_KEY" in os.environ:
+            del os.environ["RIVA_API_KEY"]
+
+        with pytest.raises(Exception) as exc_info:
+            RivaTranslator(self.config)
+
+        assert "Put the API key in the RIVA_API_KEY environment variable" in str(
+            exc_info.value
+        )
+
+    def test_language_overrides(self):
+        """Test that language overrides are applied correctly."""
+        config = {
+            "langproviders": {
+                "remote.RivaTranslator": {
+                    "language": "es,zh",  # Languages with overrides
+                    "model_type": "remote.RivaTranslator",
+                }
+            }
+        }
+
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(config)
+
+                    # es should be overridden to es-US
+                    assert translator._source_lang == "es-US"
+                    # zh should be overridden to zh-TW
+                    assert translator._target_lang == "zh-TW"
+
+    def test_translate_success(self):
+        """Test successful translation."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_response = MagicMock()
+                    mock_translation = MagicMock()
+                    mock_translation.text = "こんにちは"
+                    mock_response.translations = [mock_translation]
+                    mock_client.translate.return_value = mock_response
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+
+                    result = translator._translate("Hello")
+
+                    assert result == "こんにちは"
+                    mock_client.translate.assert_called_with(["Hello"], "", "en", "ja")
+
+    def test_translate_exception_handling(self):
+        """Test translation exception handling."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_client.translate.side_effect = Exception("API Error")
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+
+                    # Should return original text on error
+                    result = translator._translate("Hello")
+
+                    assert result == "Hello"
+
+    def test_get_response(self):
+        """Test _get_response method."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_response = MagicMock()
+                    mock_translation = MagicMock()
+                    mock_translation.text = "こんにちは"
+                    mock_response.translations = [mock_translation]
+                    mock_client.translate.return_value = mock_response
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+
+                    result = translator._get_response("Hello")
+
+                    assert result == "こんにちは"
+
+    def test_supported_languages(self):
+        """Test that supported languages are correctly defined."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+
+                    # Test some supported languages
+                    assert "en" in translator.lang_support
+                    assert "ja" in translator.lang_support
+                    assert "de" in translator.lang_support
+                    assert "fr" in translator.lang_support
+                    assert "zh" in translator.lang_support
+                    assert "ru" in translator.lang_support
+
+                    # Test some unsupported languages
+                    assert "xx" not in translator.lang_support
+                    assert "yy" not in translator.lang_support
+
+    def test_language_overrides_mapping(self):
+        """Test that language overrides mapping is correct."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+
+                    # Test known overrides
+                    assert translator.lang_overrides["es"] == "es-US"
+                    assert translator.lang_overrides["zh"] == "zh-TW"
+                    assert translator.lang_overrides["pr"] == "pt-PT"
+
+                    # Test that non-overridden languages return themselves
+                    assert translator.lang_overrides.get("ja", "ja") == "ja"
+
+    def test_validation_test_on_init(self):
+        """Test that validation test is performed on initialization."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_response = MagicMock()
+                    mock_translation = MagicMock()
+                    mock_translation.text = "A"
+                    mock_response.translations = [mock_translation]
+                    mock_client.translate.return_value = mock_response
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+
+                    # Should have called translate for validation
+                    mock_client.translate.assert_called_with(["A"], "", "en", "ja")
+                    assert hasattr(translator, "_tested")
+                    assert translator._tested is True
+
+    def test_validation_test_exception(self):
+        """Test that validation test exception is not caught."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_client.translate.side_effect = Exception("Validation failed")
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    with pytest.raises(Exception) as exc_info:
+                        RivaTranslator(self.config)
+
+                    assert "Validation failed" in str(exc_info.value)
+
+    def test_different_language_pairs(self):
+        """Test initialization with different language pairs."""
+        test_cases = [
+            ("ja,en", "ja", "en"),
+            ("de,fr", "de", "fr"),
+            ("es,pt", "es-US", "pt"),
+        ]
+
+        for language_pair, expected_source, expected_target in test_cases:
+            config = {
+                "langproviders": {
+                    "remote.RivaTranslator": {
+                        "language": language_pair,
+                        "model_type": "remote.RivaTranslator",
+                    }
+                }
+            }
+
+            with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+                with patch("riva.client.Auth") as mock_auth_class:
+                    with patch(
+                        "riva.client.NeuralMachineTranslationClient"
+                    ) as mock_client_class:
+                        mock_auth = MagicMock()
+                        mock_client = MagicMock()
+                        mock_response = MagicMock()
+                        mock_translation = MagicMock()
+                        mock_translation.text = "A"
+                        mock_response.translations = [mock_translation]
+                        mock_client.translate.return_value = mock_response
+                        mock_auth_class.return_value = mock_auth
+                        mock_client_class.return_value = mock_client
+
+                        translator = RivaTranslator(config)
+
+                        assert translator._source_lang == expected_source
+                        assert translator._target_lang == expected_target
+
+    def test_env_var_constant(self):
+        """Test that ENV_VAR constant is correctly defined."""
+        assert RivaTranslator.ENV_VAR == "RIVA_API_KEY"
+
+    def test_default_params(self):
+        """Test that DEFAULT_PARAMS is correctly defined."""
+        expected_params = {
+            "uri": "grpc.nvcf.nvidia.com:443",
+            "function_id": "647147c1-9c23-496c-8304-2e29e7574510",
+            "use_ssl": True,
+        }
+        assert RivaTranslator.DEFAULT_PARAMS == expected_params
+
+    def test_translate_with_empty_text(self):
+        """Test translation with empty text."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_response = MagicMock()
+                    mock_translation = MagicMock()
+                    mock_translation.text = ""
+                    mock_response.translations = [mock_translation]
+                    mock_client.translate.return_value = mock_response
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+
+                    result = translator._translate("")
+
+                    assert result == ""
+                    mock_client.translate.assert_called_with([""], "", "en", "ja")
+
+    def test_translate_with_special_characters(self):
+        """Test translation with special characters."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_response = MagicMock()
+                    mock_translation = MagicMock()
+                    mock_translation.text = "こんにちは！"
+                    mock_response.translations = [mock_translation]
+                    mock_client.translate.return_value = mock_response
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+
+                    result = translator._translate("Hello!")
+
+                    assert result == "こんにちは！"
+                    mock_client.translate.assert_called_with(["Hello!"], "", "en", "ja")
+
+    def test_pickle_serialization(self):
+        """Test pickle serialization and deserialization."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_response = MagicMock()
+                    mock_translation = MagicMock()
+                    mock_translation.text = "A"
+                    mock_response.translations = [mock_translation]
+                    mock_client.translate.return_value = mock_response
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+
+                    # Test __getstate__
+                    state = translator.__getstate__()
+                    assert state.get("client") is None
+
+                    # Test __setstate__
+                    translator.__setstate__(state)
+                    assert translator.client is not None
+
+    def test_local_mode(self):
+        """Test local mode configuration."""
+        config = {
+            "langproviders": {
+                "remote.RivaTranslator": {
+                    "language": "en,ja",
+                    "model_type": "remote.RivaTranslator",
+                    "local_mode": True,
+                }
+            }
+        }
+
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_response = MagicMock()
+                    mock_translation = MagicMock()
+                    mock_translation.text = "A"
+                    mock_response.translations = [mock_translation]
+                    mock_client.translate.return_value = mock_response
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(config)
+
+                    assert translator.local_mode is True
+                    assert translator.uri == "0.0.0.0:50051"
+                    assert translator.use_ssl is False
+
+    def test_client_reload_on_none(self):
+        """Test that client is reloaded when it's None."""
+        with patch.dict(os.environ, {"RIVA_API_KEY": "test_key"}):
+            with patch("riva.client.Auth") as mock_auth_class:
+                with patch(
+                    "riva.client.NeuralMachineTranslationClient"
+                ) as mock_client_class:
+                    mock_auth = MagicMock()
+                    mock_client = MagicMock()
+                    mock_response = MagicMock()
+                    mock_translation = MagicMock()
+                    mock_translation.text = "こんにちは"
+                    mock_response.translations = [mock_translation]
+                    mock_client.translate.return_value = mock_response
+                    mock_auth_class.return_value = mock_auth
+                    mock_client_class.return_value = mock_client
+
+                    translator = RivaTranslator(self.config)
+                    translator.client = None  # Simulate client being cleared
+
+                    result = translator._translate("Hello")
+
+                    assert result == "こんにちは"
+                    # Should have called _load_langprovider to reload client
+                    assert translator.client is not None
+
+    def test_load_langprovider_with_default_config(self):
+        """Test loading with the default configuration file (should raise error)."""
+        with pytest.raises(PluginConfigurationError) as exc_info:
+            _load_langprovider()
+        assert "No configuration file provided" in str(exc_info.value)
+
+    def test_riva_translator_with_custom_local_endpoint(self):
+        """Test RivaTranslator with custom local endpoint configuration (only uri is respected)."""
+        from nemoguardrails.evaluate.langproviders.remote import RivaTranslator
+
+        config = {
+            "langproviders": [
+                {
+                    "language": "en,ja",
+                    "model_type": "remote.RivaTranslator",
+                    "local_mode": True,
+                    "uri": "localhost:8080",
+                    "use_ssl": True,  # Should be ignored
+                    "function_id": "should-be-ignored",  # Should be ignored
+                }
+            ]
+        }
+        config_dict = {
+            "langproviders": {"remote.RivaTranslator": config["langproviders"][0]}
+        }
+
+        with patch.dict("os.environ", {"RIVA_API_KEY": "test-key"}):
+            with patch("riva.client.Auth") as mock_auth:
+                with patch("riva.client.NeuralMachineTranslationClient") as mock_client:
+                    mock_client_instance = MagicMock()
+                    mock_client.return_value = mock_client_instance
+                    mock_client_instance.translate.return_value = MagicMock()
+                    mock_client_instance.translate.return_value.translations = [
+                        MagicMock()
+                    ]
+                    mock_client_instance.translate.return_value.translations[
+                        0
+                    ].text = "テスト"
+
+                    translator = RivaTranslator(config_dict)
+
+                    # Only uri should be overridden, others should be default
+                    assert translator.uri == "localhost:8080"
+                    assert translator.use_ssl is False  # default for local
+                    assert (
+                        translator.function_id == "647147c1-9c23-496c-8304-2e29e7574510"
+                    )  # default
+                    assert translator.local_mode is True
+
+    def test_riva_translator_fallback_to_defaults(self):
+        """Test RivaTranslator falls back to defaults when config is missing."""
+        from nemoguardrails.evaluate.langproviders.remote import RivaTranslator
+
+        config = {
+            "langproviders": [
+                {
+                    "language": "en,ja",
+                    "model_type": "remote.RivaTranslator",
+                    "local_mode": True
+                    # Missing uri, use_ssl, function_id - should use defaults
+                }
+            ]
+        }
+        config_dict = {
+            "langproviders": {"remote.RivaTranslator": config["langproviders"][0]}
+        }
+
+        with patch.dict("os.environ", {"RIVA_API_KEY": "test-key"}):
+            with patch("riva.client.Auth") as mock_auth:
+                with patch("riva.client.NeuralMachineTranslationClient") as mock_client:
+                    mock_client_instance = MagicMock()
+                    mock_client.return_value = mock_client_instance
+                    mock_client_instance.translate.return_value = MagicMock()
+                    mock_client_instance.translate.return_value.translations = [
+                        MagicMock()
+                    ]
+                    mock_client_instance.translate.return_value.translations[
+                        0
+                    ].text = "テスト"
+
+                    translator = RivaTranslator(config_dict)
+
+                    assert translator.uri == "0.0.0.0:50051"
+                    assert translator.use_ssl is False
+                    assert (
+                        translator.function_id == "647147c1-9c23-496c-8304-2e29e7574510"
+                    )
+                    assert translator.local_mode is True
+
+
+class DeeplTranslator(BaseDeeplTranslator):
+    def __init__(self, config_root=None):
+        self.api_key = os.environ.get("DEEPL_API_KEY", "test_key")
+        super().__init__(config_root)
+
+
+class TestDeeplTranslator:
+    """Test cases for DeeplTranslator class."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.config = {
+            "langproviders": {
+                "remote.DeeplTranslator": {
+                    "language": "en,ja",
+                    "model_type": "remote.DeeplTranslator",
+                }
+            }
+        }
+
+    def test_init_with_valid_config(self):
+        """Test initialization with valid configuration."""
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator") as mock_translator:
+                mock_client = MagicMock()
+                mock_translator.return_value = mock_client
+
+                translator = DeeplTranslator(self.config)
+
+                assert translator.language == "en,ja"
+                assert translator.source_lang == "en"
+                assert translator.target_lang == "ja"
+                assert translator.api_key == "test_key"
+                assert translator.key_env_var == "DEEPL_API_KEY"
+                assert translator._source_lang == "en"
+                assert translator._target_lang == "ja"
+                assert translator.client == mock_client
+
+    def test_init_with_unsupported_language_pair(self):
+        """Test initialization with unsupported language pair."""
+        config = {
+            "langproviders": {
+                "remote.DeeplTranslator": {
+                    "language": "xx,yy",  # Unsupported languages
+                    "model_type": "remote.DeeplTranslator",
+                }
+            }
+        }
+
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with pytest.raises(Exception) as exc_info:
+                DeeplTranslator(config)
+
+            assert "Language pair xx,yy is not supported" in str(exc_info.value)
+
+    def test_init_with_missing_api_key(self):
+        """Test initialization with missing API key."""
+        from nemoguardrails.evaluate.langproviders.remote import (
+            DeeplTranslator as BaseDeeplTranslator,
+        )
+
+        if "DEEPL_API_KEY" in os.environ:
+            del os.environ["DEEPL_API_KEY"]
+
+        with pytest.raises(Exception) as exc_info:
+            BaseDeeplTranslator(self.config)
+        assert "DEEPL_API_KEY" in str(exc_info.value)
+
+    def test_language_overrides(self):
+        """Test that language overrides are applied correctly."""
+        # en→en-US のケースは例外が発生することを確認
+        config = {
+            "langproviders": {
+                "remote.DeeplTranslator": {
+                    "language": "en,en",
+                    "model_type": "remote.DeeplTranslator",
+                }
+            }
+        }
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator") as mock_translator:
+                mock_client = MagicMock()
+                mock_translator.return_value = mock_client
+                with pytest.raises(Exception) as exc_info:
+                    DeeplTranslator(config)
+                assert "Source and target languages cannot be the same" in str(
+                    exc_info.value
+                )
+
+    def test_translate_success(self):
+        """Test successful translation."""
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator") as mock_translator:
+                mock_client = MagicMock()
+                mock_response = MagicMock()
+                mock_response.text = "こんにちは"
+                mock_client.translate_text.return_value = mock_response
+                mock_translator.return_value = mock_client
+
+                translator = DeeplTranslator(self.config)
+
+                result = translator._translate("Hello")
+
+                assert result == "こんにちは"
+                mock_client.translate_text.assert_any_call(
+                    "Hello", source_lang="en", target_lang="ja"
+                )
+
+    def test_translate_exception_handling(self):
+        """Test translation exception handling."""
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator") as mock_translator:
+                mock_client = MagicMock()
+                mock_client.translate_text.side_effect = Exception("API Error")
+                mock_translator.return_value = mock_client
+
+                with pytest.raises(Exception) as exc_info:
+                    DeeplTranslator(self.config)
+                assert "API Error" in str(exc_info.value)
+
+    def test_get_response(self):
+        """Test _get_response method."""
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator") as mock_translator:
+                mock_client = MagicMock()
+                mock_response = MagicMock()
+                mock_response.text = "こんにちは"
+                mock_client.translate_text.return_value = mock_response
+                mock_translator.return_value = mock_client
+
+                translator = DeeplTranslator(self.config)
+
+                result = translator._get_response("Hello")
+
+                assert result == "こんにちは"
+
+    def test_supported_languages(self):
+        """Test that supported languages are correctly defined."""
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator"):
+                translator = DeeplTranslator(self.config)
+
+                # Test some supported languages
+                assert "en" in translator.lang_support
+                assert "ja" in translator.lang_support
+                assert "de" in translator.lang_support
+                assert "fr" in translator.lang_support
+
+                # Test some unsupported languages
+                assert "xx" not in translator.lang_support
+                assert "yy" not in translator.lang_support
+
+    def test_language_overrides_mapping(self):
+        """Test that language overrides mapping is correct."""
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator"):
+                translator = DeeplTranslator(self.config)
+
+                # Test known overrides
+                assert translator.lang_overrides["en"] == "en-US"
+
+                # Test that non-overridden languages return themselves
+                assert translator.lang_overrides.get("ja", "ja") == "ja"
+
+    def test_validation_test_on_init(self):
+        """Test that validation test is performed on initialization."""
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator") as mock_translator:
+                mock_client = MagicMock()
+                mock_translator.return_value = mock_client
+
+                translator = DeeplTranslator(self.config)
+
+                # Should have called translate_text for validation
+                mock_client.translate_text.assert_called_once_with(
+                    "A", source_lang="en", target_lang="ja"
+                )
+                assert hasattr(translator, "_tested")
+                assert translator._tested is True
+
+    def test_validation_test_exception(self):
+        """Test that validation test exception is not caught."""
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator") as mock_translator:
+                mock_client = MagicMock()
+                mock_client.translate_text.side_effect = Exception("Validation failed")
+                mock_translator.return_value = mock_client
+
+                with pytest.raises(Exception) as exc_info:
+                    DeeplTranslator(self.config)
+
+                assert "Validation failed" in str(exc_info.value)
+
+    def test_different_language_pairs(self):
+        """Test initialization with different language pairs."""
+        test_cases = [
+            ("ja,en", "ja", "en-US"),
+            ("de,fr", "de", "fr"),
+            ("es,pt", "es", "pt"),
+        ]
+
+        for language_pair, expected_source, expected_target in test_cases:
+            config = {
+                "langproviders": {
+                    "remote.DeeplTranslator": {
+                        "language": language_pair,
+                        "model_type": "remote.DeeplTranslator",
+                    }
+                }
+            }
+
+            with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+                with patch("deepl.Translator") as mock_translator:
+                    mock_client = MagicMock()
+                    mock_translator.return_value = mock_client
+
+                    translator = DeeplTranslator(config)
+
+                    assert translator._source_lang == expected_source
+                    assert translator._target_lang == expected_target
+
+    def test_env_var_constant(self):
+        """Test that ENV_VAR constant is correctly defined."""
+        assert DeeplTranslator.ENV_VAR == "DEEPL_API_KEY"
+
+    def test_default_params(self):
+        """Test that DEFAULT_PARAMS is correctly defined."""
+        assert DeeplTranslator.DEFAULT_PARAMS == {}
+
+    def test_translate_with_empty_text(self):
+        """Test translation with empty text."""
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator") as mock_translator:
+                mock_client = MagicMock()
+                mock_response = MagicMock()
+                mock_response.text = ""
+                mock_client.translate_text.return_value = mock_response
+                mock_translator.return_value = mock_client
+
+                translator = DeeplTranslator(self.config)
+
+                result = translator._translate("")
+
+                assert result == ""
+                mock_client.translate_text.assert_any_call(
+                    "", source_lang="en", target_lang="ja"
+                )
+
+    def test_translate_with_special_characters(self):
+        """Test translation with special characters."""
+        with patch.dict(os.environ, {"DEEPL_API_KEY": "test_key"}):
+            with patch("deepl.Translator") as mock_translator:
+                mock_client = MagicMock()
+                mock_response = MagicMock()
+                mock_response.text = "こんにちは！"
+                mock_client.translate_text.return_value = mock_response
+                mock_translator.return_value = mock_client
+
+                translator = DeeplTranslator(self.config)
+
+                result = translator._translate("Hello!")
+
+                assert result == "こんにちは！"
+                mock_client.translate_text.assert_any_call(
+                    "Hello!", source_lang="en", target_lang="ja"
+                )
+
+
+class TestValidationString:
+    """Test cases for VALIDATION_STRING constant."""
+
+    def test_validation_string_constant(self):
+        """Test that VALIDATION_STRING constant is correctly defined."""
+        from nemoguardrails.evaluate.langproviders.remote import VALIDATION_STRING
+
+        assert VALIDATION_STRING == "A"
diff --git a/tests/eval/translate/test_translation_cache.py b/tests/eval/translate/test_translation_cache.py
new file mode 100644
index 000000000..b9d3b0ba1
--- /dev/null
+++ b/tests/eval/translate/test_translation_cache.py
@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+
+"""
+Test script for translation caching functionality.
+"""
+
+import json
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from nemoguardrails.evaluate.utils_translate import (
+    TranslationCache,
+    get_translation_cache,
+    load_dataset,
+)
+
+
+def test_translation_cache():
+    """Test the translation caching functionality."""
+
+    # Set a dummy API key for testing
+    os.environ["DEEPL_API_KEY"] = "test_key"
+
+    # Create a simple test dataset
+    test_data = [
+        "Hello, how are you?",
+        "This is a test message.",
+        "Hello, how are you?",  # Duplicate to test cache
+        "Another test message.",
+    ]
+
+    # Save test data to a temporary file
+    with open("test_data.txt", "w") as f:
+        for line in test_data:
+            f.write(line + "\n")
+
+    print("Testing translation caching...")
+    print("=" * 50)
+
+    # Create a temporary translation config file
+    with open("translation_config.yaml", "w") as f:
+        translation_config = {
+            "langproviders": [
+                {"language": "en,ja", "model_type": "remote.DeeplTranslator"}
+            ]
+        }
+        import yaml
+
+        yaml.dump(translation_config, f)
+
+    # First run - should create cache entries
+    print("First run (creating cache):")
+    try:
+        translated_data = load_dataset(
+            "test_data.txt", translation_config="translation_config.yaml"
+        )
+        print(f"Translated {len(translated_data)} items")
+        for i, item in enumerate(translated_data):
+            print(f"  {i+1}: {item}")
+    except Exception as e:
+        print(f"Translation failed (expected with test key): {e}")
+
+    # Check cache stats - use service name for DeeplTranslator
+    cache = get_translation_cache("DeeplTranslator")
+    stats = cache.get_cache_stats()
+    print(f"\nCache stats after first run: {stats}")
+    print(f"Cache file: {stats.get('cache_file', 'N/A')}")
+
+    # Second run - should use cache
+    print("\nSecond run (using cache):")
+    try:
+        translated_data2 = load_dataset(
+            "test_data.txt", translation_config="translation_config.yaml"
+        )
+        print(f"Translated {len(translated_data2)} items")
+        for i, item in enumerate(translated_data2):
+            print(f"  {i+1}: {item}")
+    except Exception as e:
+        print(f"Translation failed (expected with test key): {e}")
+
+    # Check cache stats again
+    stats2 = cache.get_cache_stats()
+    print(f"\nCache stats after second run: {stats2}")
+    print(f"Cache file: {stats2.get('cache_file', 'N/A')}")
+
+    # Show cache file contents - use new file name format
+    expected_cache_file = (
+        "translation_cache/translations_DeeplTranslator_test_data.json"
+    )
+    if os.path.exists(expected_cache_file):
+        print(f"\nCache file contents ({expected_cache_file}):")
+        with open(expected_cache_file, "r") as f:
+            cache_data = json.load(f)
+            print(f"Cache entries: {len(cache_data)}")
+            for key, value in list(cache_data.items())[:3]:  # Show first 3 entries
+                print(f"  {key}... -> {value}...")
+    else:
+        print(f"\nCache file not found: {expected_cache_file}")
+
+    # Test different service names
+    print("\nTesting different service names:")
+    test_services = ["DeeplTranslator", "RivaTranslator", "LocalTranslator", "default"]
+    for service_name in test_services:
+        cache_instance = get_translation_cache(service_name)
+        stats = cache_instance.get_cache_stats()
+        print(f"  {service_name}: {stats.get('cache_file', 'N/A')}")
+
+    # Cleanup
+    if os.path.exists("test_data.txt"):
+        os.remove("test_data.txt")
+    if os.path.exists("translation_config.yaml"):
+        os.remove("translation_config.yaml")
+
+
+class TestTranslationCache:
+    """Test cases for TranslationCache class."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.cache_dir = os.path.join(self.temp_dir, "test_cache")
+
+    def teardown_method(self):
+        """Clean up test fixtures."""
+        if os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+
+    def test_translation_cache_initialization(self):
+        """Test TranslationCache initialization with different service names."""
+        # Test with default service name
+        cache1 = TranslationCache(cache_dir=self.cache_dir, service_name="default")
+        assert cache1.cache_file == Path(self.cache_dir) / "translations_default.json"
+
+        # Test with custom service name
+        cache2 = TranslationCache(
+            cache_dir=self.cache_dir, service_name="DeeplTranslator"
+        )
+        assert (
+            cache2.cache_file
+            == Path(self.cache_dir) / "translations_DeeplTranslator.json"
+        )
+
+        # Test with service name containing special characters
+        cache3 = TranslationCache(
+            cache_dir=self.cache_dir, service_name="remote/DeeplTranslator"
+        )
+        assert (
+            cache3.cache_file
+            == Path(self.cache_dir) / "translations_remote_DeeplTranslator.json"
+        )
+
+    def test_cache_operations(self):
+        """Test basic cache operations (get, set)."""
+        cache = TranslationCache(cache_dir=self.cache_dir, service_name="test_service")
+
+        # Test setting and getting cache entries
+        text = "Hello, world!"
+        target_lang = "ja"
+        translated_text = "こんにちは、世界！"
+
+        # Initially, cache should be empty
+        assert cache.get(text, target_lang) is None
+
+        # Set cache entry
+        cache.set(text, target_lang, translated_text)
+
+        # Get cache entry
+        result = cache.get(text, target_lang)
+        assert result == translated_text
+
+    def test_cache_persistence(self):
+        """Test that cache persists between instances."""
+        service_name = "persistence_test"
+        text = "Test message"
+        target_lang = "fr"
+        translated_text = "Message de test"
+
+        # Create first cache instance and set entry
+        cache1 = TranslationCache(cache_dir=self.cache_dir, service_name=service_name)
+        cache1.set(text, target_lang, translated_text)
+
+        # Create second cache instance and check if entry exists
+        cache2 = TranslationCache(cache_dir=self.cache_dir, service_name=service_name)
+        result = cache2.get(text, target_lang)
+        assert result == translated_text
+
+    def test_cache_stats(self):
+        """Test cache statistics functionality."""
+        cache = TranslationCache(cache_dir=self.cache_dir, service_name="stats_test")
+
+        # Add some entries
+        cache.set("text1", "ja", "translation1")
+        cache.set("text2", "ja", "translation2")
+
+        stats = cache.get_cache_stats()
+
+        assert "total_entries" in stats
+        assert "cache_size_bytes" in stats
+        assert "cache_size_mb" in stats
+        assert "cache_file" in stats
+        assert stats["total_entries"] == 2
+        assert stats["cache_file"] == str(cache.cache_file)
+
+    def test_get_translation_cache_function(self):
+        """Test get_translation_cache function with different service names."""
+        # Test with different service names
+        service_names = [
+            "DeeplTranslator",
+            "RivaTranslator",
+            "LocalTranslator",
+            "default",
+        ]
+        cache_instances = {}
+
+        for service_name in service_names:
+            cache = get_translation_cache(service_name)
+            cache_instances[service_name] = cache
+
+            # Verify cache file name
+            expected_file = f"translations_{service_name}.json"
+            assert cache.cache_file.name == expected_file
+
+        # Verify that different service names create different cache instances
+        assert (
+            cache_instances["DeeplTranslator"] is not cache_instances["RivaTranslator"]
+        )
+        assert (
+            cache_instances["RivaTranslator"] is not cache_instances["LocalTranslator"]
+        )
+
+    def test_cache_key_generation(self):
+        """Test cache key generation."""
+        cache = TranslationCache(cache_dir=self.cache_dir, service_name="key_test")
+
+        # Test cache key generation
+        text = "Hello, world!"
+        target_lang = "ja"
+        actual_key = cache._get_cache_key(text, target_lang)
+        assert isinstance(actual_key, str)
+
+
+if __name__ == "__main__":
+    test_translation_cache()