Support smolagent (#5)

* Toctree logic update

* feat: Add AWS Bedrock integration and API provider selection

This commit introduces the following enhancements:

- **API Provider Selection**: Implemented a new feature allowing users to select between Anthropic and AWS Bedrock as their preferred API provider for translation tasks.
- **AWS Bedrock Integration**: Integrated AWS Bedrock as a translation backend, enabling the use of AWS Bedrock models via a bearer token.
- **Dynamic API Key Management**: Updated the configuration panel and backend logic to dynamically manage and apply API keys based on the selected provider, ensuring only the active provider's key is used.
- **Improved PR Generation**: Enhanced the default Pull Request generation with a more detailed and structured template, including a comprehensive checklist for reviewers.
- **Model Configuration**: Added `config.py` to centralize default model definitions.

These changes provide greater flexibility in choosing translation services and improve the overall user experience for PR generation.

agent/handler.py

@@ -33,6 +33,7 @@ class ChatState:
         # Persistent settings (preserved across restarts)
         self.persistent_settings = {
             "anthropic_api_key": "",
+            "aws_bearer_token_bedrock": "",
             "github_config": {
                 "token": "",
                 "owner": "",
@@ -374,14 +375,29 @@ def update_language_selection(lang, history):
     return history, "", update_status(), lang
 
 
-def update_persistent_config(anthropic_key, github_token, github_owner, github_repo, reference_pr_url, history):
+def update_persistent_config(api_provider, anthropic_key, aws_bearer_token_bedrock, github_token, github_owner, github_repo, reference_pr_url, history):
     """Update persistent configuration settings."""
     global state
     
-    # Update API keys
-    if anthropic_key:
+    # Update API keys based on provider selection
+    if api_provider == "Anthropic":
         state.persistent_settings["anthropic_api_key"] = anthropic_key
         os.environ["ANTHROPIC_API_KEY"] = anthropic_key
+        # Clear AWS Bedrock token if Anthropic is selected
+        state.persistent_settings["aws_bearer_token_bedrock"] = ""
+        os.environ.pop("AWS_BEARER_TOKEN_BEDROCK", None)
+    elif api_provider == "AWS Bedrock":
+        state.persistent_settings["aws_bearer_token_bedrock"] = aws_bearer_token_bedrock
+        os.environ["AWS_BEARER_TOKEN_BEDROCK"] = aws_bearer_token_bedrock
+        # Clear Anthropic key if AWS Bedrock is selected
+        state.persistent_settings["anthropic_api_key"] = ""
+        os.environ.pop("ANTHROPIC_API_KEY", None)
+    else:
+        # If no provider is selected or unknown, clear both
+        state.persistent_settings["anthropic_api_key"] = ""
+        os.environ.pop("ANTHROPIC_API_KEY", None)
+        state.persistent_settings["aws_bearer_token_bedrock"] = ""
+        os.environ.pop("AWS_BEARER_TOKEN_BEDROCK", None)
     
     if github_token:
         os.environ["GITHUB_TOKEN"] = github_token
@@ -406,8 +422,11 @@ def update_persistent_config(anthropic_key, github_token, github_owner, github_r
     response = "✅ Configuration saved!"
     if github_owner and github_repo:
         response += f" GitHub: {github_owner}/{github_repo}"
-    elif anthropic_key:
+    
+    if api_provider == "Anthropic" and anthropic_key:
         response += " Anthropic API key updated."
+    elif api_provider == "AWS Bedrock" and aws_bearer_token_bedrock:
+        response += " AWS Bedrock Bearer Token updated."
     
     history.append(["Configuration update", response])
     return history, "", update_status()
@@ -457,12 +476,20 @@ def send_message(message, history):
 def start_translate_handler(history, file_to_translate, additional_instruction="", force_retranslate=False):
     # Use persistent anthropic key
     anthropic_key = state.persistent_settings["anthropic_api_key"]
-    if not anthropic_key:
-        response = "❌ Please set Anthropic API key in Configuration panel first."
+    aws_bearer_token_bedrock = state.persistent_settings["aws_bearer_token_bedrock"]
+
+    if not anthropic_key and not aws_bearer_token_bedrock:
+        response = "❌ Please set either Anthropic API key or AWS Bearer Token for Bedrock in Configuration panel first."
         history.append(["Translation request", response])
         return history, "", update_status(), gr.Tabs(), gr.update(), gr.update()
     
-    os.environ["ANTHROPIC_API_KEY"] = anthropic_key
+    # Set the active API key to environment variable for translator.content.py
+    if anthropic_key:
+        os.environ["ANTHROPIC_API_KEY"] = anthropic_key
+        os.environ.pop("AWS_BEARER_TOKEN_BEDROCK", None) # Ensure only one is active
+    elif aws_bearer_token_bedrock:
+        os.environ["AWS_BEARER_TOKEN_BEDROCK"] = aws_bearer_token_bedrock
+        os.environ.pop("ANTHROPIC_API_KEY", None) # Ensure only one is active
     
     # Check if file path is provided
     if not file_to_translate or not file_to_translate.strip():
@@ -602,6 +629,8 @@ def restart_handler(history):
     # Restore environment variables
     if backup_settings["anthropic_api_key"]:
         os.environ["ANTHROPIC_API_KEY"] = backup_settings["anthropic_api_key"]
+    if backup_settings["aws_bearer_token_bedrock"]:
+        os.environ["AWS_BEARER_TOKEN_BEDROCK"] = backup_settings["aws_bearer_token_bedrock"]
     if backup_settings["github_config"]["token"]:
         os.environ["GITHUB_TOKEN"] = backup_settings["github_config"]["token"]
     

agent/toctree_handler.py

@@ -134,8 +134,10 @@ Korean title:"""
             english_title = self.find_title_for_local(en_toctree, target_local)
             
             if not english_title:
-                print(f"Could not find English title for local: {target_local}")
-                return ko_toctree
+                print(f"⚠️ Toctree entry not found: '{target_local}' not in English toctree")
+                print(f"🔍 Attempting to find appropriate section for new entry...")
+                # Try to add new entry in appropriate location
+                return self.add_new_toctree_entry(ko_toctree, target_local)
             
             print(f"Found English title: {english_title} for local: {target_local}")
             
@@ -153,10 +155,11 @@ Korean title:"""
             )
             
             if updated:
-                print(f"Successfully updated translation entry: local={target_local}, title={korean_title}")
+                print(f"✅ Successfully updated translation entry: local={target_local}, title={korean_title}")
                 return updated_toctree
             else:
-                print(f"Could not find '(번역중) {english_title}' entry to update")
+                print(f"⚠️ Toctree update skipped: '(번역중) {english_title}' entry not found")
+                print(f"📋 This may be a new file not yet added to Korean toctree")
                 return ko_toctree
                 
         except Exception as e:
@@ -192,8 +195,8 @@ Korean title:"""
         # Get Korean toctree
         ko_toctree = self.get_ko_toctree()
         
-        # Update Korean toctree with replacement logic
-        updated_ko_toctree = self.create_updated_toctree_with_replacement(ko_toctree, filepath_without_prefix)
+        # Use diff-merge algorithm to add new entry
+        updated_ko_toctree = self.add_new_toctree_entry(ko_toctree, filepath_without_prefix)
         
         if not updated_ko_toctree:
             print(f"Failed to create updated Korean toctree for local: {filepath_without_prefix}")
@@ -287,3 +290,130 @@ Korean title:"""
                 "status": "error",
                 "message": f"Error updating toctree: {str(e)}"
             }
+    
+    def add_new_toctree_entry(self, ko_toctree: list, target_local: str) -> list:
+        """Add new toctree entry using diff-merge algorithm"""
+        try:
+            import copy
+            updated_toctree = copy.deepcopy(ko_toctree)
+            
+            # Generate new entry
+            filename = target_local.split('/')[-1].replace('_', ' ').title()
+            korean_title = self.translate_title(filename)
+            new_entry = {
+                'local': target_local,
+                'title': korean_title
+            }
+            
+            # Get English toctree for structure reference
+            en_toctree = self.get_en_toctree()
+            
+            # Use diff-merge algorithm
+            if self.merge_toctree_sections(en_toctree, updated_toctree, target_local, new_entry):
+                return updated_toctree
+            else:
+                # Fallback: add to root level
+                updated_toctree.append(new_entry)
+                print(f"✅ Added new entry at root level: {target_local} -> {korean_title}")
+                return updated_toctree
+                
+        except Exception as e:
+            print(f"❌ Error adding new toctree entry: {e}")
+            return ko_toctree
+    
+    def merge_toctree_sections(self, en_toctree: list, ko_toctree: list, target_local: str, new_entry: dict) -> bool:
+        """Merge English toctree structure into Korean toctree for target_local"""
+        for en_section in en_toctree:
+            en_title = en_section.get('title')
+            
+            # Check if this English section contains our target
+            if self.contains_target(en_section, target_local):
+                # Find matching Korean section
+                ko_section = self.find_matching_section(ko_toctree, en_title)
+                
+                if ko_section:
+                    # Section exists - merge subsections
+                    return self.merge_subsections(en_section, ko_section, target_local, new_entry)
+                else:
+                    # Section doesn't exist - create new section
+                    new_ko_section = self.create_section_with_order(en_section, target_local, new_entry)
+                    ko_toctree.append(new_ko_section)
+                    print(f"✅ Created new section '{new_ko_section.get('title')}' with ordered structure")
+                    return True
+        return False
+    
+    def contains_target(self, section: dict, target_local: str) -> bool:
+        """Check if section contains target_local recursively"""
+        if 'sections' in section:
+            for subsection in section['sections']:
+                if subsection.get('local') == target_local:
+                    return True
+                if self.contains_target(subsection, target_local):
+                    return True
+        return False
+    
+    def find_matching_section(self, ko_toctree: list, en_title: str) -> dict:
+        """Find Korean section that matches English title"""
+        # Try exact match first
+        for item in ko_toctree:
+            if item.get('title') == en_title:
+                return item
+        
+        # Try translated title match
+        try:
+            translated_title = self.translate_title(en_title)
+            for item in ko_toctree:
+                if item.get('title') == translated_title:
+                    return item
+        except:
+            pass
+                
+        return None
+    
+    def merge_subsections(self, en_section: dict, ko_section: dict, target_local: str, new_entry: dict) -> bool:
+        """Merge subsections while maintaining order"""
+        if 'sections' not in en_section:
+            return False
+            
+        # Find target index in English sections
+        target_index = -1
+        for i, en_subsection in enumerate(en_section['sections']):
+            if en_subsection.get('local') == target_local:
+                target_index = i
+                break
+        
+        if target_index == -1:
+            return False
+            
+        # Ensure Korean section has sections array
+        if 'sections' not in ko_section:
+            ko_section['sections'] = []
+            
+        # Insert at correct position
+        self.insert_at_correct_position(ko_section, target_index, new_entry)
+        return True
+    
+    def insert_at_correct_position(self, ko_section: dict, target_index: int, new_entry: dict):
+        """Insert entry at correct position, expanding array if needed"""
+        sections = ko_section['sections']
+        
+        # Expand sections array if needed
+        while len(sections) <= target_index:
+            sections.append(None)  # Placeholder
+        
+        # Insert new entry
+        sections[target_index] = new_entry
+        
+        # Clean up None placeholders at the end
+        while sections and sections[-1] is None:
+            sections.pop()
+    
+    def create_section_with_order(self, en_section: dict, target_local: str, new_entry: dict) -> dict:
+        """Create new Korean section with only the translated entry"""
+        new_ko_section = {
+            'title': self.translate_title(en_section.get('title')),
+            'isExpanded': en_section.get('isExpanded', False),
+            'sections': [new_entry]  # Only add the translated entry
+        }
+        
+        return new_ko_section

agent/workflow.py

@@ -261,30 +261,58 @@ def generate_github_pr(
 {result["message"]}"""
 
         elif result["status"] == "partial_success":
-            return f"""⚠️ **Partial Success**
+            error_details = result.get("error_details", "Unknown error")
+            
+            # Check if it's "existing PR" case (not really an error)
+            if "Existing PR found" in error_details:
+                existing_pr_url = error_details.split(": ")[-1] if ": " in error_details else "Unknown"
+                return f"""🔄 **Translation Updated Successfully**
+
+🎯 **Selected Project:** {project}
+🌿 **Branch:** {result["branch"]}
+📁 **File:** {result["file_path"]}{toctree_status}
+
+🔗 **Existing PR Updated:** {existing_pr_url}
+
+✅ Your translation has been added to the existing PR. The file and toctree have been successfully updated!"""
+            else:
+                # Actual error case
+                return f"""⚠️ **Partial Success**
 
+🎯 **Selected Project:** {project}
+🏠 **User Fork:** {github_config.get('owner', 'USER')}/{github_config.get('repo_name', 'REPO')}
+🎯 **Target Base:** {base_owner}/{base_repo}
 🌿 **Branch:** {result["branch"]}
 📁 **File:** {result["file_path"]}{toctree_status}
 
 {result["message"]}
 
 **Error Details:**
-{result.get("error_details", "Unknown error")}"""
+{error_details}
+
+💡 **Project-Repository Mismatch Check:**
+- Selected project '{project}' should match repository '{github_config.get('repo_name', 'REPO')}'
+- For smolagents: use Jwaminju/smolagents fork
+- For transformers: use Jwaminju/transformers fork"""
 
         else:
             error_details = result.get("error_details", "No additional details")
             return f"""❌ **GitHub PR Creation Failed**
 
+🎯 **Selected Project:** {project}
+🏠 **User Fork:** {github_config.get('owner', 'USER')}/{github_config.get('repo_name', 'REPO')}
+🎯 **Target Base:** {base_owner}/{base_repo}
+
 **Error Message:**
 {result["message"]}
 
 **Error Details:**
 {error_details}
 
-💡 **Common Solutions:**
-1. **Project Mismatch**: Selected project '{project}' but fork is '{github_config.get('repo_name', 'REPO')}' - ensure they match
-2. Check if your GitHub fork exists: {github_config.get('owner', 'USER')}/{github_config.get('repo_name', 'REPO')}
-3. Verify GitHub token has write access to your fork"""
+💡 **Project-Repository Mismatch:**
+Selected project '{project}' but configured repository '{github_config.get('repo_name', 'REPO')}'
+• For smolagents project: use 'smolagents' repository
+• For transformers project: use 'transformers' repository"""
 
     except Exception as e:
         error_msg = f"""❌ **Unexpected Error During PR Creation**

app.py

@@ -138,10 +138,23 @@ with gr.Blocks(
                 gr.Markdown("### ⚙️ Configuration")
                 
                 with gr.Accordion("🔧 API & GitHub Settings", open=True):
+                    api_provider_radio = gr.Radio(
+                        ["Anthropic", "AWS Bedrock"],
+                        label="Select API Provider",
+                        value="Anthropic", # Default selection
+                        interactive=True,
+                    )
                     config_anthropic_key = gr.Textbox(
                         label="🔑 Anthropic API Key",
                         type="password",
                         placeholder="sk-ant-...",
+                        visible=True, # Initially visible as Anthropic is default
+                    )
+                    config_aws_bearer_token_bedrock = gr.Textbox(
+                        label="🔑 AWS Bearer Token for Bedrock",
+                        type="password",
+                        placeholder="AWS_BEARER_TOKEN_BEDROCK",
+                        visible=False, # Initially hidden
                     )
                     config_github_token = gr.Textbox(
                         label="🔑 GitHub Token (Required for PR, Optional for file search)",
@@ -316,10 +329,20 @@ with gr.Blocks(
     # Configuration Save
     save_config_btn.click(
         fn=update_persistent_config,
-        inputs=[config_anthropic_key, config_github_token, config_github_owner, config_github_repo, reference_pr_url, chatbot],
+        inputs=[api_provider_radio, config_anthropic_key, config_aws_bearer_token_bedrock, config_github_token, config_github_owner, config_github_repo, reference_pr_url, chatbot],
         outputs=[chatbot, msg_input, status_display],
     )
 
+    # API Provider selection handler
+    api_provider_radio.change(
+        fn=lambda provider: (
+            gr.update(visible=True) if provider == "Anthropic" else gr.update(visible=False),
+            gr.update(visible=True) if provider == "AWS Bedrock" else gr.update(visible=False),
+        ),
+        inputs=[api_provider_radio],
+        outputs=[config_anthropic_key, config_aws_bearer_token_bedrock],
+    )
+
     approve_btn.click(
         fn=approve_handler,
         inputs=[chatbot, config_github_owner, config_github_repo, reference_pr_url],

config.py

@@ -0,0 +1,10 @@
+# config.py
+
+# 기본 모델 목록
+default_models = [
+    "Helsinki-NLP/opus-mt-ko-en",
+    "Helsinki-NLP/opus-mt-tc-big-en-ko",
+    "davidkim205/iris-7b",
+    "maywell/Synatra-7B-v0.3-Translation",
+    "CUSTOM_MODEL_INPUT" # Placeholder for custom model input
+]

pr_generator/agent.py

@@ -11,6 +11,7 @@ from typing import Optional, Dict, List, Tuple, Any
 
 # Load environment variables from .env file
 from dotenv import load_dotenv
+from translator.content import llm_translate
 
 load_dotenv()
 
@@ -259,8 +260,8 @@ class GitHubPRAgent:
     ) -> str:
         """Generate text using LLM."""
         try:
-            response = self.llm.invoke(prompt)
-            generated = response.content.strip()
+            _usage_info, generated = llm_translate(prompt)
+            generated = generated.strip()
             print(f"LLM generated {operation}: {generated}")
             return generated
         except Exception as e:
@@ -271,25 +272,10 @@ class GitHubPRAgent:
     def generate_branch_name_from_reference(
         self, reference_branch_name: str, target_language: str, file_name: str
     ) -> str:
-        """Use LLM to analyze reference PR information and generate appropriate branch name."""
-        prompt = f"""Here is the reference PR information:
-
-Reference PR branch name: {reference_branch_name}
-
-Now I need to generate a branch name for a new translation task:
-- Target language: {target_language}
-- File to translate: {file_name}
-
-Please analyze the pattern and style of the reference PR title to generate a consistent new branch name.
-
-Requirements:
-1. Follow the naming conventions and patterns of the reference PR
-2. Appropriately reflect the target language ({target_language}) and file name ({file_name}) if applicable
-
-Please return only the branch name. No other explanation is needed."""
-
-        fallback = f"translate-{target_language}-{file_name.replace('_', '-')}"
-        return self._generate_with_llm(prompt, fallback, "branch name")
+        """Generate branch name using simple template."""
+        # Keep .md extension and make branch-safe
+        branch_safe_name = file_name.replace('_', '-')
+        return f"{target_language}-{branch_safe_name}"
 
     def generate_pr_content_from_reference(
         self,
@@ -328,8 +314,8 @@ Title: [PR title here]
 Body: [PR body here, maintaining the exact markdown format and structure of the original]"""
 
         try:
-            response = self.llm.invoke(prompt)
-            generated_content = response.content.strip()
+            _usage_info, generated_content = llm_translate(prompt)
+            generated_content = generated_content.strip()
 
             # Separate title and body from response
             lines = generated_content.split("\n")
@@ -370,47 +356,46 @@ Body: [PR body here, maintaining the exact markdown format and structure of the
         self, target_language: str, filepath: str, target_filepath: str, file_name: str
     ) -> Tuple[str, str]:
         """Generate default PR content."""
-        title = f"[i18n-{target_language}] Add {target_language} translation for {file_name}"
-        body = f"""## Summary
-Add {target_language} translation for `{filepath}`.
-
-## Changes
-- Add {target_language} translation: `{target_filepath}`
-- Original file: `{filepath}`
+        title = f"🌐 [i18n-{target_language}] Translated `{file_name}` to {target_language}"
+        body = f"""# What does this PR do?
+
+Translated the `{filepath}` file of the documentation to {target_language} 😄 
+Thank you in advance for your review!
+
+Part of https://github.com/huggingface/transformers/issues/20179
+
+## Before reviewing
+- [x] Check for missing / redundant translations (번역 누락/중복 검사)
+- [x] Grammar Check (맞춤법 검사)
+- [x] Review or Add new terms to glossary (용어 확인 및 추가)
+- [x] Check Inline TOC (e.g. `[[lowercased-header]]`)
+- [x] Check live-preview for gotchas (live-preview로 정상작동 확인)
+
+## Who can review? (Initial)
+{target_language} translation reviewers
+
+## Before submitting
+- [x] This PR fixes a typo or improves the docs (you can dismiss the other checks if that's the case).
+- [x] Did you read the [contributor guideline](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md#start-contributing-pull-requests),
+      Pull Request section?
+- [ ] Was this discussed/approved via a Github issue or the [forum](https://discuss.huggingface.co/)? Please add a link
+      to it if that's the case.
+- [x] Did you make sure to update the documentation with your changes? Here are the
+      [documentation guidelines](https://github.com/huggingface/transformers/tree/main/docs), and
+      [here are tips on formatting docstrings](https://github.com/huggingface/transformers/tree/main/docs#writing-source-documentation).
+- [ ] Did you write any new necessary tests?
+
+## Who can review? (Final)
+ May you please review this PR?
+Documentation maintainers
 """
         return title, body
 
     def generate_commit_message_from_reference(
         self, commit_messages: List[str], target_language: str, file_name: str
     ) -> str:
-        """Use LLM to analyze reference PR commit messages and generate appropriate commit message."""
-        commits_text = (
-            "\n".join([f"- {msg}" for msg in commit_messages])
-            if commit_messages
-            else "None"
-        )
-
-        prompt = f"""Here are the commit messages from the reference PR:
-
-{commits_text}
-
-Now I need to generate a commit message for a new translation task:
-- Target language: {target_language}
-- File to translate: {file_name}
-
-Please analyze the commit message patterns and style of the reference PR to generate a consistent new commit message.
-
-Requirements:
-1. Follow the commit message style and format of the reference PR
-2. Appropriately reflect the target language ({target_language}) and file name ({file_name})
-3. Follow general Git commit message conventions
-4. Be concise and clear
-5. If you detect typos in the given commit messages, use corrected versions (e.g., dos -> docs)
-
-Please return only the commit message. No other explanation is needed."""
-
-        fallback = f"docs: add {target_language} translation for {file_name}"
-        return self._generate_with_llm(prompt, fallback, "commit message")
+        """Generate simple commit message using template."""
+        return f"docs: {target_language}: {file_name}"
 
     def get_branch_info(self, owner: str, repo_name: str, branch_name: str) -> str:
         """Get information about an existing branch."""
@@ -452,7 +437,7 @@ Please return only the commit message. No other explanation is needed."""
 
             # 2. Generate translation file path and branch name
             target_filepath = filepath.replace("/en/", f"/{target_language}/")
-            file_name = filepath.split("/")[-1].replace(".md", "")
+            file_name = filepath.split("/")[-1]  # Keep .md extension
 
             print(f"🌿 Generating branch name...")
             branch_name = self.generate_branch_name_from_reference(

translator/content.py

@@ -1,9 +1,12 @@
+import os
 import re
 import string
 
 import requests
 from langchain.callbacks import get_openai_callback
 from langchain_anthropic import ChatAnthropic
+import boto3
+import json
 
 from translator.prompt_glossary import PROMPT_WITH_GLOSSARY
 from translator.project_config import get_project_config
@@ -167,10 +170,45 @@ def fill_scaffold(content: str, to_translate: str, translated: str) -> str:
 
 
 def llm_translate(to_translate: str) -> tuple[str, str]:
-    with get_openai_callback() as cb:
+    anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+    aws_bearer_token_bedrock = os.environ.get("AWS_BEARER_TOKEN_BEDROCK")
+
+    if anthropic_api_key:
+        # Use Anthropic API Key
         model = ChatAnthropic(
             model="claude-sonnet-4-20250514", max_tokens=64000, streaming=True
         )
         ai_message = model.invoke(to_translate)
-        print("cb:", cb)
-    return str(cb), ai_message.content
+        cb = "Anthropic API Key used"
+        return str(cb), ai_message.content
+
+    elif aws_bearer_token_bedrock:
+        # Use AWS Bedrock with bearer token (assuming standard AWS credential chain is configured)
+        # Note: boto3 does not directly use a 'bearer_token' named environment variable for SigV4 authentication.
+        # It relies on AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN, or IAM roles.
+        # If AWS_BEARER_TOKEN_BEDROCK is meant to be one of these, it should be renamed accordingly.
+        # For now, we proceed assuming standard AWS credential chain is configured to pick up credentials.
+        client = boto3.client("bedrock-runtime", region_name="eu-north-1")
+
+        body = {
+            "messages": [
+                {"role": "user", "content": to_translate}
+            ],
+            "max_tokens": 128000,
+            "anthropic_version": "bedrock-2023-05-31"
+        }
+
+        response = client.invoke_model(
+            modelId="arn:aws:bedrock:eu-north-1:235729104418:inference-profile/eu.anthropic.claude-3-7-sonnet-20250219-v1:0",
+            contentType="application/json",
+            accept="application/json",
+            body=json.dumps(body),
+        )
+        result = json.loads(response["body"].read())
+        cb = result["usage"]
+        ai_message = result["content"][0]["text"]
+
+        return str(cb), ai_message
+
+    else:
+        raise ValueError("No API key found for translation. Please set ANTHROPIC_API_KEY or AWS_BEARER_TOKEN_BEDROCK environment variable.")