ppt-translator-mcp 0.0.1

package/.env.example

@@ -0,0 +1,4 @@
+AWS_ACCESS_KEY_ID=your_access_key
+AWS_SECRET_ACCESS_KEY=your_secret_key
+AWS_REGION=us-east-1
+DEFAULT_TARGET_LANGUAGE=zh-CN

package/README.md

@@ -0,0 +1,118 @@
+# PowerPoint Translator MCP Service
+
+A Model Context Protocol (MCP) service that provides PowerPoint translation capabilities using AWS Bedrock models.
+
+## Features
+
+- Translate PowerPoint presentations to multiple languages
+- Preserve formatting during translation
+- Support for multiple translation engines (Nova Lite and Claude)
+- Intelligent handling of proper nouns, brand names, and special content
+
+## Supported Languages
+
+- Simplified Chinese (zh-CN)
+- Traditional Chinese (zh-TW)
+- English (en)
+- Japanese (ja)
+- Korean (ko)
+- French (fr)
+- German (de)
+- Spanish (es)
+
+## Prerequisites
+
+- Node.js 14+ (for npm package installation)
+- Python 3.8+
+- AWS account with Bedrock access
+- AWS credentials configured
+
+## Installation
+
+### Using npm
+
+```bash
+npm install -g ppt-translator-mcp-zhu2mu-unique
+```
+
+### Using Amazon Q Configuration
+
+Add the following to your Amazon Q configuration:
+
+```json
+"mcpServers": {
+  "ppt-translator": {
+    "timeout": 60,
+    "type": "stdio",
+    "command": "npx",
+    "args": [
+      "-y",
+      "ppt-translator-mcp-zhu2mu-unique@latest"
+    ],
+    "env": {
+      "AWS_ACCESS_KEY_ID": "${AWS_ACCESS_KEY_ID}",
+      "AWS_SECRET_ACCESS_KEY": "${AWS_SECRET_ACCESS_KEY}",
+      "AWS_REGION": "us-east-1",
+      "DEFAULT_TARGET_LANGUAGE": "zh-CN"
+    }
+  }
+}
+```
+
+## Usage
+
+Once the MCP server is running, you can use it with any MCP-compatible client like Amazon Q or Claude Desktop.
+
+### Available Tools
+
+1. `translate_ppt` - Translate a PowerPoint document
+   - Parameters:
+     - `input_file`: Path to the input PowerPoint file (required)
+     - `target_language`: Target language code (default: zh-CN)
+     - `output_file`: Path to save the translated file (optional)
+     - `translation_method`: Translation method, 'nova' or 'claude' (default: nova)
+
+2. `list_supported_languages` - List all supported target languages
+
+## Example
+
+```
+Translate my presentation.pptx to Japanese using the Claude model
+```
+
+## Development
+
+### Local Development
+
+1. Clone this repository:
+   ```bash
+   git clone https://github.com/yourusername/mcpppttranslator.git
+   cd mcpppttranslator
+   ```
+
+2. Install dependencies:
+   ```bash
+   npm install
+   pip install -r requirements.txt
+   ```
+
+3. Run the server:
+   ```bash
+   node index.js
+   ```
+
+### Publishing to npm
+
+1. Update version in package.json
+2. Login to npm:
+   ```bash
+   npm login
+   ```
+3. Publish:
+   ```bash
+   npm publish --access public
+   ```
+
+## License
+
+MIT

package/amazon-q-config-example.json

@@ -0,0 +1,19 @@
+{
+  "mcpServers": {
+    "ppt-translator": {
+      "timeout": 60,
+      "type": "stdio",
+      "command": "npx",
+      "args": [
+        "-y",
+        "ppt-translator-mcp@latest"
+      ],
+      "env": {
+        "AWS_ACCESS_KEY_ID": "${AWS_ACCESS_KEY_ID}",
+        "AWS_SECRET_ACCESS_KEY": "${AWS_SECRET_ACCESS_KEY}",
+        "AWS_REGION": "us-east-1",
+        "DEFAULT_TARGET_LANGUAGE": "zh-CN"
+      }
+    }
+  }
+}

package/index.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Ensure Python and pip are installed
+function checkPythonDependencies() {
+  try {
+    // Check if Python is available
+    const pythonVersion = spawn('python3', ['--version']);
+    pythonVersion.on('error', (err) => {
+      console.error('Python3 is not installed or not in PATH. Please install Python 3.8+');
+      process.exit(1);
+    });
+
+    // Check if pip is available
+    const pipVersion = spawn('pip3', ['--version']);
+    pipVersion.on('error', (err) => {
+      console.error('pip3 is not installed or not in PATH. Please install pip');
+      process.exit(1);
+    });
+  } catch (error) {
+    console.error('Error checking Python dependencies:', error);
+    process.exit(1);
+  }
+}
+
+// Install required Python packages
+function installPythonDependencies() {
+  return new Promise((resolve, reject) => {
+    console.log('Installing Python dependencies...');
+    
+    // Path to requirements.txt in the package
+    const requirementsPath = path.join(__dirname, 'requirements.txt');
+    
+    // Install dependencies using pip
+    const pip = spawn('pip3', ['install', '-r', requirementsPath]);
+    
+    pip.stdout.on('data', (data) => {
+      console.log(`${data}`);
+    });
+    
+    pip.stderr.on('data', (data) => {
+      console.error(`${data}`);
+    });
+    
+    pip.on('close', (code) => {
+      if (code === 0) {
+        console.log('Python dependencies installed successfully');
+        resolve();
+      } else {
+        console.error(`pip exited with code ${code}`);
+        reject(new Error(`Failed to install Python dependencies (exit code: ${code})`));
+      }
+    });
+  });
+}
+
+// Run the MCP server
+function runMCPServer() {
+  console.log('Starting PowerPoint Translator MCP server...');
+  
+  // Path to the Python server script
+  const serverPath = path.join(__dirname, 'server.py');
+  
+  // Make sure the script is executable
+  fs.chmodSync(serverPath, '755');
+  
+  // Run the Python script in MCP mode
+  const server = spawn('python3', [serverPath]);
+  
+  // Pipe stdin/stdout directly to the Python process for MCP communication
+  process.stdin.pipe(server.stdin);
+  server.stdout.pipe(process.stdout);
+  server.stderr.on('data', (data) => {
+    process.stderr.write(`${data}`);
+  });
+  
+  server.on('close', (code) => {
+    console.log(`MCP server exited with code ${code}`);
+    process.exit(code);
+  });
+  
+  // Handle process termination
+  process.on('SIGINT', () => {
+    console.log('Received SIGINT. Shutting down MCP server...');
+    server.kill('SIGINT');
+  });
+  
+  process.on('SIGTERM', () => {
+    console.log('Received SIGTERM. Shutting down MCP server...');
+    server.kill('SIGTERM');
+  });
+}
+
+// Main function
+async function main() {
+  try {
+    checkPythonDependencies();
+    await installPythonDependencies();
+    runMCPServer();
+  } catch (error) {
+    console.error('Error starting MCP server:', error);
+    process.exit(1);
+  }
+}
+
+// Run the main function
+main();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "ppt-translator-mcp",
+  "version": "0.0.1",
+  "description": "MCP server for PowerPoint translation using AWS Bedrock",
+  "main": "index.js",
+  "bin": {
+    "mcp-ppt-translator": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "mcp",
+    "powerpoint",
+    "translation",
+    "aws",
+    "bedrock"
+  ],
+  "author": "zhuermu",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhuermu/mcpppttranslator.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zhuermu/mcpppttranslator/issues"
+  },
+  "homepage": "https://github.com/zhuermu/mcpppttranslator#readme",
+  "dependencies": {
+    "@modelcontextprotocol/server": "^1.0.0"
+  }
+}

package/publish.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# 检查是否提供了NPM令牌
+if [ -z "$1" ]; then
+  echo "请提供NPM令牌作为参数"
+  echo "用法: ./publish.sh your-npm-token"
+  exit 1
+fi
+
+# 设置NPM令牌
+NPM_TOKEN=$1
+
+# 创建临时.npmrc文件
+echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" > .npmrc
+
+# 发布包
+npm publish --access public
+
+# 删除临时.npmrc文件
+rm .npmrc
+
+echo "发布完成！"

package/requirements.txt

@@ -0,0 +1,3 @@
+python-pptx>=0.6.21
+boto3>=1.28.0
+python-dotenv>=1.0.0

package/server.py

@@ -0,0 +1,565 @@
+#!/usr/bin/env python3
+"""
+PPT Translator Server
+A server that provides PowerPoint translation capabilities using AWS Bedrock models.
+"""
+
+import os
+import sys
+import logging
+import json
+import argparse
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+
+try:
+    from pptx import Presentation
+except ImportError:
+    print("Error: python-pptx not found. Please install it with 'pip install python-pptx'")
+    sys.exit(1)
+
+try:
+    import boto3
+except ImportError:
+    print("Error: boto3 not found. Please install it with 'pip install boto3'")
+    sys.exit(1)
+
+try:
+    from dotenv import load_dotenv
+except ImportError:
+    print("Error: python-dotenv not found. Please install it with 'pip install python-dotenv'")
+    sys.exit(1)
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize AWS Bedrock client
+try:
+    bedrock_client = boto3.client(
+        'bedrock-runtime',
+        aws_access_key_id=os.getenv('AWS_ACCESS_KEY_ID'),
+        aws_secret_access_key=os.getenv('AWS_SECRET_ACCESS_KEY'),
+        region_name=os.getenv('AWS_REGION', 'us-east-1')
+    )
+except Exception as e:
+    logger.error(f"Failed to initialize AWS Bedrock client: {str(e)}")
+    print(f"Error: Failed to initialize AWS Bedrock client. Please check your AWS credentials.")
+    sys.exit(1)
+
+default_target_language = os.getenv('DEFAULT_TARGET_LANGUAGE', 'zh-CN')
+
+def _translate_text(text: str, target_language: str, method: str) -> Optional[str]:
+    """Translate a single text"""
+    try:
+        if method == 'claude':
+            return _translate_with_claude(text, target_language)
+        else:
+            return _translate_with_nova(text, target_language)
+    except Exception as e:
+        logger.error(f"Failed to translate text: {str(e)}")
+        return None
+
+def _translate_with_claude(text: str, target_language: str) -> str:
+    """Translate using AWS Bedrock Claude 3.5 Sonnet"""
+    language_map = {
+        'zh-CN': '简体中文',
+        'zh-TW': '繁体中文',
+        'en': '英语',
+        'ja': '日语',
+        'ko': '韩语',
+        'fr': '法语',
+        'de': '德语',
+        'es': '西班牙语'
+    }
+    
+    target_lang_name = language_map.get(target_language, target_language)
+    
+    body = json.dumps({
+        "anthropic_version": "bedrock-2023-05-31",
+        "max_tokens": 1000,
+        "messages": [
+            {
+                "role": "user",
+                "content": f"Please translate the following text to {target_lang_name}. Keep proper nouns, brand names, person names, place names, company names, and currencies untranslated. Only return the translation result:\n\n{text}"
+            }
+        ]
+    })
+    
+    response = bedrock_client.invoke_model(
+        body=body,
+        modelId="anthropic.claude-3-5-sonnet-20241022-v2:0",
+        accept="application/json",
+        contentType="application/json"
+    )
+    
+    response_body = json.loads(response.get('body').read())
+    return response_body['content'][0]['text'].strip()
+
+def _translate_with_nova(text: str, target_language: str) -> str:
+    """Translate using AWS Bedrock Nova Lite"""
+    language_map = {
+        'zh-CN': '简体中文',
+        'zh-TW': '繁体中文',
+        'en': '英语',
+        'ja': '日语',
+        'ko': '韩语',
+        'fr': '法语',
+        'de': '德语',
+        'es': '西班牙语'
+    }
+    
+    target_lang_name = language_map.get(target_language, target_language)
+    
+    # Check if it's a proper noun or number
+    if text.strip().isdigit() or (len(text.strip()) <= 3 and not any(c.isalpha() for c in text)):
+        return text
+    
+    body = json.dumps({
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "text": f"""Translate the following text to {target_lang_name}.
+                        
+Please follow these rules:
+1. Keep all brand names untranslated, such as Amazon, AWS, Bedrock, Nova, etc.
+2. Keep all person names untranslated
+3. Keep all company names untranslated
+4. Keep all product names untranslated
+5. Keep all currency amounts untranslated
+6. For content that shouldn't be translated, return the original text
+7. Only return the translation result, without any explanations or original text
+
+Original text: {text}"""
+                    }
+                ]
+            }
+        ],
+        "inferenceConfig": {
+            "max_new_tokens": 1000,
+            "temperature": 0.1
+        }
+    })
+    
+    response = bedrock_client.invoke_model(
+        body=body,
+        modelId="amazon.nova-lite-v1:0",
+        accept="application/json",
+        contentType="application/json"
+    )
+    
+    response_body = json.loads(response.get('body').read())
+    translated_text = response_body['output']['message']['content'][0]['text'].strip()
+    
+    # If the translation result contains "important rules" or "don't translate", return the original text
+    if "重要规则" in translated_text or "不要翻译" in translated_text:
+        return text
+        
+    return translated_text
+
+def _translate_ppt(input_file: str, output_file: str, target_language: str, method: str) -> Dict[str, Any]:
+    """Translate a PowerPoint file"""
+    try:
+        # Load the PPT
+        prs = Presentation(input_file)
+        translated_count = 0
+        
+        # Iterate through all slides
+        for slide_idx, slide in enumerate(prs.slides):
+            logger.info(f"Processing slide {slide_idx + 1}")
+            
+            # Iterate through all shapes in the slide
+            for shape in slide.shapes:
+                try:
+                    if hasattr(shape, "text") and shape.text.strip():
+                        original_text = shape.text.strip()
+                        
+                        # Translate the text
+                        translated_text = _translate_text(original_text, target_language, method)
+                        
+                        if translated_text and translated_text != original_text:
+                            # Update the text while preserving formatting
+                            if hasattr(shape, 'text_frame') and shape.text_frame:
+                                _update_text_frame_with_formatting(shape.text_frame, translated_text)
+                            else:
+                                shape.text = translated_text
+                            
+                            translated_count += 1
+                            logger.info(f"Translated: '{original_text[:50]}...' -> '{translated_text[:50]}...'")
+                except Exception as e:
+                    logger.error(f"Error processing shape: {str(e)}")
+                    continue
+        
+        # Save the translated PPT
+        prs.save(output_file)
+        logger.info(f"Translation completed, saved to: {output_file}")
+        
+        return {"translated_count": translated_count}
+    except Exception as e:
+        logger.error(f"Error translating PPT: {str(e)}")
+        raise
+
+def _update_text_frame_with_formatting(text_frame, new_text):
+    """Update text frame content while preserving original formatting"""
+    try:
+        if not text_frame.paragraphs:
+            return
+        
+        # Save the format of the first paragraph
+        first_paragraph = text_frame.paragraphs[0]
+        if first_paragraph.runs:
+            # Save the format of the first run
+            first_run = first_paragraph.runs[0]
+            font_name = first_run.font.name
+            font_size = first_run.font.size
+            font_bold = first_run.font.bold
+            font_italic = first_run.font.italic
+            
+            # Default to black
+            from pptx.dml.color import RGBColor
+            font_color = RGBColor(0, 0, 0)  # Default black
+            
+            # Safely get the color
+            try:
+                if hasattr(first_run.font, 'color'):
+                    if hasattr(first_run.font.color, 'rgb') and first_run.font.color.rgb:
+                        font_color = first_run.font.color.rgb
+                    elif hasattr(first_run.font.color, 'type'):
+                        # If it's a theme color, we still use default black
+                        pass
+            except Exception as e:
+                logger.error(f"Error getting font color: {str(e)}")
+            
+            # Clear all paragraphs
+            text_frame.clear()
+            
+            # Add new text and apply original formatting
+            paragraph = text_frame.paragraphs[0]
+            # The correct method is to call add_run() directly on the paragraph, not on the runs collection
+            run = paragraph.add_run()
+            run.text = new_text
+            
+            # Restore formatting
+            if font_name:
+                run.font.name = font_name
+            if font_size:
+                run.font.size = font_size
+            if font_bold is not None:
+                run.font.bold = font_bold
+            if font_italic is not None:
+                run.font.italic = font_italic
+            
+            # Set font color
+            run.font.color.rgb = font_color
+        else:
+            # If there are no runs, set the text directly
+            text_frame.text = new_text
+    except Exception as e:
+        logger.error(f"Error updating text formatting: {str(e)}")
+        # If formatting fails, set the text directly
+        text_frame.text = new_text
+
+def translate_ppt(
+    input_file: str,
+    target_language: str = default_target_language,
+    output_file: str = None,
+    translation_method: str = "nova"
+) -> Dict[str, Any]:
+    """Translate a PowerPoint document to the specified language
+    
+    Args:
+        input_file: Path to the input PowerPoint file
+        target_language: Target language code, default is zh-CN
+        output_file: Path to save the translated file, if not provided it will be auto-generated
+        translation_method: Translation method, can be 'nova' or 'claude'
+        
+    Returns:
+        Dict[str, Any]: Translation result information
+    """
+    try:
+        if not input_file:
+            return {"error": "No input file path provided"}
+        
+        if not Path(input_file).exists():
+            return {"error": f"File does not exist: {input_file}"}
+        
+        # Generate output filename
+        if not output_file:
+            input_path = Path(input_file)
+            output_file = str(input_path.parent / f"{input_path.stem}_translated_{target_language}{input_path.suffix}")
+        
+        # Execute translation
+        result = _translate_ppt(input_file, output_file, target_language, translation_method)
+        
+        return {
+            "success": True,
+            "input_file": input_file,
+            "output_file": output_file,
+            "target_language": target_language,
+            "translation_method": translation_method,
+            "translated_texts_count": result.get('translated_count', 0),
+            "message": "PowerPoint translation completed"
+        }
+        
+    except Exception as e:
+        logger.error(f"Error processing request: {str(e)}")
+        return {"error": f"Processing failed: {str(e)}"}
+
+def list_supported_languages() -> Dict[str, str]:
+    """List all supported target languages for translation
+    
+    Returns:
+        Dict[str, str]: Dictionary of language codes and their names
+    """
+    return {
+        "zh-CN": "Simplified Chinese",
+        "zh-TW": "Traditional Chinese",
+        "en": "English",
+        "ja": "Japanese",
+        "ko": "Korean",
+        "fr": "French",
+        "de": "German",
+        "es": "Spanish"
+    }
+
+# MCP protocol implementation
+def handle_mcp_request():
+    """Handle MCP protocol requests"""
+    try:
+        # Read request from stdin
+        request_line = sys.stdin.readline().strip()
+        request = json.loads(request_line)
+        
+        # Process the request
+        if request.get("type") == "invoke":
+            tool_name = request.get("name")
+            params = request.get("params", {})
+            
+            if tool_name == "translate_ppt":
+                result = translate_ppt(
+                    input_file=params.get("input_file"),
+                    target_language=params.get("target_language", default_target_language),
+                    output_file=params.get("output_file"),
+                    translation_method=params.get("translation_method", "nova")
+                )
+                
+                # Send response
+                response = {
+                    "type": "result",
+                    "result": result
+                }
+                sys.stdout.write(json.dumps(response) + "\n")
+                sys.stdout.flush()
+                
+            elif tool_name == "list_supported_languages":
+                result = list_supported_languages()
+                
+                # Send response
+                response = {
+                    "type": "result",
+                    "result": result
+                }
+                sys.stdout.write(json.dumps(response) + "\n")
+                sys.stdout.flush()
+                
+            else:
+                # Unknown tool
+                response = {
+                    "type": "error",
+                    "error": f"Unknown tool: {tool_name}"
+                }
+                sys.stdout.write(json.dumps(response) + "\n")
+                sys.stdout.flush()
+                
+        elif request.get("type") == "describe":
+            # Send server description
+            response = {
+                "type": "description",
+                "name": "PowerPoint Translator",
+                "description": "A service that provides PowerPoint translation capabilities using AWS Bedrock models",
+                "tools": [
+                    {
+                        "name": "translate_ppt",
+                        "description": "Translate PowerPoint documents to a specified language",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "input_file": {
+                                    "type": "string",
+                                    "description": "Path to the input PowerPoint file"
+                                },
+                                "target_language": {
+                                    "type": "string",
+                                    "description": "Target language code (e.g., zh-CN, en, ja, ko, fr, de, es)",
+                                    "default": default_target_language
+                                },
+                                "output_file": {
+                                    "type": "string",
+                                    "description": "Path to save the translated PowerPoint file (if not provided, will be auto-generated)"
+                                },
+                                "translation_method": {
+                                    "type": "string",
+                                    "description": "Translation method to use: 'nova' (faster) or 'claude' (higher quality)",
+                                    "default": "nova",
+                                    "enum": ["nova", "claude"]
+                                }
+                            },
+                            "required": ["input_file"]
+                        }
+                    },
+                    {
+                        "name": "list_supported_languages",
+                        "description": "List all supported target languages for translation",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {}
+                        }
+                    }
+                ]
+            }
+            sys.stdout.write(json.dumps(response) + "\n")
+            sys.stdout.flush()
+            
+        else:
+            # Unknown request type
+            response = {
+                "type": "error",
+                "error": f"Unknown request type: {request.get('type')}"
+            }
+            sys.stdout.write(json.dumps(response) + "\n")
+            sys.stdout.flush()
+            
+    except Exception as e:
+        logger.error(f"Error handling MCP request: {str(e)}")
+        response = {
+            "type": "error",
+            "error": f"Error handling request: {str(e)}"
+        }
+        sys.stdout.write(json.dumps(response) + "\n")
+        sys.stdout.flush()
+
+def main():
+    """Main function"""
+    parser = argparse.ArgumentParser(description='PowerPoint Translator')
+    parser.add_argument('--mcp', action='store_true', help='Run in MCP mode')
+    parser.add_argument('--translate', action='store_true', help='Translate a PowerPoint file')
+    parser.add_argument('--input-file', help='Path to the input PowerPoint file')
+    parser.add_argument('--target-language', default=default_target_language, help='Target language code')
+    parser.add_argument('--output-file', help='Path to save the translated file')
+    parser.add_argument('--method', default='nova', choices=['nova', 'claude'], help='Translation method')
+    parser.add_argument('--list-languages', action='store_true', help='List supported languages')
+    
+    args = parser.parse_args()
+    
+    if args.mcp:
+        print("Starting PowerPoint Translator in MCP mode...")
+        while True:
+            try:
+                handle_mcp_request()
+            except KeyboardInterrupt:
+                break
+            except Exception as e:
+                logger.error(f"Error in MCP mode: {str(e)}")
+                break
+    
+    elif args.translate:
+        if not args.input_file:
+            print("Error: Input file is required for translation")
+            parser.print_help()
+            sys.exit(1)
+            
+        result = translate_ppt(
+            args.input_file,
+            args.target_language,
+            args.output_file,
+            args.method
+        )
+        
+        if 'error' in result:
+            print(f"Error: {result['error']}")
+            sys.exit(1)
+        else:
+            print(f"Translation completed successfully!")
+            print(f"Input file: {result['input_file']}")
+            print(f"Output file: {result['output_file']}")
+            print(f"Target language: {result['target_language']}")
+            print(f"Translation method: {result['translation_method']}")
+            print(f"Translated {result['translated_texts_count']} text elements")
+    
+    elif args.list_languages:
+        languages = list_supported_languages()
+        print("Supported languages:")
+        for code, name in languages.items():
+            print(f"  {code}: {name}")
+    
+    else:
+        # Default to MCP mode when no arguments are provided
+        print("Starting PowerPoint Translator in MCP mode...")
+        # Send initial description
+        response = {
+            "type": "description",
+            "name": "PowerPoint Translator",
+            "description": "A service that provides PowerPoint translation capabilities using AWS Bedrock models",
+            "tools": [
+                {
+                    "name": "translate_ppt",
+                    "description": "Translate PowerPoint documents to a specified language",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "input_file": {
+                                "type": "string",
+                                "description": "Path to the input PowerPoint file"
+                            },
+                            "target_language": {
+                                "type": "string",
+                                "description": "Target language code (e.g., zh-CN, en, ja, ko, fr, de, es)",
+                                "default": default_target_language
+                            },
+                            "output_file": {
+                                "type": "string",
+                                "description": "Path to save the translated PowerPoint file (if not provided, will be auto-generated)"
+                            },
+                            "translation_method": {
+                                "type": "string",
+                                "description": "Translation method to use: 'nova' (faster) or 'claude' (higher quality)",
+                                "default": "nova",
+                                "enum": ["nova", "claude"]
+                            }
+                        },
+                        "required": ["input_file"]
+                    }
+                },
+                {
+                    "name": "list_supported_languages",
+                    "description": "List all supported target languages for translation",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {}
+                    }
+                }
+            ]
+        }
+        sys.stdout.write(json.dumps(response) + "\n")
+        sys.stdout.flush()
+        
+        while True:
+            try:
+                handle_mcp_request()
+            except KeyboardInterrupt:
+                break
+            except Exception as e:
+                logger.error(f"Error in MCP mode: {str(e)}")
+                break
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        sys.exit(1)

package/test_local.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# This script tests the PowerPoint Translator MCP service locally
+
+# Get the directory of this script
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Install dependencies
+echo "Installing dependencies..."
+pip install -r "$SCRIPT_DIR/requirements.txt"
+
+# Create a test PowerPoint file if it doesn't exist
+if [ ! -f "$SCRIPT_DIR/test.pptx" ]; then
+  echo "Creating test PowerPoint file..."
+  python -c "
+from pptx import Presentation
+from pptx.util import Inches
+
+# Create a presentation
+prs = Presentation()
+
+# Add a slide with a title and content
+slide_layout = prs.slide_layouts[1]  # Title and content layout
+slide = prs.slides.add_slide(slide_layout)
+
+# Set the title
+title = slide.shapes.title
+title.text = 'Test PowerPoint for Translation'
+
+# Add content
+content = slide.placeholders[1]
+content.text = 'This is a test PowerPoint file for translation.\n\nIt contains some text that will be translated to another language.\n\nAWS Bedrock is a powerful service for AI/ML tasks.'
+
+# Save the presentation
+prs.save('$SCRIPT_DIR/test.pptx')
+print('Test PowerPoint file created at $SCRIPT_DIR/test.pptx')
+"
+fi
+
+# Run the MCP server
+echo "Starting PowerPoint Translator MCP server..."
+node "$SCRIPT_DIR/index.js"