API 玩出新花样：我如何构建自己的智能翻译助手

用户11286421

发布于 2025-05-19 08:28:17

11600

代码可运行

文章被收录于专栏：学习学习

运行总次数：0

代码可运行

关于蓝耘中的MaaS平台的介绍

MaaS（模型即服务）平台为企业开发者、创业者和非技术用户提供开箱即用的AI模型服务。它支持零代码、API集成和灵活计费，简化AI应用开发，助力业务创新。用户无需训练模型即可通过API等方式使用预训练的机器学习模型。

关于蓝耘中的MaaS的详细文档介绍，我们通过这个链接进行查询文档查询帮助里面的文档介绍可以帮助我们快速的进行上手，让我们更快的了解自己想要使用的API是什么!!!

如图所示，在需要进入这个平台之前，肯定是需要我们注册的下面再附上我们的注册链接点击之后即可直接跳转该平台。

调用API以及切换model

在官方文档当中，也告诉了我们如何正确的接入API，让我们更加高效的使用

仅需要将 model 和 api_key 替换成相关配置，不需要对应用做额外修改，即可无缝将您的应用切换到相应的大模型。

即将下图当中的框起来部分进行修改即可

创建自己的API KEY管理

上面对应的就是API_KEY的复制我们需要进行替换的部分然后将这个API_KEY填写到上面调用代码的api_key里面就行了

model的话就直接选择你想带调用的模型，这里我们可以发现模型广场可以带哦用的类型还是蛮多的 model的话我们选择模型下方的名字就行了

现在我们话又说回来，我现在带着大家完成一下通过这个API调用完成的翻译的软件（并且是可视化的）

现在我调用QwQ-32B的API接口我们只需要将model=“/maas/qwen/QwQ-32B”

并且每一个API调用的模型都有自己的详细介绍，以及一些tokens的扣费介绍等等。

不过对于费用这种东西，不得不说蓝耘平台考虑的很周到，会给新用户提供充足的tokens额度供新用户体验使用，并且很多模型都是最新上线的，随便我们进行调用API

用不完，根本用不完

通过上面的介绍我们已经了解了蓝耘一些基础，现在我们通过API的调用，来进行编写一个关于翻译的软件

软件的编写

我们可以通过和CodeBuddy进行对话，让他帮我生成想要的效果

帮我生成一个本地翻译软件，有可视化界面，通过调用API来实现翻译效果，我会将需要翻译的内容发给你，然后你将信息通过API调用，让AI进行翻译，然后在可视化界面返回翻译的内容

from openai import OpenAI

# 构造 client
client = OpenAI(
    api_key="sk-nlankfqeeubf53ytm26cm4ecuv6zzg3xwxwl224n422zeju7",  # APIKey
    base_url="https://maas-api.lanyun.net/v1",
)
# 流式
stream = True
# 请求
chat_completion = client.chat.completions.create(
    model="/maas/qwen/QwQ-32B",
    messages=[
        {
            "role": "user",
            "content": "你是谁",
        }
    ],
    stream=stream,
)
if stream:
   for chunk in chat_completion:
       # 打印思维链内容
       if hasattr(chunk.choices[0].delta, 'reasoning_content'):
          print(f"{chunk.choices[0].delta.reasoning_content}", end="")
       # 打印模型最终返回的content
       if hasattr(chunk.choices[0].delta, 'content'):
          if chunk.choices[0].delta.content != None and len(chunk.choices[0].delta.content) != 0:
             print(chunk.choices[0].delta.content, end="")
else:
   result = chat_completion.choices[0].message.content

下面是我和CodeBuddy进行对话，然后进行API调用的过程，直接可以通过API帮我生成一个想要的软件（提供强大的算力需求）

translator.py

import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox
from openai import OpenAI
import threading
import json
import os
import pyperclip

class TranslatorApp:
    def __init__(self, root):
        self.root = root
        self.root.title("AI翻译助手")
        self.root.geometry("800x600")
        
        # 默认设置
        self.config = {
            "api_key": "sk-nlankfqeeubf53ytm26cm4ecuv6zzg3xwxwl224n422zeju7",
            "base_url": "https://maas-api.lanyun.net/v1",
            "model": "/maas/qwen/QwQ-32B"
        }
        
        # 加载配置
        self.load_config()
        
        # 设置API客户端
        self.setup_client()
        
        # 创建菜单
        self.create_menu()
        
        # 创建主框架
        self.main_frame = ttk.Frame(self.root, padding="10")
        self.main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # 创建语言选择区域
        self.lang_frame = ttk.Frame(self.main_frame)
        self.lang_frame.grid(row=0, column=0, sticky=(tk.W, tk.E), pady=(0, 10))
        
        self.source_lang_label = ttk.Label(self.lang_frame, text="源语言:")
        self.source_lang_label.grid(row=0, column=0, padx=(0, 5))
        
        self.source_lang = tk.StringVar(value="自动检测")
        self.source_lang_combo = ttk.Combobox(self.lang_frame, textvariable=self.source_lang, 
                                              values=["自动检测", "中文", "英文", "日文", "韩文", "法文", "德文", "西班牙文", "俄文"])
        self.source_lang_combo.grid(row=0, column=1, padx=(0, 20))
        self.source_lang_combo.state(['readonly'])
        
        self.target_lang_label = ttk.Label(self.lang_frame, text="目标语言:")
        self.target_lang_label.grid(row=0, column=2, padx=(0, 5))
        
        self.target_lang = tk.StringVar(value="中文")
        self.target_lang_combo = ttk.Combobox(self.lang_frame, textvariable=self.target_lang,
                                              values=["中文", "英文", "日文", "韩文", "法文", "德文", "西班牙文", "俄文"])
        self.target_lang_combo.grid(row=0, column=3)
        self.target_lang_combo.state(['readonly'])
        
        # 创建输入文本区域
        self.input_label = ttk.Label(self.main_frame, text="请输入要翻译的文本：")
        self.input_label.grid(row=1, column=0, sticky=tk.W, pady=(0, 5))
        
        self.input_text = scrolledtext.ScrolledText(self.main_frame, height=10, width=80)
        self.input_text.grid(row=2, column=0, sticky=(tk.W, tk.E), pady=(0, 10))
        
        # 创建按钮区域
        self.button_frame = ttk.Frame(self.main_frame)
        self.button_frame.grid(row=3, column=0, pady=(0, 10))
        
        self.translate_button = ttk.Button(self.button_frame, text="翻译", command=self.start_translation)
        self.translate_button.grid(row=0, column=0, padx=5)
        
        self.clear_button = ttk.Button(self.button_frame, text="清除", command=self.clear_text)
        self.clear_button.grid(row=0, column=1, padx=5)
        
        # 创建输出文本区域
        self.output_label = ttk.Label(self.main_frame, text="翻译结果：")
        self.output_label.grid(row=4, column=0, sticky=tk.W, pady=(0, 5))
        
        self.output_text = scrolledtext.ScrolledText(self.main_frame, height=10, width=80)
        self.output_text.grid(row=5, column=0, sticky=(tk.W, tk.E))
        
        # 创建复制按钮
        self.copy_button = ttk.Button(self.main_frame, text="复制结果", command=self.copy_result)
        self.copy_button.grid(row=6, column=0, pady=(10, 0), sticky=tk.W)
        
        # 设置窗口可调整大小
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=1)
        self.main_frame.columnconfigure(0, weight=1)
        
        # 创建状态标签
        self.status_label = ttk.Label(self.main_frame, text="就绪")
        self.status_label.grid(row=7, column=0, sticky=tk.W, pady=(5, 0))

    def setup_client(self):
        """设置API客户端"""
        self.client = OpenAI(
            api_key=self.config["api_key"],
            base_url=self.config["base_url"],
        )
    
    def create_menu(self):
        """创建菜单栏"""
        menubar = tk.Menu(self.root)
        self.root.config(menu=menubar)
        
        # 文件菜单
        file_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="文件", menu=file_menu)
        file_menu.add_command(label="退出", command=self.root.quit)
        
        # 设置菜单
        settings_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="设置", menu=settings_menu)
        settings_menu.add_command(label="API设置", command=self.show_api_settings)
        
        # 帮助菜单
        help_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="帮助", menu=help_menu)
        help_menu.add_command(label="关于", command=self.show_about)
    
    def load_config(self):
        """加载配置文件"""
        config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "translator_config.json")
        try:
            if os.path.exists(config_path):
                with open(config_path, "r") as f:
                    loaded_config = json.load(f)
                    # 更新配置，保留默认值
                    for key, value in loaded_config.items():
                        if key in self.config:
                            self.config[key] = value
        except Exception as e:
            print(f"加载配置失败: {e}")
    
    def save_config(self):
        """保存配置文件"""
        config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "translator_config.json")
        try:
            with open(config_path, "w") as f:
                json.dump(self.config, f, indent=4)
        except Exception as e:
            print(f"保存配置失败: {e}")
    
    def show_api_settings(self):
        """显示API设置对话框"""
        settings_window = tk.Toplevel(self.root)
        settings_window.title("API设置")
        settings_window.geometry("500x300")
        settings_window.resizable(False, False)
        settings_window.transient(self.root)
        settings_window.grab_set()
        
        # 创建设置框架
        settings_frame = ttk.Frame(settings_window, padding="20")
        settings_frame.pack(fill=tk.BOTH, expand=True)
        
        # API密钥
        ttk.Label(settings_frame, text="API密钥:").grid(row=0, column=0, sticky=tk.W, pady=5)
        api_key_var = tk.StringVar(value=self.config["api_key"])
        api_key_entry = ttk.Entry(settings_frame, textvariable=api_key_var, width=50)
        api_key_entry.grid(row=0, column=1, sticky=(tk.W, tk.E), pady=5)
        
        # 基础URL
        ttk.Label(settings_frame, text="基础URL:").grid(row=1, column=0, sticky=tk.W, pady=5)
        base_url_var = tk.StringVar(value=self.config["base_url"])
        base_url_entry = ttk.Entry(settings_frame, textvariable=base_url_var, width=50)
        base_url_entry.grid(row=1, column=1, sticky=(tk.W, tk.E), pady=5)
        
        # 模型
        ttk.Label(settings_frame, text="模型:").grid(row=2, column=0, sticky=tk.W, pady=5)
        model_var = tk.StringVar(value=self.config["model"])
        model_entry = ttk.Entry(settings_frame, textvariable=model_var, width=50)
        model_entry.grid(row=2, column=1, sticky=(tk.W, tk.E), pady=5)
        
        # 保存按钮
        def save_settings():
            self.config["api_key"] = api_key_var.get()
            self.config["base_url"] = base_url_var.get()
            self.config["model"] = model_var.get()
            self.save_config()
            self.setup_client()
            settings_window.destroy()
            messagebox.showinfo("成功", "API设置已保存")
        
        ttk.Button(settings_frame, text="保存", command=save_settings).grid(row=3, column=1, sticky=tk.E, pady=20)
    
    def show_about(self):
        """显示关于对话框"""
        messagebox.showinfo("关于", "AI翻译助手\n\n一个使用AI进行文本翻译的工具\n\n版本: 1.0")
    
    def copy_result(self):
        """复制翻译结果到剪贴板"""
        result = self.output_text.get("1.0", tk.END).strip()
        if result:
            pyperclip.copy(result)
            self.status_label.config(text="已复制到剪贴板")
        else:
            self.status_label.config(text="没有可复制的内容")
    
    def clear_text(self):
        """清除输入和输出文本"""
        self.input_text.delete("1.0", tk.END)
        self.output_text.delete("1.0", tk.END)
        self.status_label.config(text="已清除")
    
    def translate_text(self):
        """执行翻译操作"""
        try:
            # 获取输入文本
            input_text = self.input_text.get("1.0", tk.END).strip()
            if not input_text:
                self.status_label.config(text="请输入要翻译的文本")
                return
            
            # 获取语言设置
            source_lang = self.source_lang.get()
            target_lang = self.target_lang.get()
            
            # 更新状态
            self.status_label.config(text="正在翻译...")
            self.translate_button.state(['disabled'])
            self.output_text.delete("1.0", tk.END)
            
            # 构造翻译提示
            system_prompt = f"你是一个专业的翻译助手。"
            
            if source_lang == "自动检测":
                system_prompt += f"请将用户输入的文本翻译成{target_lang}。"
            else:
                system_prompt += f"请将用户输入的{source_lang}文本翻译成{target_lang}。"
                
            system_prompt += "只需要提供翻译结果，不需要解释。"
            
            messages = [
                {
                    "role": "system",
                    "content": system_prompt
                },
                {
                    "role": "user",
                    "content": input_text
                }
            ]
            
            # 调用API进行翻译
            chat_completion = self.client.chat.completions.create(
                model=self.config["model"],
                messages=messages,
                stream=True
            )
            
            # 处理流式响应
            for chunk in chat_completion:
                if hasattr(chunk.choices[0].delta, 'content'):
                    if chunk.choices[0].delta.content:
                        self.output_text.insert(tk.END, chunk.choices[0].delta.content)
                        self.output_text.see(tk.END)
                        self.root.update()
            
            # 更新状态
            self.status_label.config(text="翻译完成")
            
        except Exception as e:
            self.status_label.config(text=f"翻译出错：{str(e)}")
            messagebox.showerror("错误", f"翻译过程中发生错误：\n{str(e)}")
        finally:
            self.translate_button.state(['!disabled'])

    def start_translation(self):
        """在新线程中启动翻译"""
        threading.Thread(target=self.translate_text, daemon=True).start()

def main():
    root = tk.Tk()
    app = TranslatorApp(root)
    root.mainloop()

if __name__ == "__main__":
    main()

requirements.txt