用DeepSeek在小程序开发中的别样用法

const getWordExplanation = async (word) => {
    try {
        const completion = await openai.chat.completions.create({
            model: CONFIG.openai.model,
            messages: [
                {
                    role: "system",
                    content: `你是一个中文语言专家，请用JSON格式解释汉字，包含以下字段：
                    character: 汉字
                    pinyin: 拼音（不带声调）
                    symbol: 拼音（带声调）
                    meaning: 含义数组，每个元素包含：
                        - property: 词性
                        - definition: 该词性下的含义
                    group: 包含该字的常用词组（数组）
                    sentence: 包含该字的例句（数组）
                    请确保返回的是合法的JSON格式。`
                },
                {
                    role: "user",
                    content: `请解释汉字："${word.character}"（拼音：${word.pinyin}）`
                }
            ],
            temperature: CONFIG.openai.temperature,
            max_tokens: CONFIG.openai.maxTokens
        });

        const response = completion.choices[0].message.content;
        try {
            const cleanResponse = response.replace(/^```json\n?/, '').replace(/\n?```$/, '').trim();
            const parsedResponse = JSON.parse(cleanResponse);

            // 确保meaning是数组格式
            if (typeof parsedResponse.meaning === 'string') {
                parsedResponse.meaning = [{
                    property: parsedResponse.property || '未知',
                    definition: parsedResponse.meaning
                }];
            }
            return parsedResponse;
        } catch (e) {
            console.error(`Error parsing JSON for word ${word.character}:`, e);
            // 如果解析失败，创建默认数据
            const defaultWordData = createDefaultWordData(word.character, word.pinyin);
            defaultWordData.error = true;
            return defaultWordData;
        }
    } catch (error) {
        console.error(`Error getting explanation for word ${word.character}:`, error);
        // 如果API调用失败，创建默认数据
        const defaultWordData = createDefaultWordData(word.character, word.pinyin);
        defaultWordData.error = true;
        return defaultWordData;
    }
};

// 云函数入口函数
exports.main = async (event, context) => {
    const { audioData } = event
    //   console.log("audioData", audioData);

    try {
        // 创建语音识别客户端
        const client = new AsrClient(clientAsrConfig)

        // 调用语音识别接口
        const params = {
            EngSerViceType: "16k_zh", // 16k采样率中文语音识别
            SourceType: 1,
            VoiceFormat: "mp3",
            Data: audioData,
            DataLen: audioData.length
        }

        const result = await client.SentenceRecognition(params)
        console.log("result", result);

        if (!result || !result.Result) {
            return {
                success: false,
                error: '语音识别失败'
            }
        }

        // 调用腾讯云 DeepSeek 接口获取汉字
        const recognizedText = result.Result
        const LkeapClient = tencentcloud.lkeap.v20240522.Client;
        const deepseekClient = new LkeapClient(clientDeepseekConfig)

        const deepseekParams = {
            Messages: [
                {
                    Role: "system",
                    Content: "你是一个汉字识别专家，请分析以下语音识别结果，如果是在询问某个汉字的写法，请直接返回该汉字。如果不是，请将结果转换为汉字。最多返回4个汉字。"
                },
                {
                    Role: "user",
                    Content: recognizedText
                }
            ],
            Model: "deepseek-v3-0324"
        }
        const deepseekResult = await deepseekClient.ChatCompletions(deepseekParams)
        console.log("deepseekResult", deepseekResult);

        if (!deepseekResult || !deepseekResult.Choices) {
            return {
                success: false,
                error: '汉字转换失败'
            }
        }

        const characters = deepseekResult.Choices[0].Message.Content.split('')
        console.log("characters", characters);

        // 查询数据库获取汉字详情
        const wordPromises = characters.map(char =>
            charactersCollection.where({
                character: char
            }).get()
        )

        const wordResults = await Promise.all(wordPromises)
        const matchedCharacters = wordResults
            .filter(result => result.data && result.data.length > 0)
            .map(result => result.data[0])

        console.log("matchedCharacters", matchedCharacters);

        return {
            success: true,
            data: {
                recognizedText,
                characters: matchedCharacters
            }
        }

    } catch (err) {
        console.error('Error:', err)
        return {
            success: false,
            error: err.message || '处理失败'
        }
    }
}