How to handle multi-language inputs correctly in Claude workflows with n8n?

When working with Claude in n8n workflows, handling multi-language inputs requires proper character encoding, language detection, and appropriate processing steps. This ensures Claude accurately processes text in various languages, including those with non-Latin characters like Chinese, Japanese, Arabic, or Cyrillic. The key is to maintain UTF-8 encoding throughout your workflow and properly configure Claude nodes to handle the specific language requirements of your use case.

 

Step 1: Understanding Character Encoding Basics

 

Before diving into n8n specifics, it's important to understand that proper multi-language support requires UTF-8 encoding. UTF-8 is a variable-width character encoding that can represent every character in the Unicode standard, making it ideal for multi-language applications.

In n8n workflows, most text is handled as UTF-8 by default, but issues can arise when:

• Importing data from external sources with different encodings
• Working with APIs that don't properly specify content encoding
• Transforming data between different systems

 

Step 2: Setting Up Your n8n Environment

 

To ensure your n8n environment is ready for multi-language processing:

Check n8n version: Ensure you're using the latest version of n8n, as newer versions have improved Unicode support.

Server configuration: If self-hosting, make sure your database and server configurations support UTF-8:

# For MySQL databases, check that the character set is utf8mb4
SHOW VARIABLES LIKE 'character_set_%';

# For PostgreSQL databases
SHOW server\_encoding;

API settings: When creating HTTP request nodes, set the appropriate content type and encoding:

Content-Type: application/json; charset=utf-8

 

Step 3: Configuring Input Sources for Multi-language Data

 

For HTTP Requests:

1. Navigate to your HTTP Request node
2. In the "Headers" section, add a header that specifies UTF-8 encoding:

   
   {
     "Content-Type": "application/json; charset=utf-8",
     "Accept-Charset": "utf-8"
   }
   

3. If sending form data with non-Latin characters, ensure you set the correct encoding:

   
   {
     "Content-Type": "application/x-www-form-urlencoded; charset=utf-8"
   }
   

For File inputs:

1. When reading files containing multi-language text, use the "Read Binary File" node
2. Follow it with a "Move Binary Data" node to convert the binary data to text
3. Specify UTF-8 encoding during the conversion:

   
   // In Function node after reading binary data
   return {
     json: {
       text: Buffer.from(items[0].binary.data, 'base64').toString('utf8')
     }
   };
   

 

Step 4: Creating a Language Detection Node

 

Before sending text to Claude, it can be helpful to detect the language to apply language-specific processing:

1. Add a "Function" node to your workflow
2. Implement a basic language detection function or use a language detection API
3. Example using the franc library (which you'd need to install on your n8n server):

   
   // This assumes you've installed franc on your n8n server
   // npm install franc
   const franc = require('franc');
   
   // Get the input text from the previous node
   const inputText = items[0].json.text;
   // Detect the language
   const detectedLanguageCode = franc(inputText);
   // Map language code to language name (basic mapping)
   const languageMap = {
     'cmn': 'Chinese',
     'jpn': 'Japanese',
     'kor': 'Korean',
     'rus': 'Russian',
     'ara': 'Arabic',
     'eng': 'English',
     'spa': 'Spanish',
     'fra': 'French',
     'deu': 'German',
     // Add more languages as needed
   };
   const detectedLanguage = languageMap[detectedLanguageCode] || 'Unknown';
   // Return the detected language with the original text
   return {
     json: {
       text: inputText,
       language: detectedLanguage,
       languageCode: detectedLanguageCode
     }
   };
   

Alternatively, you can use the HTTP Request node to call a language detection API:

// Configure HTTP Request node to call Google Cloud Natural Language API
// POST https://language.googleapis.com/v1/documents:analyzeEntities?key=YOUR_API_KEY
// With request body:
{
  "document": {
    "type": "PLAIN\_TEXT",
    "content": "{{$node["Previous\_Node"].json.text}}"
  }
}

 

Step 5: Preprocessing Text Based on Language

 

Different languages might require specific preprocessing before sending to Claude:

1. Add a "Function" node after language detection
2. Implement language-specific preprocessing:

   
   // Get data from previous nodes
   const text = items[0].json.text;
   const language = items[0].json.language;
   
   let processedText = text;
   // Language-specific processing
   switch(language) {
     case 'Chinese':
       // For Chinese, you might want to ensure there are spaces between sentences
       processedText = text.replace(/([。！？])/g, '$1 ').trim();
       break;
     case 'Japanese':
       // For Japanese, you might need to normalize characters
       // This is a simple example - more complex normalization might be needed
       processedText = text.replace(/～/g, '〜').replace(/−/g, '-');
       break;
     case 'Arabic':
       // For Arabic, ensure proper right-to-left rendering markers if needed
       processedText = '\u200F' + text;  // Prepend with RTL mark
       break;
     // Add more language-specific processing as needed
     default:
       // No special processing for other languages
       break;
   }
   // Return the processed text
   return {
     json: {
       originalText: text,
       processedText: processedText,
       language: language
     }
   };
   

 

Step 6: Configuring the Claude Node for Multi-language Inputs

 

When setting up the Claude node in n8n:

1. Navigate to your Claude AI node settings
2. Ensure you're using a model version that supports the languages you need (Claude 3 has excellent multilingual capabilities)
3. Set the appropriate system prompt that acknowledges multi-language input:

   
   You are a multilingual assistant. You will receive text in various languages. 
   Please identify the language if not explicitly stated, and respond in the same language as the input.
   For languages with specialized characters or formatting, maintain those appropriately in your response.
   

4. Pass your preprocessed text to Claude:

   
   {{$node["Preprocess_Text_Node"].json.processedText}}
   

5. Optionally, include language information in your prompt:

   
   The following text is in {{$node["Language_Detection_Node"].json.language}}:
   
   {{$node["Preprocess_Text_Node"].json.processedText}}
   Please process this text while maintaining its original language characteristics.
   

 

Step 7: Adding Language-Specific Instructions to Claude

 

For better results with specific languages, you can provide Claude with language-specific instructions:

// Example function to generate language-specific instructions
function getLanguageInstructions(language) {
  const instructions = {
    'Chinese': 'For Chinese text, please maintain proper character usage and ensure you respond in the same dialect (Simplified or Traditional) as the input.',
    'Japanese': 'For Japanese text, maintain proper use of kanji, hiragana, and katakana. Respect formality levels present in the original text.',
    'Arabic': 'For Arabic text, maintain proper right-to-left formatting and respect dialectal variations if present.',
    'Russian': 'For Russian text, maintain proper grammar and case usage in your responses.',
    // Add more languages as needed
  };
  
  return instructions[language] || 'Please process this text while maintaining its original language characteristics.';
}

// In your Function node before Claude
const language = items[0].json.language;
const text = items[0].json.processedText;
const instructions = getLanguageInstructions(language);

return {
  json: {
    prompt: `The following text is in ${language}:\n\n${text}\n\n${instructions}`
  }
};

 

Step 8: Handling Claude's Multi-language Responses

 

After Claude processes your multi-language input:

1. Add a "Function" node to handle Claude's response
2. Process the response based on the detected input language:

   
   // Get Claude's response and the original language
   const claudeResponse = items[0].json.response; // Adjust based on actual path
   const originalLanguage = items[0].json.language;
   
   // Process response based on language if needed
   let processedResponse = claudeResponse;
   // Example language-specific post-processing
   switch(originalLanguage) {
     case 'Chinese':
       // Any Chinese-specific post-processing
       break;
     case 'Arabic':
       // Remove any incorrect handling of RTL characters if needed
       processedResponse = claudeResponse.replace(/\u200F\u200F/g, '\u200F');
       break;
     // Add more language-specific post-processing as needed
     default:
       // No special processing
       break;
   }
   return {
     json: {
       originalResponse: claudeResponse,
       processedResponse: processedResponse,
       language: originalLanguage
     }
   };
   

 

Step 9: Validating Multi-language Outputs

 

To ensure your workflow produces valid multi-language content:

1. Add a validation step with a "Function" node:

   
   // Simple validation for common issues with multi-language text
   const text = items[0].json.processedResponse;
   const language = items[0].json.language;
   
   let validationIssues = [];
   // Check for common encoding issues
   if (text.includes('�')) {
     validationIssues.push('Text contains replacement characters, indicating encoding issues');
   }
   // Language-specific validation
   switch(language) {
     case 'Chinese':
       // Check for appropriate character density
       if (text.length > 0 && text.replace(/\s+/g, '').length / text.length < 0.5) {
         validationIssues.push('Chinese text has unusually low character density');
       }
       break;
     case 'Japanese':
       // Check for appropriate mix of character types
       const hasKanji = /[\u4E00-\u9FAF]/.test(text);
       const hasHiragana = /[\u3040-\u309F]/.test(text);
       if (text.length > 20 && (!hasKanji || !hasHiragana)) {
         validationIssues.push('Japanese text is missing expected character types');
       }
       break;
     // Add more language-specific validation as needed
   }
   return {
     json: {
       text: text,
       language: language,
       isValid: validationIssues.length === 0,
       validationIssues: validationIssues
     }
   };
   

 

Step 10: Creating a Complete Multi-language Claude Workflow

 

Here's how to create a complete workflow that handles multi-language input for Claude:

1. Start with an input node (HTTP Request, Webhook, Form Trigger, etc.)
2. Add a "Function" node to extract and normalize the input text:

   
   // Example for extracting text from various input sources
   let inputText;
   
   if (items[0].json.text) {
     // Direct text input
     inputText = items[0].json.text;
   } else if (items[0].json.body && typeof items[0].json.body === 'string') {
     // Text from HTTP request body
     inputText = items[0].json.body;
   } else if (items[0].binary && items[0].binary.data) {
     // Text from binary data (e.g., file upload)
     inputText = Buffer.from(items[0].binary.data, 'base64').toString('utf8');
   } else {
     // Fallback
     inputText = JSON.stringify(items[0].json);
   }
   // Normalize line endings
   inputText = inputText.replace(/\r\n/g, '\n');
   return {
     json: {
       text: inputText
     }
   };
   

3. Add the Language Detection node (as described in Step 4)
4. Add the Language-specific Preprocessing node (as described in Step 5)
5. Add the Claude AI node with appropriate system prompt and language instructions
6. Add the Response Processing node (as described in Step 8)
7. Add the Validation node (as described in Step 9)
8. Add an output node (HTTP Response, Send Email, Save to Database, etc.)

 

Step 11: Optimizing Claude for Specific Languages

 

For certain languages, you can further optimize Claude's performance:

Chinese and Japanese:

// In your prompt to Claude:
const prompt = \`
The following text is in ${language}:

${text}

Please analyze this text carefully. For Chinese/Japanese text:
1. Pay attention to the specific characters and their nuances
2. Maintain the same level of formality in your response
3. If the text uses Simplified Chinese, respond in Simplified Chinese
4. If the text uses Traditional Chinese, respond in Traditional Chinese
5. For Japanese, maintain the appropriate use of keigo (honorific language) if present

Your response:
\`;

Arabic and other RTL languages:

// In your prompt to Claude:
const prompt = \`
The following text is in ${language}:

${text}

For Arabic or other right-to-left languages:
1. Maintain proper directional formatting
2. Respect dialectal variations in your response
3. Maintain proper handling of numbers and punctuation
4. Keep any embedded English or other left-to-right language segments properly formatted

Your response:
\`;

 

Step 12: Implementing Error Handling for Multi-language Processing

 

Add robust error handling to your workflow:

// Error handling function node
try {
  // Get text and language from previous nodes
  const text = items[0].json.text || '';
  const language = items[0].json.language || 'Unknown';
  
  // Check for common issues
  if (!text || text.trim() === '') {
    throw new Error('Empty input text');
  }
  
  // Language-specific checks
  if (language === 'Chinese' && !/[\u4E00-\u9FFF]/.test(text)) {
    throw new Error('Text identified as Chinese but contains no Chinese characters');
  }
  
  if (language === 'Japanese' && !/[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FFF]/.test(text)) {
    throw new Error('Text identified as Japanese but contains no Japanese characters');
  }
  
  if (language === 'Arabic' && !/[\u0600-\u06FF]/.test(text)) {
    throw new Error('Text identified as Arabic but contains no Arabic characters');
  }
  
  // If we reach here, all checks passed
  return {
    json: {
      text: text,
      language: language,
      status: 'valid'
    }
  };
  
} catch (error) {
  // Handle the error
  return {
    json: {
      error: error.message,
      text: items[0].json.text || '',
      language: items[0].json.language || 'Unknown',
      status: 'error'
    }
  };
}

Add an "IF" node to route the workflow based on the error status:

// Condition for the IF node
return items[0].json.status === 'valid';

 

Step 13: Testing Your Multi-language Workflow

 

Create a test suite for your multi-language workflow:

1. Prepare test inputs in different languages:
2. Add a "Code" node at the beginning of your workflow for testing:

   
   // Test suite for multi-language inputs
   const testCases = [
     {
       name: 'English Test',
       text: 'This is a sample English text to test the multi-language capabilities.',
       expectedLanguage: 'English'
     },
     {
       name: 'Chinese Test',
       text: '这是一个中文测试样本，用于测试多语言处理能力。',
       expectedLanguage: 'Chinese'
     },
     {
       name: 'Japanese Test',
       text: 'これは多言語処理能力をテストするためのサンプル日本語テキストです。',
       expectedLanguage: 'Japanese'
     },
     {
       name: 'Arabic Test',
       text: 'هذا نص عربي عينة لاختبار قدرات اللغة المتعددة.',
       expectedLanguage: 'Arabic'
     },
     {
       name: 'Russian Test',
       text: 'Это образец русского текста для проверки возможностей многоязычной обработки.',
       expectedLanguage: 'Russian'
     },
     {
       name: 'Mixed Language Test',
       text: 'This text contains multiple languages: 中文, 日本語, and العربية.',
       expectedLanguage: 'English' // Primary language is English
     }
   ];
   
   // Choose which test to run (0-5)
   const testIndex = 0; // Change this to run different tests
   const currentTest = testCases[testIndex];
   return {
     json: {
       testName: currentTest.name,
       text: currentTest.text,
       expectedLanguage: currentTest.expectedLanguage
     }
   };
   

3. Add a "Function" node at the end of your workflow to validate test results:

   
   // Test validation
   const testName = items[0].json.testName;
   const expectedLanguage = items[0].json.expectedLanguage;
   const detectedLanguage = items[0].json.language;
   const claudeResponse = items[0].json.processedResponse;
   
   const languageCorrect = detectedLanguage === expectedLanguage;
   const responseNotEmpty = claudeResponse && claudeResponse.trim().length > 0;
   // For mixed language test, check if all languages are mentioned in the analysis
   const isMixedTest = testName === 'Mixed Language Test';
   const containsAllLanguages = isMixedTest ?
     (claudeResponse.includes('Chinese') &&
      claudeResponse.includes('Japanese') &&
      claudeResponse.includes('Arabic')) : true;
   const testPassed = languageCorrect && responseNotEmpty && containsAllLanguages;
   return {
     json: {
       testName: testName,
       passed: testPassed,
       details: {
         languageDetectionCorrect: languageCorrect,
         expectedLanguage: expectedLanguage,
         detectedLanguage: detectedLanguage,
         responseNotEmpty: responseNotEmpty,
         containsAllLanguages: containsAllLanguages
       },
       response: claudeResponse
     }
   };
   

 

Step 14: Implementing Language-Aware Response Formatting

 

When formatting Claude's responses for display or further processing, consider language-specific requirements:

// Language-aware formatting function
function formatResponseForOutput(text, language) {
  let formattedText = text;
  
  switch(language) {
    case 'Chinese':
    case 'Japanese':
      // For CJK languages, ensure proper line breaking
      // Avoid breaking between characters without spaces
      formattedText = `
${text}
`;
      break;
      
    case 'Arabic':
    case 'Hebrew':
      // For RTL languages, ensure proper direction
      formattedText = `
${text}
`;
      break;
      
    case 'Thai':
      // Thai needs special word-breaking rules
      formattedText = `
${text}
`;
      break;
      
    default:
      // For most languages, standard formatting is fine
      formattedText = `
${text}
`;
      break;
  }
  
  return formattedText;
}

// In your Function node
const response = items[0].json.processedResponse;
const language = items[0].json.language;

return {
  json: {
    rawResponse: response,
    formattedResponse: formatResponseForOutput(response, language),
    language: language
  }
};

 

Step 15: Creating a Multilingual Chatbot with n8n and Claude

 

To build a complete multilingual chatbot:

1. Create a "Webhook" node to receive user messages
2. Add the language detection and preprocessing steps described earlier
3. Implement session management to maintain conversation context:

   
   // Session management in Function node
   // This assumes you're using cookies or headers for session IDs
   const sessionId = items[0].json.headers['x-session-id'] || 'default-session';
   const inputText = items[0].json.text;
   const language = items[0].json.language;
   
   // In a production environment, you would use a database
   // This is a simplified in-memory approach for demonstration
   const sessionStorage = {
     // This would normally be retrieved from a database
       conversationHistory: $('sessionData').json?.[sessionId]?.conversationHistory || [],
       detectedLanguage: $('sessionData').json?.[sessionId]?.detectedLanguage || language
     }
   };
   // Update conversation history
   sessionStorage[sessionId].conversationHistory.push({
     role: 'user',
     content: inputText
   });
   // If language changes within a session, note it but maintain primary language
   if (language !== sessionStorage[sessionId].detectedLanguage) {
     sessionStorage[sessionId].languageChanged = true;
     // Only update if we're confident in the new language detection
     if (inputText.length > 50) {
       sessionStorage[sessionId].detectedLanguage = language;
     }
   }
   // Limit conversation history length
   if (sessionStorage[sessionId].conversationHistory.length > 10) {
     sessionStorage[sessionId].conversationHistory =
       sessionStorage[sessionId].conversationHistory.slice(-10);
   }
   return {
     json: {
       text: inputText,
       language: sessionStorage[sessionId].detectedLanguage,
       sessionId: sessionId,
       conversationHistory: sessionStorage[sessionId].conversationHistory,
       languageChanged: sessionStorage[sessionId].languageChanged || false
     }
   };
   

4. Configure Claude with conversation context:

   
   // Format conversation history for Claude
   const conversationHistory = items[0].json.conversationHistory;
   const language = items[0].json.language;
   const languageChanged = items[0].json.languageChanged;
   
   let formattedHistory = '';
   for (const message of conversationHistory.slice(0, -1)) {
     formattedHistory += ${message.role === 'user' ? 'Human' : 'Assistant'}: ${message.content}\n\n;
   }
   // Current message is handled separately
   const currentMessage = conversationHistory[conversationHistory.length - 1].content;
   // Build the prompt for Claude
   let prompt = '';
   if (conversationHistory.length > 1) {
     prompt = You are having a conversation with a user in ${language}.\n\n;
     if (languageChanged) {
       prompt += Note: The user appears to have switched to ${language}. Please respond in this language going forward.\n\n;
     }
     prompt += Previous conversation:\n${formattedHistory}\n;
     prompt += Human: ${currentMessage}\n\nAssistant:;
   } else {
     prompt = Human: ${currentMessage}\n\nAssistant:;
   }
   return {
     json: {
       prompt: prompt,
       language: language,
       sessionId: items[0].json.sessionId
     }
   };
   

5. Store Claude's response in the session:

   
   // After Claude responds, update the conversation history
   const sessionId = items[0].json.sessionId;
   const claudeResponse = items[0].json.response;
   const language = items[0].json.language;
   
   // In a production environment, you would use a database
   // This is a simplified in-memory approach
   const sessionStorage = {
     // This would normally be retrieved from a database
       conversationHistory: $('sessionData').json?.[sessionId]?.conversationHistory || [],
       detectedLanguage: language
     }
   };
   // Add Claude's response to conversation history
   sessionStorage[sessionId].conversationHistory.push({
     role: 'assistant',
     content: claudeResponse
   });
   // Store updated session data
   $('sessionData').setData(sessionStorage);
   return {
     json: {
       response: claudeResponse,
       language: language,
       sessionId: sessionId
     }
   };
   

 

Step 16: Implementing Translation Capabilities When Needed

 

Sometimes you may want to translate inputs or outputs:

// Function to call a translation API
// This example uses Google Cloud Translation API
async function translateText(text, sourceLang, targetLang) {
  // Configure HTTP request to translation API
  const options = {
    method: 'POST',
    url: 'https://translation.googleapis.com/v2',
    qs: {
      key: 'YOUR_GOOGLE_API\_KEY' // Replace with your actual API key
    },
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      q: text,
      source: getLanguageCode(sourceLang),
      target: getLanguageCode(targetLang),
      format: 'text'
    })
  };
  
  // In a real implementation, you would make the actual HTTP request here
  // For this example, we'll simulate a response
  console.log('Translation request:', options);
  
  // Mock translation response
  return `[Translated from ${sourceLang} to ${targetLang}]: ${text}`;
}

// Helper function to convert language names to ISO codes
function getLanguageCode(language) {
  const languageCodes = {
    'English': 'en',
    'Spanish': 'es',
    'French': 'fr',
    'German': 'de',
    'Chinese': 'zh',
    'Japanese': 'ja',
    'Korean': 'ko',
    'Russian': 'ru',
    'Arabic': 'ar',
    // Add more as needed
  };
  
  return languageCodes[language] || 'en';
}

// In your Function node
const text = items[0].json.text;
const detectedLanguage = items[0].json.language;
const targetLanguage = 'English'; // Change as needed

// Only translate if the language isn't already the target language
let translatedText = text;
let needsTranslation = detectedLanguage !== targetLanguage;

if (needsTranslation) {
  translatedText = await translateText(text, detectedLanguage, targetLanguage);
}

return {
  json: {
    originalText: text,
    originalLanguage: detectedLanguage,
    translatedText: translatedText,
    targetLanguage: targetLanguage,
    wasTranslated: needsTranslation
  }
};

 

Step 17: Implementing Multi-language Content Generation with Claude

 

For generating content in multiple languages:

// Function to generate content prompts for multiple languages
function generateMultilingualPrompts(basePrompt, languages) {
  const prompts = {};
  
  languages.forEach(language => {
    let languageSpecificPrompt = basePrompt;
    
    // Add language-specific instructions
    languageSpecificPrompt += `\n\nGenerate this content in ${language}.`;
    
    // Add language-specific considerations
    switch(language) {
      case 'Chinese':
        languageSpecificPrompt += ' Use Simplified Chinese characters unless specified otherwise. Ensure appropriate formal tone for business communication.';
        break;
      case 'Japanese':
        languageSpecificPrompt += ' Use appropriate keigo (formal language) for business communication. Include common business Japanese phrases where appropriate.';
        break;
      case 'German':
        languageSpecificPrompt += ' Use appropriate formal language (Sie form) for business communication.';
        break;
      // Add more languages as needed
    }
    
    prompts[language] = languageSpecificPrompt;
  });
  
  return prompts;
}

// In your Function node
const basePrompt = 'Create a product description for our new wireless headphones with noise cancellation features.';
const targetLanguages = ['English', 'Chinese', 'Japanese', 'German', 'Spanish'];

const multilingualPrompts = generateMultilingualPrompts(basePrompt, targetLanguages);

// Now you can either:
// 1. Return all prompts and use a Split node to process each language separately
// 2. Process one language at a time

// Option 1: Return all prompts
return {
  json: {
    prompts: multilingualPrompts,
    languages: targetLanguages
  }
};

// Option 2: Process one language at a time (for example, just Chinese)
/\*
return {
  json: {
    prompt: multilingualPrompts['Chinese'],
    language: 'Chinese'
  }
};
\*/

 

Step 18: Custom Function for Japanese Text Processing

 

Japanese text often requires special handling:

// Function for Japanese text preprocessing
function preprocessJapaneseText(text) {
  // Replace full-width alphanumerics with half-width when appropriate
  // This is sometimes needed for technical content
  let processed = text.replace(/[Ａ-Ｚａ-ｚ０-９]/g, function(s) {
    return String.fromCharCode(s.charCodeAt(0) - 0xFEE0);
  });
  
  // Normalize Japanese quotes
  processed = processed.replace(/「/g, '「').replace(/」/g, '」');
  
  // Ensure proper Japanese punctuation
  processed = processed.replace(/.\s/g, '。');
  processed = processed.replace(/!\s/g, '！');
  processed = processed.replace(/?\s/g, '？');
  
  // Add spaces after Japanese sentence endings if missing
  processed = processed.replace(/([。！？])/g, '$1 ');
  
  return processed;
}

// In your Function node
const text = items[0].json.text;
const language = items[0].json.language;

let processedText = text;

if (language === 'Japanese') {
  processedText = preprocessJapaneseText(text);
}

return {
  json: {
    originalText: text,
    processedText: processedText,
    language: language
  }
};

 

Step 19: Custom Function for Chinese Text Processing

 

For Chinese text processing:

// Function for Chinese text preprocessing
function preprocessChineseText(text, targetVariant = 'simplified') {
  // Note: For complete conversion between Simplified and Traditional Chinese,
  // you would typically use a library like OpenCC or a cloud API
  
  // This is a simplified example with some common character mappings
  const simplifiedToTraditional = {
    '国': '國', '东': '東', '车': '車', '马': '馬', '长': '長',
    '华': '華', '图': '圖', '书': '書', '电': '電', '话': '話'
    // This is just a small subset - a real implementation would include thousands
  };
  
  const traditionalToSimplified = {};
  Object.keys(simplifiedToTraditional).forEach(key => {
    traditionalToSimplified[simplifiedToTraditional[key]] = key;
  });
  
  let processed = text;
  
  // Detect if the text is predominantly Simplified or Traditional
  // This is a very simple heuristic - a real implementation would be more sophisticated
  let simplifiedCount = 0;
  let traditionalCount = 0;
  
  for (let char of text) {
    if (simplifiedToTraditional[char]) simplifiedCount++;
    if (traditionalToSimplified[char]) traditionalCount++;
  }
  
  const detectedVariant = simplifiedCount > traditionalCount ? 'simplified' : 'traditional';
  
  // Convert if needed
  if (detectedVariant !== targetVariant) {
    if (targetVariant === 'traditional') {
      // Convert simplified to traditional
      for (let char in simplifiedToTraditional) {
        processed = processed.replace(new RegExp(char, 'g'), simplifiedToTraditional[char]);
      }
    } else {
      // Convert traditional to simplified
      for (let char in traditionalToSimplified) {
        processed = processed.replace(new RegExp(char, 'g'), traditionalToSimplified[char]);
      }
    }
  }
  
  // Add spaces after Chinese sentence endings if missing
  processed = processed.replace(/([。！？])/g, '$1 ');
  
  return {
    text: processed,
    detectedVariant: detectedVariant,
    targetVariant: targetVariant
  };
}

// In your Function node
const text = items[0].json.text;
const language = items[0].json.language;
const targetVariant = 'simplified'; // or 'traditional'

let processedText = text;
let textInfo = {};

if (language === 'Chinese') {
  const result = preprocessChineseText(text, targetVariant);
  processedText = result.text;
  textInfo = {
    detectedVariant: result.detectedVariant,
    targetVariant: result.targetVariant
  };
}

return {
  json: {
    originalText: text,
    processedText: processedText,
    language: language,
    ...textInfo
  }
};

 

Step 20: Implementing Multi-language User Interface Instructions

 

For workflows that include user interface elements:

// Function to generate UI instructions in different languages
function getUIInstructions(language) {
  const instructions = {
    'English': {
      welcomeMessage: 'Welcome to our multilingual assistant. Please type your question.',
      inputPlaceholder: 'Type your message here...',
      sendButton: 'Send',
      errorMessage: 'Sorry, there was an error processing your request.',
      loadingMessage: 'Processing your request...'
    },
    'Spanish': {
      welcomeMessage: 'Bienvenido a nuestro asistente multilingüe. Por favor, escriba su pregunta.',
      inputPlaceholder: 'Escriba su mensaje aquí...',
      sendButton: 'Enviar',
      errorMessage: 'Lo sentimos, hubo un error al procesar su solicitud.',
      loadingMessage: 'Procesando su solicitud...'
    },
    'Chinese': {
      welcomeMessage: '欢迎使用我们的多语言助手。请输入您的问题。',
      inputPlaceholder: '在此输入您的消息...',
      sendButton: '发送',
      errorMessage: '抱歉，处理您的请求时出错。',
      loadingMessage: '正在处理您的请求...'
    },
    'Japanese': {
      welcomeMessage: '多言語アシスタントへようこそ。ご質問を入力してください。',
      inputPlaceholder: 'メッセージをここに入力してください...',
      sendButton: '送信',
      errorMessage: '申し訳ありませんが、リクエストの処理中にエラーが発生しました。',
      loadingMessage: 'リクエストを処理中...'
    },
    'Arabic': {
      welcomeMessage: 'مرحبًا بك في مساعدنا متعدد اللغات. يرجى كتابة سؤالك.',
      inputPlaceholder: 'اكتب رسالتك هنا...',
      sendButton: 'إرسال',
      errorMessage: 'عذرًا، حدث خطأ أثناء معالجة طلبك.',
      loadingMessage: 'جاري معالجة طلبك...'
    }
    // Add more languages as needed
  };
  
  return instructions[language] || instructions['English'];
}

// In your Function node
const language = items[0].json.language || 'English';
const uiInstructions = getUIInstructions(language);

return {
  json: {
    ...items[0].json,
    ui: uiInstructions
  }
};

By following these detailed steps, you can create robust n8n workflows that properly handle multi-language inputs with Claude, ensuring accurate processing of text in various languages, from input preparation to language detection, processing, and response formatting. This comprehensive approach helps maintain the integrity and accuracy of your multi-language applications.