API Docs T-Link Question Bank API Platform

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'http://localhost:8888/api';

async function generateQuestions(subject, questionType = 'single', difficulty = 'medium', count = 1, keywords = null, materialFile = null) {
  try {
    if (!materialFile) {
      // Basic question generation (GET request)
      const params = new URLSearchParams({
        token: API_KEY,
        subject: subject,
        type: questionType,
        difficulty: difficulty,
        count: count
      });
      
      if (keywords) {
        params.append('keywords', keywords);
      }
      
      const response = await fetch(`${BASE_URL}/generate?${params.toString()}`);
      const result = await response.json();
      
      if (result.code === 1) {
        return result.questions;
      } else {
        throw new Error(`API request failed: ${result.msg || 'Unknown error'}`);
      }
    } else {
      // File upload question generation (POST request)
      const formData = new FormData();
      formData.append('subject', subject);
      formData.append('type', questionType);
      formData.append('difficulty', difficulty);
      formData.append('count', count);
      
      if (keywords) {
        formData.append('keywords', keywords);
      }
      
      formData.append('material', materialFile);
      
      const response = await fetch(`${BASE_URL}/generate`, {
        method: 'POST',
        headers: {
          'X-API-Key': API_KEY
        },
        body: formData
      });
      
      const result = await response.json();
      
      if (result.code === 1) {
        return result.questions;
      } else {
        throw new Error(`API request failed: ${result.msg || 'Unknown error'}`);
      }
    }
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}

// Usage Examples
generateQuestions('Mathematics', 'single', 'medium', 2, 'functions')
  .then(questions => console.log(`Generated questions:\n${questions}`))
  .catch(error => console.error(`Error: ${error.message}`));

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'http://localhost:8888/api';

async function gradeEssay(content, topic = null, requirements = null, criteria = 'comprehensive', essayFile = null) {
  try {
    const url = `${BASE_URL}/grade`;
    
    if (essayFile) {
      // File upload request
      const formData = new FormData();
      formData.append('criteria', criteria);
      
      if (topic) {
        formData.append('topic', topic);
      }
      
      if (requirements) {
        formData.append('requirements', requirements);
      }
      
      formData.append('essay_file', essayFile);
      
      const response = await fetch(url, {
        method: 'POST',
        headers: {
          'X-API-Key': API_KEY
        },
        body: formData
      });
      
      const result = await response.json();
      
      if (result.code === 1) {
        return result;
      } else {
        throw new Error(`API request failed: ${result.msg || 'Unknown error'}`);
      }
    } else {
      // JSON format request
      const data = {
        content: content,
        criteria: criteria
      };
      
      if (topic) {
        data.topic = topic;
      }
      
      if (requirements) {
        data.requirements = requirements;
      }
      
      const response = await fetch(url, {
        method: 'POST',
        headers: {
          'X-API-Key': API_KEY,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(data)
      });
      
      const result = await response.json();
      
      if (result.code === 1) {
        return result;
      } else {
        throw new Error(`API request failed: ${result.msg || 'Unknown error'}`);
      }
    }
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}

// Usage Examples
const chineseEssay = `
My hometown is a beautiful small county town with mountains and water, picturesque scenery.
In spring, flowers bloom all over the mountains and fields; in summer, green trees provide shade; in autumn, fruits are abundant; in winter, snowflakes dance.
I love my hometown, where I have beautiful childhood memories.
`;

gradeEssay(
  chineseEssay,
  'My Hometown',
  'Requirements: vivid language, specific descriptions, express true feelings',
  'comprehensive'
)
  .then(result => {
    console.log('Grading Result:');
    console.log(`  Language Type: ${result.language}`);
    console.log(`  Word Count: ${result.word_count}`);
    console.log(`  Model Used: ${result.model}`);
    console.log(`  Grading Details: ${result.grading_result.substring(0, 100)}...`);
  })
  .catch(error => console.error(`Error: ${error.message}`));

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'http://localhost:8888/api';

async function generateSimilarQuestions(originalQuestion, options = null, questionType = 'single', count = 3, similarityLevel = 'medium', variationType = 'comprehensive') {
  try {
    const url = `${BASE_URL}/similar`;
    
    const data = {
      question: originalQuestion,
      type: questionType,
      count: count,
      similarity_level: similarityLevel,
      variation_type: variationType
    };
    
    if (options) {
      data.options = options;
    }
    
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'X-API-Key': API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(data)
    });
    
    const result = await response.json();
    
    if (result.code === 1) {
      return result;
    } else {
      throw new Error(`API request failed: ${result.msg || 'Unknown error'}`);
    }
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}

// Usage Examples
// Single choice numerical variation
generateSimilarQuestions(
  'Which of the following is a prime number?',
  'A. 4\nB. 6\nC. 7\nD. 9',
  'single',
  3,
  'medium',
  'numerical'
)
  .then(result => {
    console.log(`Original Question: ${result.original_question}`);
    console.log(`Question Type: ${result.question_type}`);
    console.log(`Similarity Level: ${result.similarity_level}`);
    console.log(`Variation Type: ${result.variation_type}`);
    console.log(`Generated Count: ${result.count}`);
    console.log(`Model Used: ${result.model}`);
    console.log(`Similar Questions:\n${result.similar_questions}`);
  })
  .catch(error => console.error(`Error: ${error.message}`));

// True/False question context variation
generateSimilarQuestions(
  'Earth is the largest planet in the solar system',
  null,
  'judgement',
  2,
  'high',
  'contextual'
)
  .then(result => console.log(`\nTrue/False Similar Questions:\n${result.similar_questions}`))
  .catch(error => console.error(`Error: ${error.message}`));

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'http://localhost:8888/api';

async function explainQuestion(question, options = null, questionType = null, answer = null, explainLevel = 'adaptive', subject = null,
                             studentLevel = 'intermediate', learningStyle = 'balanced', includeExamples = true, 
                             includePractice = true, focusAreas = null) {
  try {
    const url = `${BASE_URL}/explain`;
    
    const data = {
      question: question,
      explain_level: explainLevel,
      student_level: studentLevel,
      learning_style: learningStyle,
      include_examples: includeExamples,
      include_practice: includePractice
    };
    
    if (options) data.options = options;
    if (questionType) data.type = questionType;
    if (answer) data.answer = answer;
    if (subject) data.subject = subject;
    if (focusAreas) data.focus_areas = focusAreas;
    
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'X-API-Key': API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(data)
    });
    
    const result = await response.json();
    
    if (result.code === 1) {
      return result;
    } else {
      throw new Error(`API request failed: ${result.msg || 'Unknown error'}`);
    }
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}

// Usage Examples
// Single choice adaptive explanation
explainQuestion(
  'Which of the following is a prime number?',
  'A. 4\nB. 6\nC. 7\nD. 9',
  'single',
  'C',
  'adaptive',
  'Mathematics',
  'intermediate',
  'visual',
  true,
  true,
  'Number Theory Basics'
)
  .then(result => {
    console.log(`Question: ${result.question}`);
    console.log(`Question Type: ${result.question_type}`);
    console.log(`Explanation Level: ${result.explain_level} (Original: ${result.original_level})`);
    console.log(`Student Level: ${result.student_level}`);
    console.log(`Learning Style: ${result.learning_style}`);
    console.log(`Subject: ${result.subject}`);
    console.log(`Answer: ${result.answer}`);
    console.log(`Model Used: ${result.model}`);
    console.log(`Features: ${JSON.stringify(result.features)}`);
    console.log(`Explanation:\n${result.explanation}`);
  })
  .catch(error => console.error(`Error: ${error.message}`));

// Calculation brief explanation
explainQuestion(
  'Calculate the value of 2 + 3 × 4',
  null,
  'calculation',
  '14',
  'brief',
  'Mathematics',
  'beginner',
  'logical'
)
  .then(result => console.log(`\nCalculation explanation:\n${result.explanation}`))
  .catch(error => console.error(`Error: ${error.message}`));

// Programming comprehensive explanation
explainQuestion(
  'Write a Python function to implement the bubble sort algorithm',
  null,
  'coding',
  null,
  'comprehensive',
  'Computer Science',
  'advanced',
  'kinesthetic',
  true,
  true,
  'Algorithm Basics'
)
  .then(result => console.log(`\nProgramming explanation:\n${result.explanation.substring(0, 200)}...`))
  .catch(error => console.error(`Error: ${error.message}`));

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'http://localhost:8888/api';

async function translateText(text, sourceLang = 'auto', targetLang = 'zh', translateMode = 'standard', domain = 'general', preserveFormat = false) {
  try {
    const url = `${BASE_URL}/translate`;
    
    const data = {
      text: text,
      source_lang: sourceLang,
      target_lang: targetLang,
      translate_mode: translateMode,
      domain: domain,
      preserve_format: preserveFormat
    };
    
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'X-API-Key': API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(data)
    });
    
    const result = await response.json();
    
    if (result.code === 1) {
      return result;
    } else {
      throw new Error(`API request failed: ${result.msg || 'Unknown error'}`);
    }
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}

// Usage Examples
// English to Chinese example
translateText(
  'Hello, world! This is a test of AI translation.',
  'en',
  'zh',
  'standard',
  'general'
)
  .then(result => {
    console.log(`Original Text: ${result.original_text}`);
    console.log(`Translated Text: ${result.translated_text}`);
    console.log(`Translation Mode: ${result.translate_mode}`);
    console.log(`Model Used: ${result.model}`);
  })
  .catch(error => console.error(`Error: ${error.message}`));

// Chinese to English example
translateText(
  'Machine learning is an important branch of artificial intelligence.',
  'zh',
  'en',
  'accurate',
  'academic'
)
  .then(result => console.log(`\nAcademic Translation Result: ${result.translated_text}`))
  .catch(error => console.error(`Error: ${error.message}`));

// Technical document translation
translateText(
  'The API returns a JSON response with HTTP status code 200.',
  'en',
  'zh',
  'standard',
  'technical'
)
  .then(result => console.log(`\nTechnical Translation Result: ${result.translated_text}`))
  .catch(error => console.error(`Error: ${error.message}`));

// Auto-detect language translation
translateText(
  'Bonjour le monde!',
  'auto',
  'zh',
  'standard'
)
  .then(result => {
    console.log(`\nAuto-detect Translation: ${result.translated_text}`);
    console.log(`Detected Target Language: ${result.detected_target_lang}`);
  })
  .catch(error => console.error(`Error: ${error.message}`));

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

import org.json.JSONObject;

public class AnevolGenerateClient {
    private static final String API_KEY = "YOUR_API_KEY";
    private static final String BASE_URL = "http://localhost:8888/api";
    
    public static String generateQuestions(String subject, String questionType, String difficulty, int count, String keywords) throws Exception {
        Map parameters = new HashMap<>();
        parameters.put("token", API_KEY);
        parameters.put("subject", subject);
        parameters.put("type", questionType);
        parameters.put("difficulty", difficulty);
        parameters.put("count", String.valueOf(count));
        
        if (keywords != null && !keywords.isEmpty()) {
            parameters.put("keywords", keywords);
        }
        
        String query = parameters.entrySet().stream()
            .map(e -> e.getKey() + "=" + URLEncoder.encode(e.getValue(), StandardCharsets.UTF_8))
            .collect(Collectors.joining("&"));
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/generate?" + query))
            .build();
        
        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        JSONObject result = new JSONObject(response.body());
        
        if (result.getInt("code") == 1) {
            return result.getString("questions");
        } else {
            throw new Exception("API request failed: " + result.optString("msg", "Unknown error"));
        }
    }
    
    public static void main(String[] args) {
        try {
            String questions = generateQuestions("Mathematics", "single", "medium", 2, "functions");
            System.out.println("Generated questions:\n" + questions);
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;

import org.json.JSONObject;

public class AnevolEssayClient {
    private static final String API_KEY = "YOUR_API_KEY";
    private static final String BASE_URL = "http://localhost:8888/api";
    
    public static JSONObject gradeEssay(String content, String topic, String requirements, String criteria) throws Exception {
        JSONObject data = new JSONObject();
        data.put("content", content);
        data.put("criteria", criteria);
        
        if (topic != null && !topic.isEmpty()) {
            data.put("topic", topic);
        }
        
        if (requirements != null && !requirements.isEmpty()) {
            data.put("requirements", requirements);
        }
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/grade"))
            .header("X-API-Key", API_KEY)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(data.toString(), StandardCharsets.UTF_8))
            .build();
        
        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        JSONObject result = new JSONObject(response.body());
        
        if (result.getInt("code") == 1) {
            return result;
        } else {
            throw new Exception("API request failed: " + result.optString("msg", "Unknown error"));
        }
    }
    
    public static void main(String[] args) {
        try {
            String chineseEssay = "My hometown is a beautiful small county town with mountains and water, picturesque scenery." +
                "In spring, flowers bloom all over the mountains and fields; in summer, green trees provide shade; in autumn, fruits are abundant; in winter, snowflakes dance." +
                "I love my hometown, where I have beautiful childhood memories.";
            
            JSONObject result = gradeEssay(
                chineseEssay,
                "My Hometown",
                "Requirements: vivid language, specific descriptions, express true feelings",
                "comprehensive"
            );
            
            System.out.println("Grading Result:");
            System.out.println("  Language Type: " + result.getString("language"));
            System.out.println("  Word Count: " + result.getInt("word_count"));
            System.out.println("  Model Used: " + result.getString("model"));
            
            String gradingResult = result.getString("grading_result");
            System.out.println("  Grading Details: " + gradingResult.substring(0, Math.min(100, gradingResult.length())) + "...");
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;

import org.json.JSONObject;

public class AnevolSimilarClient {
    private static final String API_KEY = "YOUR_API_KEY";
    private static final String BASE_URL = "http://localhost:8888/api";
    
    public static JSONObject generateSimilarQuestions(String originalQuestion, String options, String questionType, 
                                                     int count, String similarityLevel, String variationType) throws Exception {
        JSONObject data = new JSONObject();
        data.put("question", originalQuestion);
        data.put("type", questionType);
        data.put("count", count);
        data.put("similarity_level", similarityLevel);
        data.put("variation_type", variationType);
        
        if (options != null && !options.isEmpty()) {
            data.put("options", options);
        }
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/similar"))
            .header("X-API-Key", API_KEY)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(data.toString(), StandardCharsets.UTF_8))
            .build();
        
        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        JSONObject result = new JSONObject(response.body());
        
        if (result.getInt("code") == 1) {
            return result;
        } else {
            throw new Exception("API request failed: " + result.optString("msg", "Unknown error"));
        }
    }
    
    public static void main(String[] args) {
        try {
            // Single choice numerical variation example
            JSONObject result1 = generateSimilarQuestions(
                "Which of the following is a prime number?",
                "A. 4\nB. 6\nC. 7\nD. 9",
                "single",
                3,
                "medium",
                "numerical"
            );
            
            System.out.println("Original Question: " + result1.getString("original_question"));
            System.out.println("Question Type: " + result1.getString("question_type"));
            System.out.println("Similarity Level: " + result1.getString("similarity_level"));
            System.out.println("Variation Type: " + result1.getString("variation_type"));
            System.out.println("Generated Count: " + result1.getInt("count"));
            System.out.println("Model Used: " + result1.getString("model"));
            System.out.println("Similar Questions:\n" + result1.getString("similar_questions"));
            
            System.out.println("\n" + "=".repeat(50) + "\n");
            
            // True/False question context variation example
            JSONObject result2 = generateSimilarQuestions(
                "Earth is the largest planet in the solar system",
                null,
                "judgement",
                2,
                "high",
                "contextual"
            );
            
            System.out.println("True/False Similar Questions:\n" + result2.getString("similar_questions"));
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;

import org.json.JSONObject;

public class AnevolExplainClient {
    private static final String API_KEY = "YOUR_API_KEY";
    private static final String BASE_URL = "http://localhost:8888/api";
    
    public static JSONObject explainQuestion(String question, String options, String questionType, 
                                           String answer, String explainLevel, String subject,
                                           String studentLevel, String learningStyle, boolean includeExamples,
                                           boolean includePractice, String focusAreas) throws Exception {
        JSONObject data = new JSONObject();
        data.put("question", question);
        data.put("explain_level", explainLevel != null ? explainLevel : "adaptive");
        data.put("student_level", studentLevel != null ? studentLevel : "intermediate");
        data.put("learning_style", learningStyle != null ? learningStyle : "balanced");
        data.put("include_examples", includeExamples);
        data.put("include_practice", includePractice);
        
        if (options != null && !options.isEmpty()) {
            data.put("options", options);
        }
        if (questionType != null && !questionType.isEmpty()) {
            data.put("type", questionType);
        }
        if (answer != null && !answer.isEmpty()) {
            data.put("answer", answer);
        }
        if (subject != null && !subject.isEmpty()) {
            data.put("subject", subject);
        }
        if (focusAreas != null && !focusAreas.isEmpty()) {
            data.put("focus_areas", focusAreas);
        }
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/explain"))
            .header("X-API-Key", API_KEY)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(data.toString(), StandardCharsets.UTF_8))
            .build();
        
        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        JSONObject result = new JSONObject(response.body());
        
        if (result.getInt("code") == 1) {
            return result;
        } else {
            throw new Exception("API request failed: " + result.optString("msg", "Unknown error"));
        }
    }
    
    public static void main(String[] args) {
        try {
            // Single choice adaptive explanation example
            JSONObject result1 = explainQuestion(
                "Which of the following is a prime number?",
                "A. 4\nB. 6\nC. 7\nD. 9",
                "single",
                "C",
                "adaptive",
                "Mathematics",
                "intermediate",
                "visual",
                true,
                true,
                "Number Theory Basics"
            );
            
            System.out.println("Question: " + result1.getString("question"));
            System.out.println("Question Type: " + result1.getString("question_type"));
            System.out.println("Explanation Level: " + result1.getString("explain_level") + " (Original: " + result1.getString("original_level") + ")");
            System.out.println("Student Level: " + result1.getString("student_level"));
            System.out.println("Learning Style: " + result1.getString("learning_style"));
            System.out.println("Subject: " + result1.getString("subject"));
            System.out.println("Answer: " + result1.getString("answer"));
            System.out.println("Model Used: " + result1.getString("model"));
            System.out.println("Features: " + result1.getJSONObject("features").toString());
            System.out.println("Explanation:\n" + result1.getString("explanation"));
            
            System.out.println("\n" + "=".repeat(50) + "\n");
            
            // Calculation brief explanation example
            JSONObject result2 = explainQuestion(
                "Calculate the value of 2 + 3 × 4",
                null,
                "calculation",
                "14",
                "brief",
                "Mathematics",
                "beginner",
                "logical",
                false,
                false,
                null
            );
            
            System.out.println("Calculation explanation:\n" + result2.getString("explanation"));
            
            System.out.println("\n" + "=".repeat(50) + "\n");
            
            // Programming comprehensive explanation example
            JSONObject result3 = explainQuestion(
                "Write a Python function to implement the bubble sort algorithm",
                null,
                "coding",
                null,
                "comprehensive",
                "Computer Science",
                "advanced",
                "kinesthetic",
                true,
                true,
                "Algorithm Basics"
            );
            
            String explanation = result3.getString("explanation");
            System.out.println("Programming explanation:\n" + 
                explanation.substring(0, Math.min(200, explanation.length())) + "...");
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;

import org.json.JSONObject;

public class AnevolTranslateClient {
    private static final String API_KEY = "YOUR_API_KEY";
    private static final String BASE_URL = "http://localhost:8888/api";
    
    public static JSONObject translateText(String text, String sourceLang, String targetLang, 
                                         String translateMode, String domain, boolean preserveFormat) throws Exception {
        JSONObject data = new JSONObject();
        data.put("text", text);
        data.put("source_lang", sourceLang != null ? sourceLang : "auto");
        data.put("target_lang", targetLang != null ? targetLang : "zh");
        data.put("translate_mode", translateMode != null ? translateMode : "standard");
        data.put("domain", domain != null ? domain : "general");
        data.put("preserve_format", preserveFormat);
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/translate"))
            .header("X-API-Key", API_KEY)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(data.toString(), StandardCharsets.UTF_8))
            .build();
        
        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        JSONObject result = new JSONObject(response.body());
        
        if (result.getInt("code") == 1) {
            return result;
        } else {
            throw new Exception("API request failed: " + result.optString("msg", "Unknown error"));
        }
    }
    
    public static void main(String[] args) {
        try {
            // English to Chinese example
            JSONObject result1 = translateText(
                "Hello, world! This is a test of AI translation.",
                "en",
                "zh",
                "standard",
                "general",
                false
            );
            
            System.out.println("Original Text: " + result1.getString("original_text"));
            System.out.println("Translated Text: " + result1.getString("translated_text"));
            System.out.println("Translation Mode: " + result1.getString("translate_mode"));
            System.out.println("Model Used: " + result1.getString("model"));
            
            System.out.println("\n" + "=".repeat(50) + "\n");
            
            // Chinese to English example
            JSONObject result2 = translateText(
                "Machine learning is an important branch of artificial intelligence.",
                "zh",
                "en",
                "accurate",
                "academic",
                false
            );
            
            System.out.println("Academic Translation Result: " + result2.getString("translated_text"));
            
            System.out.println("\n" + "=".repeat(50) + "\n");
            
            // Technical document translation
            JSONObject result3 = translateText(
                "The API returns a JSON response with HTTP status code 200.",
                "en",
                "zh",
                "standard",
                "technical",
                false
            );
            
            System.out.println("Technical Translation Result: " + result3.getString("translated_text"));
            
            System.out.println("\n" + "=".repeat(50) + "\n");
            
            // Auto-detect language translation
            JSONObject result4 = translateText(
                "Bonjour le monde!",
                "auto",
                "zh",
                "standard",
                "general",
                false
            );
            
            System.out.println("Auto-detect Translation: " + result4.getString("translated_text"));
            System.out.println("Detected Target Language: " + result4.getString("detected_target_lang"));
            
            System.out.println("\n" + "=".repeat(50) + "\n");
            
            // Format preserving translation
            JSONObject result5 = translateText(
                "# Title\n\n## Subtitle\n\n* Item 1\n* Item 2",
                "en",
                "zh",
                "standard",
                "general",
                true
            );
            
            System.out.println("Format Preserving Translation:\n" + result5.getString("translated_text"));
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}