第3课：第一行代码：使用DeepSeek-LM构建最简单的问答机器人

概述

在深入复杂的RAG架构之前，我们首先需要理解大语言模型的核心能力。本文将带领您踏出与大模型交互的第一步——不依赖任何检索增强机制，直接使用DeepSeek-LM的Chat API构建一个基础的问答机器人。通过这个实践，您将直观感受现代大语言模型的强大能力，掌握Prompt Engineering的基本技巧，并为后续更复杂的RAG应用开发奠定坚实基础。

本文将详细讲解DeepSeek API的直接调用方法、对话结构设计、Prompt Engineering原理、响应优化技巧以及错误处理机制。通过详尽的说明和丰富代码示例，您将学会如何构建一个既简单又功能完备的对话应用，充分体验DeepSeek模型在自然语言理解和生成方面的卓越表现。

一、DeepSeek-LM API基础

1.1 API核心概念

DeepSeek-LM通过OpenAI兼容的API接口提供服务，这意味着您可以使用熟悉的OpenAI Python库来调用DeepSeek模型。理解API的基本概念是构建对话应用的第一步。

关键参数说明

模型选择策略

DeepSeek提供多个模型版本，针对不同场景有不同优势：

# 可用模型列表
MODEL_CHOICES = {
    "deepseek-chat": "通用对话模型，平衡性能和速度",
    "deepseek-coder": "专为代码生成优化",
    "deepseek-math": "数学计算和逻辑推理专用",
    "deepseek-creative": "创意写作和内容生成"
}

# 根据场景选择模型
def select_model(task_type):
    model_mapping = {
        "general": "deepseek-chat",
        "coding": "deepseek-coder",
        "math": "deepseek-math",
        "creative": "deepseek-creative"
    }
    return model_mapping.get(task_type, "deepseek-chat")

1.2 认证和初始化

正确的API客户端初始化是成功调用的基础：

import os
from openai import OpenAI
from dotenv import load_dotenv
import logging

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class DeepSeekClient:
    def __init__(self, api_key=None, base_url=None):
        """
        初始化DeepSeek客户端
        
        Args:
            api_key: API密钥，如果为None则从环境变量读取
            base_url: API基础URL
        """
        load_dotenv()  # 加载环境变量
        
        self.api_key = api_key or os.getenv('DEEPSEEK_API_KEY')
        self.base_url = base_url or os.getenv('DEEPSEEK_API_BASE', 'https://api.deepseek.com')
        
        if not self.api_key:
            raise ValueError("DeepSeek API密钥未设置")
        
        # 初始化客户端
        self.client = OpenAI(
            api_key=self.api_key,
            base_url=self.base_url
        )
        
        logger.info("DeepSeek客户端初始化成功")
    
    def validate_connection(self):
        """验证API连接"""
        try:
            response = self.client.chat.completions.create(
                model="deepseek-chat",
                messages=[{"role": "user", "content": "ping"}],
                max_tokens=5
            )
            return True
        except Exception as e:
            logger.error(f"API连接验证失败: {e}")
            return False

二、对话结构设计

2.1 消息角色系统

OpenAI风格的API使用三种基本的消息角色：

# 消息角色定义
MESSAGE_ROLES = {
    "system": "系统角色，设定对话的背景和行为准则",
    "user": "用户角色，代表用户的输入和问题",
    "assistant": "助手角色，模型的回复和响应"
}

class Conversation:
    def __init__(self, system_message=None):
        """
        初始化对话会话
        
        Args:
            system_message: 系统提示词，设定助手的行为特性
        """
        self.messages = []
        
        # 添加系统消息（如果提供）
        if system_message:
            self.add_message("system", system_message)
    
    def add_message(self, role, content):
        """
        添加消息到对话历史
        
        Args:
            role: 消息角色（system/user/assistant）
            content: 消息内容
        """
        if role not in ["system", "user", "assistant"]:
            raise ValueError(f"无效的角色: {role}")
        
        self.messages.append({
            "role": role,
            "content": content.strip()
        })
    
    def add_user_message(self, content):
        """添加用户消息"""
        self.add_message("user", content)
    
    def add_assistant_message(self, content):
        """添加助手消息"""
        self.add_message("assistant", content)
    
    def get_conversation_history(self, max_messages=10):
        """
        获取对话历史，限制长度以避免超出token限制
        
        Args:
            max_messages: 最大消息数量
        Returns:
            最近的消息历史
        """
        return self.messages[-max_messages:] if max_messages else self.messages
    
    def clear_conversation(self):
        """清空对话历史，但保留系统消息"""
        system_messages = [msg for msg in self.messages if msg["role"] == "system"]
        self.messages = system_messages

2.2 对话上下文管理

有效的上下文管理是构建连贯对话的关键：

class ContextManager:
    def __init__(self, max_tokens=4000, max_history=20):
        """
        上下文管理器
        
        Args:
            max_tokens: 最大token限制
            max_history: 最大历史消息数
        """
        self.max_tokens = max_tokens
        self.max_history = max_history
        self.conversation = Conversation()
    
    def estimate_tokens(self, text):
        """
        粗略估计文本的token数量
        实际使用中建议使用tiktoken库进行精确计算
        """
        # 简单估算：1个token ≈ 4个英文字符或2个中文字符
        chinese_chars = sum(1 for char in text if '\u4e00' <= char <= '\u9fff')
        other_chars = len(text) - chinese_chars
        return (chinese_chars // 2) + (other_chars // 4) + 1
    
    def is_context_too_long(self):
        """检查当前上下文是否过长"""
        total_tokens = sum(self.estimate_tokens(msg["content"]) 
                          for msg in self.conversation.messages)
        return total_tokens > self.max_tokens
    
    def optimize_context(self):
        """优化上下文，移除较早的消息但保留系统消息"""
        if not self.is_context_too_long():
            return
        
        # 保留系统消息和最近的消息
        system_messages = [msg for msg in self.conversation.messages 
                          if msg["role"] == "system"]
        recent_messages = self.conversation.messages[-self.max_history:]
        
        # 合并并去重
        optimized_messages = system_messages + recent_messages
        seen = set()
        unique_messages = []
        
        for msg in optimized_messages:
            msg_id = f"{msg['role']}:{msg['content']}"
            if msg_id not in seen:
                seen.add(msg_id)
                unique_messages.append(msg)
        
        self.conversation.messages = unique_messages

三、Prompt Engineering实践

3.1 系统提示词设计

系统提示词是塑造模型行为的最重要工具：

class SystemPromptGenerator:
    @staticmethod
    def create_assistant_prompt(persona="helpful", expertise=None, style=None):
        """
        创建助手系统提示词
        
        Args:
            persona: 助手人格类型
            expertise: 专业领域
            style: 回复风格
        Returns:
            系统提示词字符串
        """
        base_prompts = {
            "helpful": "你是一个乐于助人的AI助手，尽可能准确、详细地回答用户的问题。",
            "concise": "你是一个简洁高效的AI助手，提供直接了当的回答，避免不必要的细节。",
            "friendly": "你是一个友好热情的AI助手，用温暖亲切的语气与用户交流。",
            "professional": "你是一个专业严谨的AI助手，提供准确可靠的信息和建议。"
        }
        
        expertise_prompts = {
            "technical": "你擅长技术问题解答，特别是编程、计算机科学和软件开发领域。",
            "academic": "你专注于学术研究，能够帮助处理论文写作、文献综述等学术任务。",
            "creative": "你具有丰富的创造力，擅长写作、头脑风暴和创意生成。",
            "general": "你拥有广泛的知识面，能够处理各种类型的问题和话题。"
        }
        
        style_prompts = {
            "formal": "请使用正式、专业的语言风格进行回复。",
            "casual": "请使用轻松、随意的口语化风格进行交流。",
            "humorous": "请在适当的时候加入幽默元素，让对话更加有趣。",
            "neutral": "请保持中立、客观的语气，避免表达个人观点。"
        }
        
        # 构建提示词
        prompt_parts = []
        prompt_parts.append(base_prompts.get(persona, base_prompts["helpful"]))
        
        if expertise:
            prompt_parts.append(expertise_prompts.get(expertise, ""))
        
        if style:
            prompt_parts.append(style_prompts.get(style, ""))
        
        # 添加通用指令
        prompt_parts.extend([
            "如果遇到不确定的问题，请诚实地告知用户，不要编造信息。",
            "对于复杂问题，可以要求用户提供更多上下文或澄清问题。",
            "确保回复内容安全、适当，符合道德规范。"
        ])
        
        return " ".join(prompt_parts)
    
    @staticmethod
    def create_task_specific_prompt(task_type, additional_instructions=None):
        """
        创建任务特定的系统提示词
        
        Args:
            task_type: 任务类型
            additional_instructions: 额外指令
        Returns:
            任务特定的提示词
        """
        task_prompts = {
            "qa": """你是一个问答专家，专门回答用户提出的各种问题。请遵循以下原则：
1. 直接回答问题，不要偏离主题
2. 提供准确、可靠的信息
3. 如果信息不确定，明确说明
4. 使用清晰、易懂的语言""",
            
            "translation": """你是一个专业的翻译助手，擅长中英互译。请遵循以下原则：
1. 保持原文的意思和风格
2. 使用自然、流畅的目标语言
3. 处理文化差异和语言习惯
4. 标注翻译中的特殊处理""",
            
            "summarization": """你是一个内容总结专家，能够将长文本浓缩为关键信息。请遵循：
1. 捕捉核心观点和关键信息
2. 保持客观中立，不添加个人观点
3. 根据要求调整总结长度和详细程度
4. 使用清晰的结构组织内容""",
            
            "coding": """你是一个编程助手，帮助解决代码相关问题。请遵循：
1. 提供准确、可工作的代码示例
2. 解释代码的逻辑和原理
3. 考虑最佳实践和性能优化
4. 处理不同的编程语言和框架"""
        }
        
        prompt = task_prompts.get(task_type, task_prompts["qa"])
        
        if additional_instructions:
            prompt += f"\n额外要求: {additional_instructions}"
        
        return prompt

3.2 用户提示词优化

优化用户输入可以提高模型回复质量：

class UserPromptOptimizer:
    @staticmethod
    def enhance_question(question, context=None, question_type=None):
        """
        增强用户问题，提供更多上下文
        
        Args:
            question: 原始问题
            context: 相关上下文
            question_type: 问题类型
        Returns:
            优化后的问题
        """
        enhanced = question.strip()
        
        # 根据问题类型添加指令
        type_instructions = {
            "explanation": "请详细解释以下内容，使用示例说明：",
            "comparison": "请比较以下内容的异同，列出优缺点：",
            "stepbystep": "请提供详细的步骤指导：",
            "definition": "请给出准确的定义并举例说明："
        }
        
        if question_type in type_instructions:
            enhanced = f"{type_instructions[question_type]} {enhanced}"
        
        # 添加上下文信息
        if context:
            enhanced = f"背景信息: {context}\n\n问题: {enhanced}"
        
        # 确保问题完整性
        if not enhanced.endswith(('?', '？', '.', '。')):
            enhanced += "。"
        
        return enhanced
    
    @staticmethod
    def add_response_constraints(question, constraints):
        """
        添加回答约束条件
        
        Args:
            question: 原始问题
            constraints: 约束条件字典
        Returns:
            带约束的问题
        """
        constraint_parts = []
        
        if constraints.get("length"):
            constraint_parts.append(f"回答长度: {constraints['length']}")
        
        if constraints.get("format"):
            constraint_parts.append(f"格式要求: {constraints['format']}")
        
        if constraints.get("language"):
            constraint_parts.append(f"使用语言: {constraints['language']}")
        
        if constraints.get("perspective")`在这里插入代码片`:
            constraint_parts.append(f"视角: {constraints['perspective']}")
        
        if constraint_parts:
            constraints_str = "，".join(constraint_parts)
            return f"{question}（请按照以下要求回答: {constraints_str}）"
        
        return question

四、完整问答机器人实现

4.1 基础问答机器人类

import time
from typing import List, Dict, Optional
from tenacity import retry, stop_after_attempt, wait_exponential

class SimpleChatbot:
    def __init__(self, api_key: Optional[str] = None, 
                 base_url: Optional[str] = None,
                 system_prompt: Optional[str] = None,
                 model: str = "deepseek-chat"):
        """
        初始化简单问答机器人
        
        Args:
            api_key: DeepSeek API密钥
            base_url: API基础URL
            system_prompt: 系统提示词
            model: 使用的模型名称
        """
        self.client = DeepSeekClient(api_key, base_url)
        self.conversation = Conversation(system_prompt)
        self.model = model
        self.context_manager = ContextManager()
        
        # 默认配置
        self.default_params = {
            "temperature": 0.7,
            "max_tokens": 1024,
            "top_p": 0.9,
        }
    
    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
    def generate_response(self, user_input: str, **kwargs) -> str:
        """
        生成对话回复
        
        Args:
            user_input: 用户输入
            **kwargs: 额外的API参数
        Returns:
            模型生成的回复
        """
        try:
            # 添加用户消息到对话历史
            self.conversation.add_user_message(user_input)
            
            # 优化上下文长度
            self.context_manager.optimize_context()
            
            # 准备API参数
            api_params = {**self.default_params, **kwargs}
            
            # 调用API
            response = self.client.client.chat.completions.create(
                model=self.model,
                messages=self.conversation.get_conversation_history(),
                **api_params
            )
            
            # 提取回复内容
            assistant_reply = response.choices[0].message.content
            
            # 添加助手回复到对话历史
            self.conversation.add_assistant_message(assistant_reply)
            
            return assistant_reply
            
        except Exception as e:
            logger.error(f"生成回复时出错: {e}")
            # 从对话历史中移除失败的用户消息
            if self.conversation.messages and self.conversation.messages[-1]["role"] == "user":
                self.conversation.messages.pop()
            raise
    
    def chat_loop(self):
        """启动交互式聊天循环"""
        print("🤖 DeepSeek聊天机器人已启动！输入'退出'或'quit'结束对话。")
        print("-" * 50)
        
        while True:
            try:
                # 获取用户输入
                user_input = input("\n👤 您: ").strip()
                
                # 检查退出条件
                if user_input.lower() in ['退出', 'quit', 'exit', 'q']:
                    print("再见！")
                    break
                
                if not user_input:
                    print("请输入有效的内容...")
                    continue
                
                # 生成回复
                print("🤖 机器人思考中...", end="", flush=True)
                start_time = time.time()
                
                response = self.generate_response(user_input)
                
                elapsed_time = time.time() - start_time
                print(f"\r🤖 DeepSeek: {response}")
                print(f"   ⏱️ 响应时间: {elapsed_time:.2f}秒")
                
            except KeyboardInterrupt:
                print("\n\n对话被用户中断")
                break
            except Exception as e:
                print(f"\n❌ 发生错误: {e}")
                print("请重新尝试...")
    
    def batch_process(self, questions: List[str]) -> List[str]:
        """
        批量处理多个问题
        
        Args:
            questions: 问题列表
        Returns:
            回复列表
        """
        responses = []
        
        for i, question in enumerate(questions, 1):
            try:
                print(f"处理问题 {i}/{len(questions)}: {question[:50]}...")
                response = self.generate_response(question)
                responses.append(response)
                
                # 添加延迟避免速率限制
                time.sleep(0.5)
                
            except Exception as e:
                logger.error(f"处理问题失败: {question} - {e}")
                responses.append(f"错误: {str(e)}")
        
        return responses
    
    def get_conversation_stats(self):
        """获取对话统计信息"""
        user_msgs = sum(1 for msg in self.conversation.messages if msg["role"] == "user")
        assistant_msgs = sum(1 for msg in self.conversation.messages if msg["role"] == "assistant")
        
        return {
            "total_messages": len(self.conversation.messages),
            "user_messages": user_msgs,
            "assistant_messages": assistant_msgs,
            "has_system_prompt": any(msg["role"] == "system" for msg in self.conversation.messages)
        }

4.2 高级功能扩展

class AdvancedChatbot(SimpleChatbot):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.response_history = []
    
    def generate_response_with_retry(self, user_input: str, max_retries: int = 3, **kwargs) -> str:
        """带重试机制的回复生成"""
        for attempt in range(max_retries):
            try:
                return self.generate_response(user_input, **kwargs)
            except Exception as e:
                if attempt == max_retries - 1:
                    raise
                logger.warning(f"尝试 {attempt + 1} 失败，重试...: {e}")
                time.sleep(2 ** attempt)  # 指数退避
    
    def stream_response(self, user_input: str, **kwargs):
        """流式输出回复"""
        try:
            self.conversation.add_user_message(user_input)
            self.context_manager.optimize_context()
            
            # 流式请求
            stream = self.client.client.chat.completions.create(
                model=self.model,
                messages=self.conversation.get_conversation_history(),
                stream=True,
                **{**self.default_params, **kwargs}
            )
            
            print("🤖 DeepSeek: ", end="", flush=True)
            full_response = ""
            
            for chunk in stream:
                if chunk.choices[0].delta.content is not None:
                    content = chunk.choices[0].delta.content
                    print(content, end="", flush=True)
                    full_response += content
            
            print()  # 换行
            self.conversation.add_assistant_message(full_response)
            return full_response
            
        except Exception as e:
            logger.error(f"流式输出失败: {e}")
            if self.conversation.messages and self.conversation.messages[-1]["role"] == "user":
                self.conversation.messages.pop()
            raise
    
    def adjust_parameters_based_on_query(self, query: str) -> Dict:
        """根据查询内容动态调整参数"""
        query_lower = query.lower()
        
        # 默认参数
        params = self.default_params.copy()
        
        # 根据查询类型调整参数
        if any(word in query_lower for word in ['创意', '想象', '故事', '诗歌']):
            params.update({"temperature": 0.9, "max_tokens": 1500})
        elif any(word in query_lower for word in ['代码', '编程', '算法', 'python']):
            params.update({"temperature": 0.2, "max_tokens": 2048})
        elif any(word in query_lower for word in ['数学', '计算', '公式', '证明']):
            params.update({"temperature": 0.1, "max_tokens": 1024})
        elif any(word in query_lower for word in ['解释', '为什么', '如何']):
            params.update({"temperature": 0.7, "max_tokens": 1024})
        
        # 根据查询长度调整token数量
        query_length = len(query)
        if query_length > 500:
            params["max_tokens"] = min(2048, params["max_tokens"] + 500)
        
        return params

五、使用示例和测试

5.1 基础使用示例

def demo_basic_usage():
    """演示基础使用方法"""
    print("=== DeepSeek聊天机器人基础演示 ===\n")
    
    # 初始化机器人
    bot = SimpleChatbot(
        system_prompt=SystemPromptGenerator.create_assistant_prompt(
            persona="friendly",
            expertise="general",
            style="casual"
        )
    )
    
    # 测试连接
    if not bot.client.validate_connection():
        print("❌ API连接失败，请检查配置")
        return
    
    print("✅ API连接成功")
    
    # 示例对话
    test_dialogue = [
        "你好，请介绍一下自己",
        "深度学习是什么？",
        "用Python写一个简单的HTTP服务器",
        "请用中文回答上面的问题"
    ]
    
    for question in test_dialogue:
        print(f"\n👤 提问: {question}")
        try:
            response = bot.generate_response(question)
            print(f"🤖 回复: {response}")
        except Exception as e:
            print(f"❌ 错误: {e}")
    
    # 显示对话统计
    stats = bot.get_conversation_stats()
    print(f"\n📊 对话统计: {stats}")

def demo_advanced_features():
    """演示高级功能"""
    print("\n=== 高级功能演示 ===\n")
    
    # 创建专业翻译机器人
    translator_bot = AdvancedChatbot(
        system_prompt=SystemPromptGenerator.create_task_specific_prompt(
            "translation",
            "请专注于中英互译，保持翻译的准确性和流畅性"
        )
    )
    
    # 流式翻译演示
    text_to_translate = "人工智能是未来科技发展的重要方向，它将改变我们的生活方式和工作方式。"
    print(f"待翻译文本: {text_to_translate}")
    
    print("流式翻译结果:")
    translator_bot.stream_response(f"请将以下中文翻译成英文: {text_to_translate}")
    
    # 参数调整演示
    coder_bot = AdvancedChatbot(
        system_prompt=SystemPromptGenerator.create_task_specific_prompt("coding")
    )
    
    coding_question = "请用Python实现快速排序算法，并添加详细注释"
    params = coder_bot.adjust_parameters_based_on_query(coding_question)
    print(f"\n代码生成参数调整: {params}")
    
    response = coder_bot.generate_response(coding_question, **params)
    print(f"代码生成结果:\n{response}")

def interactive_demo():
    """交互式演示"""
    print("\n=== 交互式聊天演示 ===\n")
    
    # 让用户选择机器人类型
    print("请选择机器人类型:")
    print("1. 通用助手")
    print("2. 技术专家")
    print("3. 创意写手")
    print("4. 学术顾问")
    
    choice = input("请输入选择 (1-4): ").strip()
    
    persona_map = {
        "1": ("helpful", "general", "neutral"),
        "2": ("professional", "technical", "formal"),
        "3": ("friendly", "creative", "humorous"),
        "4": ("professional", "academic", "formal")
    }
    
    persona, expertise, style = persona_map.get(choice, persona_map["1"])
    
    # 创建定制机器人
    bot = SimpleChatbot(
        system_prompt=SystemPromptGenerator.create_assistant_prompt(
            persona, expertise, style
        )
    )
    
    print(f"\n🎭 已创建{['通用助手','技术专家','创意写手','学术顾问'][int(choice)-1]}机器人")
    print("开始聊天吧！输入'退出'结束对话。\n")
    
    # 启动聊天循环
    bot.chat_loop()

if __name__ == "__main__":
    # 运行演示
    demo_basic_usage()
    demo_advanced_features()
    interactive_demo()

5.2 性能测试和评估

def performance_test():
    """性能测试和评估"""
    print("\n=== 性能测试 ===\n")
    
    bot = SimpleChatbot()
    
    # 测试问题集
    test_questions = [
        "什么是机器学习？",
        "解释一下神经网络的基本原理",
        "Python和JavaScript的主要区别是什么？",
        "如何提高深度学习模型的性能？",
        "写一个简单的Python函数计算斐波那契数列"
    ]
    
    total_time = 0
    successful_responses = 0
    
    for i, question in enumerate(test_questions, 1):
        try:
            start_time = time.time()
            response = bot.generate_response(question)
            elapsed = time.time() - start_time
            
            total_time += elapsed
            successful_responses += 1
            
            print(f"{i}. ✅ '{question}' - {elapsed:.2f}秒")
            print(f"   回复长度: {len(response)}字符")
            
        except Exception as e:
            print(f"{i}. ❌ '{question}' - 错误: {e}")
    
    # 输出统计结果
    print(f"\n📊 性能统计:")
    print(f"总问题数: {len(test_questions)}")
    print(f"成功回答: {successful_responses}")
    print(f"成功率: {(successful_responses/len(test_questions))*100:.1f}%")
    print(f"平均响应时间: {total_time/successful_responses:.2f}秒" if successful_responses > 0 else "无成功响应")
    print(f"总耗时: {total_time:.2f}秒")

# 运行性能测试
performance_test()

六、最佳实践和优化建议

6.1 Prompt Engineering最佳实践

1. 明确性: 确保指令清晰明确，避免歧义

2. 上下文提供: 为复杂问题提供足够的背景信息

3. 约束条件: 明确指定回答的长度、格式和风格要求

4. 示例引导: 对于复杂任务，提供输入输出示例

5. 迭代优化: 根据模型响应不断调整和优化提示词

6.2 性能优化策略

1. 缓存响应: 对常见问题缓存回答，减少API调用

2. 批处理: 将多个相关问题组合成单个API调用

3. 连接池: 复用HTTP连接，减少连接建立开销

4. 异步处理: 使用异步IO处理并发请求

5. 监控调整: 监控API使用情况，动态调整请求频率

6.3 错误处理和容错

1. 重试机制: 实现指数退避的重试策略

2. 降级方案: API不可用时提供本地降级服务

3. 输入验证: 验证用户输入，防止无效请求

4. 限流保护: 实施速率限制，避免超过配额

5. 日志记录: 详细记录请求和错误信息

结语

通过本文的详细讲解和丰富示例，您已经掌握了使用DeepSeek-LM构建基础问答机器人的完整技能。从API基础调用到高级Prompt Engineering技巧，从简单的对话交互到复杂的参数优化，您现在具备了直接使用大语言模型API进行应用开发的能力。

这个简单的问答机器人虽然不依赖RAG技术，但已经展现了现代大语言模型的强大能力。在后续的文章中，我们将在此基础上引入检索增强生成技术，构建更加智能和专业的应用系统。

记住，良好的Prompt Engineering和适当的参数调整是获得高质量回复的关键。不断实验和优化您的提示词，您将能够充分发挥DeepSeek模型的潜力，创造出更加智能和有用的对话应用。