码字不易，请大佬们点点关注，谢谢~
一、LangChain提示词设计概述
1.1 提示词在LangChain中的定位
在LangChain框架中，提示词是连接用户需求与大语言模型（LLM）能力的关键桥梁。作为整个交互流程的起点，提示词质量直接决定了模型输出结果的准确性、相关性和实用性。LangChain并非单纯依赖原始提示输入，而是通过结构化设计与动态组装机制，将用户意图转化为模型可理解的语义表达，从而引导模型生成符合预期的内容。
1.2 核心设计目标
LangChain提示词设计围绕三大核心目标展开：
- 精准意图传递：确保用户需求完整、准确地映射为模型可处理的语义结构
- 动态适配能力：支持根据不同任务类型、数据特征和模型特性调整提示策略
- 结果可控性：通过结构化设计约束输出格式，降低模型生成的随机性和不可控性
1.3 设计原则的底层逻辑
这些设计原则基于对大语言模型工作机制的深入理解：
- 上下文理解：利用模型的上下文学习能力，通过示例引导建立语义关联
- 指令引导：通过明确的任务指令约束模型输出方向
- 格式规范：通过结构化要求降低模型输出的解析成本
- 参数优化：平衡提示长度与信息密度，避免超出模型上下文窗口限制
二、结构化设计原则
2.1 基础结构组成
LangChain提示词的标准结构包含四个核心组件：
1. 任务声明（Task Declaration）
2. 背景信息（Context Information）
3. 示例引导（Example Demonstration）
4. 输出要求（Output Specification）
2.2 任务声明模块
任务声明模块通过显式指令明确任务类型，其核心设计逻辑体现在PromptTemplate类的实现中：
class PromptTemplate:
def __init__(self, input_variables, template):
self.input_variables = input_variables
self.template = template
def format(self, **kwargs):
# 检查输入变量完整性
missing_variables = set(self.input_variables) - set(kwargs.keys())
if missing_variables:
raise ValueError(f"Missing variables: {missing_variables}")
# 填充模板生成最终提示
return self.template.format(**kwargs)
通过input_variables定义可变参数，template承载固定指令结构，实现任务声明的动态组装。
2.3 背景信息集成
背景信息模块负责构建任务上下文，其关键实现涉及ChatPromptTemplate类的messages属性：
class ChatPromptTemplate:
def __init__(self, messages, input_variables):
self.messages = messages
self.input_variables = input_variables
def format_messages(self, **kwargs):
# 检查输入变量完整性
self._validate_inputs(kwargs)
# 对每条消息模板进行参数填充
formatted_messages = []
for message in self.messages:
if isinstance(message, PromptTemplate):
formatted_messages.append(message.format(**kwargs))
else:
formatted_messages.append(message)
return formatted_messages
通过嵌套PromptTemplate实例，实现多层次上下文信息的有序整合。
2.4 示例引导机制
示例引导通过Few-Shot学习模式提升模型理解能力，其核心逻辑体现在FewShotPromptTemplate类：
class FewShotPromptTemplate:
def __init__(self, examples, example_prompt, prefix, suffix, input_variables):
self.examples = examples
self.example_prompt = example_prompt
self.prefix = prefix
self.suffix = suffix
self.input_variables = input_variables
def format(self, **kwargs):
# 生成示例部分
example_strings = []
for example in self.examples:
example_strings.append(self.example_prompt.format(**example))
# 组装完整提示
return self.prefix + "\n".join(example_strings) + self.suffix.format(**kwargs)
通过examples参数注入样本数据，example_prompt定义示例模板，实现动态示例组装。
2.5 输出要求规范
输出规范通过结构化指令约束模型输出格式，典型实现如OutputFixingParser类：
class OutputFixingParser:
def __init__(self, output_parser):
self.output_parser = output_parser
def parse(self, text):
try:
# 尝试直接解析
return self.output_parser.parse(text)
except Exception as e:
# 若解析失败，使用正则表达式修正格式
fixed_text = self._fix_output(text)
return self.output_parser.parse(fixed_text)
def _fix_output(self, text):
# 示例：修正JSON格式
if text.startswith("{") and text.endswith("}"):
try:
json.loads(text)
return text
except json.JSONDecodeError:
return re.sub(r",(\s*})", r"\1", text)
通过内置解析器与格式修复机制，确保输出结果符合预期规范。
三、动态化设计原则
3.1 上下文感知机制
LangChain通过ConversationBufferMemory类实现上下文管理：
class ConversationBufferMemory:
def __init__(self, memory_key="history", input_key="input", output_key="output"):
self.memory_key = memory_key
self.input_key = input_key
self.output_key = output_key
self.chat_memory = []
def save_context(self, inputs, outputs):
# 保存用户输入与模型输出
self.chat_memory.append({"input": inputs[self.input_key], "output": outputs[self.output_key]})
def load_memory_variables(self, inputs):
# 加载历史对话记录
return {self.memory_key: [f"Human: {msg['input']}\nAI: {msg['output']}" for msg in self.chat_memory]}
通过动态维护对话历史，为提示词注入实时上下文信息。
3.2 任务类型适配
针对不同任务类型的适配逻辑体现在LLMChain类的构建过程：
class LLMChain:
def __init__(self, llm, prompt, verbose=False):
self.llm = llm
self.prompt = prompt
self.verbose = verbose
def run(self, **kwargs):
# 根据任务类型选择不同提示策略
if "task_type" in kwargs:
if kwargs["task_type"] == "summarization":
self.prompt = self._get_summarization_prompt()
elif kwargs["task_type"] == "question_answering":
self.prompt = self._get_qa_prompt()
# 生成最终提示并调用模型
prompt_text = self.prompt.format(**kwargs)
if self.verbose:
print(f"Prompt:\n{prompt_text}")
return self.llm(prompt_text)
def _get_summarization_prompt(self):
# 示例：摘要任务提示模板
return PromptTemplate(
input_variables=["text"],
template="请对以下文本进行摘要：\n{text}"
)
def _get_qa_prompt(self):
# 示例：问答任务提示模板
return PromptTemplate(
input_variables=["context", "question"],
template="根据以下内容回答问题：\n{context}\n问题：{question}"
)
通过任务类型识别动态切换提示模板，优化任务执行效果。
3.3 数据驱动优化
数据驱动优化机制依赖PromptSelector类实现：
class PromptSelector:
def __init__(self, default_prompt, conditional_prompts):
self.default_prompt = default_prompt
self.conditional_prompts = conditional_prompts
def get_prompt(self, inputs):
# 根据输入数据特征选择提示策略
for condition, prompt in self.conditional_prompts:
if condition(inputs):
return prompt.format(**inputs)
# 默认提示策略
return self.default_prompt.format(**inputs)
通过预定义的条件判断规则，实现提示策略的智能选择。
四、清晰性设计原则
4.1 指令明确性
指令明确性通过PromptTemplate的模板设计实现：
# 示例：明确的翻译任务模板
translation_template = PromptTemplate(
input_variables=["text", "target_language"],
template="请将以下文本翻译成{target_language}：\n{text}"
)
# 示例：模糊指令模板（反例）
vague_template = PromptTemplate(
input_variables=["text"],
template="处理这段文本：\n{text}"
)
通过对比可见，明确指令可显著提升模型输出准确性。
4.2 逻辑连贯性
逻辑连贯性通过ChatPromptTemplate的消息序列组织保证：
# 示例：包含背景信息与任务指令的对话模板
chat_template = ChatPromptTemplate(
messages=[
SystemMessagePromptTemplate.from_template("你是专业的内容编辑"),
HumanMessagePromptTemplate.from_template("文章主题是{topic}，请提供创作建议"),
AIMessagePromptTemplate.from_template("已收到主题，将分析后给出建议")
],
input_variables=["topic"]
)
通过有序的消息序列构建连贯的语义逻辑。
4.3 避免歧义
歧义规避通过OutputParser的格式约束实现：
# 示例：明确要求JSON格式输出
json_parser = JsonOutputParser(
json_schema={
"type": "object",
"properties": {
"title": {"type": "string"},
"content": {"type": "string"}
},
"required": ["title", "content"]
}
)
# 生成包含格式要求的提示
json_prompt = PromptTemplate(
input_variables=["topic"],
template="请根据主题{topic}创作内容，以JSON格式输出：\n{format_instructions}",
partial_variables={"format_instructions": json_parser.get_format_instructions()}
)
通过格式规范减少语义理解偏差。
五、有效性设计原则
5.1 信息密度优化
信息密度优化涉及提示长度与内容的平衡，核心逻辑体现在PromptLengthLimiter类：
class PromptLengthLimiter:
def __init__(self, max_length, llm):
self.max_length = max_length
self.llm = llm
def limit_prompt(self, prompt_text):
tokens = self.llm.get_num_tokens(prompt_text)
if tokens > self.max_length:
# 截断策略：保留关键信息
important_sections = prompt_text.split("\n")[0:3]
return "\n".join(important_sections) + "\n...（内容省略）"
return prompt_text
通过动态截断策略避免超出模型处理能力。
5.2 示例有效性
示例有效性依赖ExampleSelector的筛选机制：
class ExampleSelector:
def __init__(self, examples, selection_strategy):
self.examples = examples
self.selection_strategy = selection_strategy
def select_examples(self, input_variables):
# 根据策略选择示例
if self.selection_strategy == "random":
return random.sample(self.examples, k=3)
elif self.selection_strategy == "relevance":
# 基于相关性排序筛选
sorted_examples = self._sort_by_relevance(input_variables)
return sorted_examples[:3]
return self.examples[:3]
def _sort_by_relevance(self, input_variables):
# 示例：简单的文本相似度排序
similarities = [self._calculate_similarity(ex, input_variables) for ex in self.examples]
return [ex for _, ex in sorted(zip(similarities, self.examples), reverse=True)]
def _calculate_similarity(self, example, input_variables):
# 简化的相似度计算
input_text = " ".join([str(input_variables[k]) for k in input_variables])
example_text = " ".join([str(example[k]) for k in example])
return fuzz.ratio(input_text, example_text)
通过智能筛选机制提升示例引导效果。
5.3 指令有效性
指令有效性通过PromptValidator类进行验证：
class PromptValidator:
def __init__(self, llm):
self.llm = llm
def validate(self, prompt_text):
# 生成验证提示
validation_prompt = PromptTemplate(
input_variables=["prompt"],
template="该提示是否能清晰传达任务？请回答是或否：\n{prompt}"
).format(prompt=prompt_text)
# 调用模型进行验证
validation_result = self.llm(validation_prompt)
return "是" in validation_result
通过模型自省机制确保指令可执行性。
六、可控性设计原则
6.1 输出格式约束
输出格式约束主要由OutputParser体系实现：
# 示例：Markdown格式解析器
markdown_parser = MarkdownOutputParser()
# 生成包含格式要求的提示
markdown_prompt = PromptTemplate(
input_variables=["topic"],
template="请根据主题{topic}创作内容，以Markdown格式输出：\n{format_instructions}",
partial_variables={"format_instructions": markdown_parser.get_format_instructions()}
)
通过预设解析规则强制模型输出结构化内容。
6.2 内容范围限定
内容范围限定通过PromptConstraint类实现：
class PromptConstraint:
def __init__(self, max_words, prohibited_words):
self.max_words = max_words
self.prohibited_words = prohibited_words
def check_constraints(self, prompt_text):
word_count = len(prompt_text.split())
if word_count > self.max_words:
return False
for word in self.prohibited_words:
if word in prompt_text:
return False
return True
通过字数限制与关键词过滤控制输出内容边界。
6.3 结果质量保障
质量保障机制依赖ResultEvaluator类：
class ResultEvaluator:
def __init__(self, evaluation_criteria):
self.evaluation_criteria = evaluation_criteria
def evaluate(self, result):
for criterion, weight in self.evaluation_criteria.items():
if criterion == "relevance":
# 示例：基于关键词的相关性评估
relevance_score = self._calculate_relevance(result)
overall_score += relevance_score * weight
elif criterion == "completeness":
# 示例：完整性评估
completeness_score = self._calculate_completeness(result)
overall_score += completeness_score * weight
return overall_score
def _calculate_relevance(self, result):
# 简化的相关性计算
keywords = ["核心", "关键", "重要"]
return sum([1 for keyword in keywords if keyword in result]) / len(keywords)
def _calculate_completeness(self, result):
# 示例：检查必要字段是否存在
required_fields = ["title", "description"]
return sum([1 for field in required_fields if field in result]) / len(required_fields)
通过多维度评估体系确保输出结果质量。
七、可复用性设计原则
7.1 模板化设计
模板化设计通过PromptTemplate类的继承体系实现：
# 基础模板类
class BasePromptTemplate:
def __init__(self, input_variables, template):
self.input_variables = input_variables
self.template = template
def format(self, **kwargs):
# 基础填充逻辑
return self.template.format(**kwargs)
# 继承扩展示例
class AdvancedPromptTemplate(BasePromptTemplate):
def __init__(self, input_variables, template, additional_instructions):
super().__init__(input_variables, template)
self.additional_instructions = additional_instructions
def format(self, **kwargs):
# 扩展填充逻辑
base_prompt = super().format(**kwargs)
return base_prompt + "\n" + self.additional_instructions
通过继承机制实现模板的层次化扩展。
7.2 组件化架构
组件化架构体现在Prompt类的组合设计：
class Prompt:
def __init__(self, parts):
self.parts = parts
def format(self, **kwargs):
formatted_parts = []
for part in self.parts:
if isinstance(part, PromptTemplate):
formatted_parts.append(part.format(**kwargs))
else:
formatted_parts.append(part)
return " ".join(formatted_parts)
# 示例：组合使用多个模板
prompt = Prompt([
PromptTemplate(input_variables=["topic"], template="主题是{topic}"),
"请围绕该主题创作",
JsonOutputParser().get_format_instructions()
])
通过灵活组合实现提示结构的快速搭建。
7.3 配置化管理
配置化管理通过PromptConfiguration类实现：
class PromptConfiguration:
def __init__(self, template_path, variables, constraints):
self.template_path = template_path
self.variables = variables
self.constraints = constraints
def load_template(self):
with open(self.template_path, "r") as f:
template_text = f.read()
return PromptTemplate(
input_variables=self.variables,
template=template_text
)
def apply_constraints(self, prompt
配置化管理通过PromptConfiguration类实现：
class PromptConfiguration:
def __init__(self, template_path, variables, constraints):
self.template_path = template_path
self.variables = variables
self.constraints = constraints
def load_template(self):
with open(self.template_path, "r") as f:
template_text = f.read()
return PromptTemplate(
input_variables=self.variables,
template=template_text
)
def apply_constraints(self, prompt_text):
for constraint in self.constraints:
if not constraint.check(prompt_text):
raise ValueError(f"提示违反约束: {constraint.description}")
return prompt_text
def get_formatted_prompt(self, **kwargs):
template = self.load_template()
formatted_prompt = template.format(**kwargs)
return self.apply_constraints(formatted_prompt)
通过配置文件分离模板定义与业务逻辑，实现提示词的跨项目复用。
7.4 参数化设计
参数化设计通过ParameterizedPromptTemplate类实现：
class ParameterizedPromptTemplate:
def __init__(self, base_template, parameter_mapping):
self.base_template = base_template
self.parameter_mapping = parameter_mapping
def format(self, **kwargs):
# 将输入参数映射到模板变量
mapped_kwargs = {
template_var: kwargs[input_var]
for input_var, template_var in self.parameter_mapping.items()
}
return self.base_template.format(**mapped_kwargs)
# 示例：统一模板适配不同参数名
common_template = PromptTemplate(
input_variables=["content", "format"],
template="请以{format}格式处理：{content}"
)
# 为不同场景适配参数
web_adapter = ParameterizedPromptTemplate(
base_template=common_template,
parameter_mapping={"web_content": "content", "output_style": "format"}
)
api_adapter = ParameterizedPromptTemplate(
base_template=common_template,
parameter_mapping={"api_payload": "content", "response_format": "format"}
)
通过参数映射层实现模板的多场景复用。
八、安全性设计原则
8.1 输入过滤机制
输入过滤通过InputSanitizer类实现：
class InputSanitizer:
def __init__(self, allowed_chars=r'[a-zA-Z0-9\s.,?!-]', max_length=1000):
self.allowed_chars = re.compile(allowed_chars)
self.max_length = max_length
def sanitize(self, text):
# 长度限制
if len(text) > self.max_length:
text = text[:self.max_length]
# 字符过滤
return self.allowed_chars.sub('', text)
def sanitize_dict(self, input_dict):
return {
key: self.sanitize(value) if isinstance(value, str) else value
for key, value in input_dict.items()
}
通过正则过滤与长度限制防止恶意输入。
8.2 敏感信息保护
敏感信息保护通过SensitiveDataFilter类实现：
class SensitiveDataFilter:
def __init__(self, regex_patterns=None, replacement="***"):
self.regex_patterns = regex_patterns or [
r'\d{17,19}', # 信用卡号
r'\d{11}', # 手机号
r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+' # 邮箱
]
self.replacement = replacement
def filter(self, text):
for pattern in self.regex_patterns:
text = re.sub(pattern, self.replacement, text)
return text
def filter_prompt(self, prompt_text):
# 过滤提示中的敏感信息
return self.filter(prompt_text)
def filter_output(self, output_text):
# 过滤模型输出中的敏感信息
return self.filter(output_text)
通过正则匹配自动替换敏感信息。
8.3 安全边界控制
安全边界控制通过SafetyLayer类实现：
class SafetyLayer:
def __init__(self, llm, safety_checker):
self.llm = llm
self.safety_checker = safety_checker
def generate(self, prompt):
# 先检查提示安全性
if not self.safety_checker.validate_prompt(prompt):
raise ValueError("不安全的提示")
# 生成回复
response = self.llm(prompt)
# 检查回复安全性
if not self.safety_checker.validate_response(response):
return "抱歉，我无法提供相关内容"
return response
通过安全检查层拦截不安全的交互。
8.4 合规性验证
合规性验证通过ComplianceChecker类实现：
class ComplianceChecker:
def __init__(self, policies):
self.policies = policies
def validate_prompt(self, prompt):
for policy in self.policies:
if not policy.check_prompt(prompt):
return False
return True
def validate_response(self, response):
for policy in self.policies:
if not policy.check_response(response):
return False
return True
# 示例：自定义合规策略
class NoHarmPolicy:
def check_prompt(self, prompt):
return "攻击" not in prompt and "伤害" not in prompt
def check_response(self, response):
return "攻击" not in response and "伤害" not in response
通过策略模式实现灵活的合规检查。
九、性能优化原则
9.1 缓存机制
缓存机制通过PromptCache类实现：
class PromptCache:
def __init__(self, max_size=1000):
self.cache = LRUCache(max_size)
self.hash_function = hashlib.sha256
def get_key(self, prompt_text, model_name):
# 生成缓存键
key = f"{model_name}_{self.hash_function(prompt_text.encode()).hexdigest()}"
return key
def get(self, prompt_text, model_name):
key = self.get_key(prompt_text, model_name)
return self.cache.get(key)
def set(self, prompt_text, model_name, response):
key = self.get_key(prompt_text, model_name)
self.cache[key] = response
# 集成缓存的LLM包装器
class CachedLLM:
def __init__(self, llm, cache):
self.llm = llm
self.cache = cache
def __call__(self, prompt):
# 检查缓存
cached_response = self.cache.get(prompt, self.llm.model_name)
if cached_response:
return cached_response
# 没有缓存，调用模型
response = self.llm(prompt)
# 缓存结果
self.cache.set(prompt, self.llm.model_name, response)
return response
通过LRU缓存避免重复计算。
9.2 批处理优化
批处理优化通过BatchPromptProcessor类实现：
class BatchPromptProcessor:
def __init__(self, llm, batch_size=10):
self.llm = llm
self.batch_size = batch_size
def process(self, prompts):
results = []
for i in range(0, len(prompts), self.batch_size):
batch = prompts[i:i+self.batch_size]
# 合并为一个批量提示
batch_prompt = self._create_batch_prompt(batch)
# 调用模型
batch_response = self.llm(batch_prompt)
# 解析结果
parsed_responses = self._parse_batch_response(batch_response, len(batch))
results.extend(parsed_responses)
return results
def _create_batch_prompt(self, prompts):
# 示例：为每个提示添加索引
return "\n\n".join([f"Prompt {i}:\n{prompt}" for i, prompt in enumerate(prompts)])
def _parse_batch_response(self, response, batch_size):
# 示例：按索引分割响应
responses = []
for i in range(batch_size):
pattern = re.compile(f"Response {i}:(.*?)(Response {i+1}|$)", re.DOTALL)
match = pattern.search(response)
if match:
responses.append(match.group(1).strip())
else:
responses.append("")
return responses
通过批量处理减少API调用次数。
9.3 异步处理
异步处理通过AsyncPromptRunner类实现：
class AsyncPromptRunner:
def __init__(self, llm):
self.llm = llm
async def run(self, prompts):
tasks = []
for prompt in prompts:
tasks.append(asyncio.create_task(self._process_prompt(prompt)))
return await asyncio.gather(*tasks)
async def _process_prompt(self, prompt):
# 非阻塞调用LLM
return await asyncio.to_thread(self.llm, prompt)
# 使用示例
async def main():
runner = AsyncPromptRunner(llm)
results = await runner.run(["prompt1", "prompt2", "prompt3"])
print(results)
通过异步编程提升并发处理能力。
9.4 流式处理
流式处理通过StreamingLLM类实现：
class StreamingLLM:
def __init__(self, base_llm):
self.base_llm = base_llm
def generate_stream(self, prompt):
# 调用底层流式API
stream = self.base_llm.generate_stream(prompt)
# 示例：添加前缀和后缀处理
yield "开始生成：\n"
for chunk in stream:
yield chunk
yield "\n生成完成"
# 使用示例
def print_stream(stream):
for chunk in stream:
print(chunk, end="")
llm = StreamingLLM(base_llm)
stream = llm.generate_stream("请介绍机器学习")
print_stream(stream)
通过流式输出提升用户体验。
十、实验与评估原则
10.1 A/B测试框架
A/B测试框架通过PromptTester类实现：
class PromptTester:
def __init__(self, llm, evaluator, test_data, control_prompt, variants):
self.llm = llm
self.evaluator = evaluator
self.test_data = test_data
self.control_prompt = control_prompt
self.variants = variants
def run_test(self, num_samples=None):
results = {"control": []}
# 测试对照组
for sample in self.test_data[:num_samples]:
response = self.llm(self.control_prompt.format(**sample))
score = self.evaluator.evaluate(response)
results["control"].append(score)
# 测试变体
for i, variant in enumerate(self.variants):
variant_results = []
for sample in self.test_data[:num_samples]:
response = self.llm(variant.format(**sample))
score = self.evaluator.evaluate(response)
variant_results.append(score)
results[f"variant_{i}"] = variant_results
return self._analyze_results(results)
def _analyze_results(self, results):
# 计算统计数据
analysis = {}
for group, scores in results.items():
analysis[group] = {
"mean": sum(scores) / len(scores),
"min": min(scores),
"max": max(scores),
"std_dev": statistics.stdev(scores) if len(scores) > 1 else 0
}
# 找出最佳变体
control_mean = analysis["control"]["mean"]
best_variant = None
best_improvement = 0
for group in analysis:
if group == "control":
continue
improvement = (analysis[group]["mean"] - control_mean) / control_mean * 100
if improvement > best_improvement:
best_improvement = improvement
best_variant = group
analysis["best_variant"] = best_variant
analysis["best_improvement"] = best_improvement
return analysis
通过科学实验对比不同提示策略的效果。
10.2 评估指标体系
评估指标体系通过PromptEvaluator类实现：
class PromptEvaluator:
def __init__(self, metrics):
self.metrics = metrics
def evaluate(self, response):
scores = {}
for name, metric in self.metrics.items():
scores[name] = metric.evaluate(response)
# 计算加权总分
total_score = sum(
score * metric.weight
for name, (score, metric) in enumerate(scores.items())
)
return {
"scores": scores,
"total_score": total_score
}
# 示例：不同评估指标
class RelevanceMetric:
def __init__(self, keywords, weight=0.5):
self.keywords = keywords
self.weight = weight
def evaluate(self, response):
return sum(1 for keyword in self.keywords if keyword.lower() in response.lower()) / len(self.keywords)
class CoherenceMetric:
def __init__(self, weight=0.3):
self.weight = weight
def evaluate(self, response):
# 简化的连贯性评估，实际中可能使用NLP模型
sentences = response.split('.')
if len(sentences) < 2:
return 0.5
# 检查句子之间的连贯性
coherence_score = 0
for i in range(len(sentences) - 1):
if self._are_sentences_related(sentences[i], sentences[i+1]):
coherence_score += 1
return coherence_score / (len(sentences) - 1)
def _are_sentences_related(self, s1, s2):
# 简化的相关度检查
common_words = set(s1.split()) & set(s2.split())
return len(common_words) > 0
通过多维度评估全面衡量提示效果。
10.3 持续优化流程
持续优化流程通过PromptOptimizer类实现：
class PromptOptimizer:
def __init__(self, llm, evaluator, initial_prompt, optimization_strategy):
self.llm = llm
self.evaluator = evaluator
self.current_prompt = initial_prompt
self.optimization_strategy = optimization_strategy
self.history = []
def optimize(self, iterations=10, test_data=None):
for i in range(iterations):
# 生成候选提示
candidates = self.optimization_strategy.generate_candidates(self.current_prompt)
# 评估候选提示
best_candidate = None
best_score = -float('inf')
for candidate in candidates:
score = self._evaluate_prompt(candidate, test_data)
if score > best_score:
best_score = score
best_candidate = candidate
# 如果有改进，更新当前提示
current_score = self._evaluate_prompt(self.current_prompt, test_data)
if best_score > current_score:
self.current_prompt = best_candidate
improvement = (best_score - current_score) / current_score * 100
self.history.append({
"iteration": i,
"prompt": best_candidate,
"score": best_score,
"improvement": improvement
})
print(f"迭代 {i}: 改进 {improvement:.2f}%")
else:
self.history.append({
"iteration": i,
"prompt": self.current_prompt,
"score": current_score,
"improvement": 0
})
print(f"迭代 {i}: 无改进")
return self.current_prompt
def _evaluate_prompt(self, prompt, test_data):
# 评估提示在测试数据上的表现
total_score = 0
for sample in test_data:
response = self.llm(prompt.format(**sample))
score = self.evaluator.evaluate(response)["total_score"]
total_score += score
return total_score / len(test_data)
通过迭代优化不断提升提示质量。
10.4 错误分析机制
错误分析机制通过ErrorAnalyzer类实现：
class ErrorAnalyzer:
def __init__(self, evaluator, error_types):
self.evaluator = evaluator
self.error_types = error_types
def analyze(self, prompts, responses, ground_truths):
error_summary = {error_type: 0 for error_type in self.error_types}
error_details = []
for prompt, response, ground_truth in zip(prompts, responses, ground_truths):
# 评估响应
evaluation = self.evaluator.evaluate(response, ground_truth)
# 记录错误类型
for error_type in self.error_types:
if evaluation["errors"].get(error_type, False):
error_summary[error_type] += 1
error_details.append({
"prompt": prompt,
"response": response,
"ground_truth": ground_truth,
"error_type": error_type,
"severity": evaluation["severity"]
})
# 按错误类型排序
sorted_errors = sorted(
error_details,
key=lambda x: (self.error_types.index(x["error_type"]), -x["severity"]),
reverse=True
)
return {
"summary": error_summary,
"details": sorted_errors
}
# 示例：不同错误类型的检测器
class ErrorDetector:
def detect_irrelevance(self, response, ground_truth):
# 检查响应是否与问题相关
return "无关" in response or not any(kw in response for kw in ground_truth["keywords"])
def detect_inaccuracy(self, response, ground_truth):
# 检查响应是否准确
return "错误" in response or not self._check_factual_accuracy(response, ground_truth["facts"])
def detect_incompleteness(self, response, ground_truth):
# 检查响应是否完整
required_fields = ground_truth.get("required_fields", [])
return any(field not in response for field in required_fields)
def _check_factual_accuracy(self, response, facts):
# 简化的事实检查
for fact in facts:
if fact not in response:
return False
return True
通过错误分类和分析指导提示优化。
十一、与LLM特性的适配原则
11.1 模型能力匹配
模型能力匹配通过ModelAdapter类实现：
class ModelAdapter:
def __init__(self, model_name):
self.model_name = model_name
self.model_capabilities = self._get_model_capabilities()
def _get_model_capabilities(self):
# 查询模型能力信息
if "gpt-4" in self.model_name:
return {
"max_context_length": 8192,
"support_functions": True,
"few_shot_limit": 10
}
elif "gpt-3.5" in self.model_name:
return {
"max_context_length": 4096,
"support_functions": True,
"few_shot_limit": 5
}
else:
return {
"max_context_length": 2048,
"support_functions": False,
"few_shot_limit": 3
}
def adjust_prompt(self, prompt):
# 根据模型能力调整提示
if len(prompt) > self.model_capabilities["max_context_length"]:
# 截断提示
prompt = prompt[:self.model_capabilities["max_context_length"]]
# 其他调整...
return prompt
def get_few_shot_examples_limit(self):
return self.model_capabilities["few_shot_limit"]
通过模型适配器确保提示与模型能力匹配。
11.2 温度参数适配
温度参数适配通过TemperatureOptimizer类实现：
class TemperatureOptimizer:
def __init__(self, llm, evaluator, test_data):
self.llm = llm
self.evaluator = evaluator
self.test_data = test_data
def find_optimal_temperature(self, min_temp=0.0, max_temp=2.0, step=0.2):
best_temp = 0.0
best_score = -float('inf')
results = []
for temp in np.arange(min_temp, max_temp + step, step):
# 设置温度
self.llm.temperature = temp
# 评估性能
avg_score = self._evaluate_temperature(temp)
results.append((temp, avg_score))
# 更新最佳温度
if avg_score > best_score:
best_score = avg_score
best_temp = temp
return {
"best_temperature": best_temp,
"best_score": best_score,
"results": results
}
def _evaluate_temperature(self, temperature):
scores = []
for sample in self.test_data:
response = self.llm(sample["prompt"])
score = self.evaluator.evaluate(response)["total_score"]
scores.append(score)
return sum(scores) / len(scores)
通过实验找到最适合任务的温度参数。
11.3 函数调用适配
函数调用适配通过FunctionCallAdapter类实现：
class FunctionCallAdapter:
def __init__(self, functions):
self.functions = functions
def create_function_call_prompt(self, task_description):
# 构建函数调用提示
function_descriptions = []
for func in self.functions:
desc = {
"name": func["name"],
"parameters": func["parameters"],
"description": func["description"]
}
function_descriptions.append(desc)
# 创建系统提示
system_prompt = f"""
你可以调用以下函数来完成任务:
{json.dumps(function_descriptions, indent=2)}
任务: {task_description}
"""
return system_prompt
def parse_function_call(self, response):
# 解析模型返回的函数调用
try:
if "function_call" in response:
return response["function_call"]
else:
return None
except json.JSONDecodeError:
return None
def execute_function(self, function_call):
# 执行函数调用
function_name = function_call["name"]
parameters = function_call["parameters"]
for func in self.functions:
if func["name"] == function_name:
return func["implementation"](**parameters)
return {"error": f"Function {function_name} not found"}
通过函数调用增强模型与外部系统的交互能力。
11.4 上下文窗口管理
上下文窗口管理通过ContextWindowManager类实现：
class ContextWindowManager:
def __init__(self, model_name, max_context_length=None):
self.model_name = model_name
self.max_context_length = max_context_length or self._get_default_context_length()
self.tokenizer = self._get_tokenizer()
def _get_default_context_length(self):
# 根据模型名称获取默认上下文长度
if "gpt-4" in self.model_name:
return 8192
elif "gpt-3.5" in self.model_name:
return 4096
else:
return 2048
def _get_tokenizer(self):
# 获取模型对应的分词器
if "gpt" in self.model_name:
return GPT2TokenizerFast.from_pretrained("gpt2")
# 其他模型的分词器...
return None
def truncate_text(self, text, max_tokens):
# 将文本截断到指定的token数
tokens = self.tokenizer.encode(text)
if len(tokens) <= max_tokens:
return text
truncated_tokens = tokens[:max_tokens]
return self.tokenizer.decode(truncated_tokens)
def manage_context(self, prompt, history, max_tokens=None):
max_tokens = max_tokens or self.max_context_length
# 计算可用token数
prompt_tokens = len(self.tokenizer.encode(prompt))
available_tokens = max_tokens - prompt_tokens
# 逐步添加历史记录，直到达到token限制
truncated_history = []
history_tokens = 0
for message in reversed(history):
message_tokens = len(self.tokenizer.encode(message))
if history_tokens + message_tokens > available_tokens:
break
truncated_history.insert(0, message)
history_tokens += message_tokens
return {
"prompt": prompt,
"history": truncated_history,
"total_tokens": prompt_tokens + history_tokens
}
通过智能管理上下文窗口，充分利用模型能力。
十二、多语言支持原则
12.1 语言感知设计
语言感知设计通过LanguageAwarePrompt类实现：
class LanguageAwarePrompt:
def __init__(self, default_language="en"):
self.default_language = default_language
self.prompts = {}
def add_prompt(self, language, prompt_template):
self.prompts[language] = prompt_template
def get_prompt(self, language=None):
# 优先使用指定语言的提示
if language and language in self.prompts:
return self.prompts[language]
# 尝试使用相近语言
for lang in self.prompts:
if lang.startswith(language.split('-')[0]):
return self.prompts[lang]
# 使用默认语言
return self.prompts.get(self.default_language)
def detect_language(self, text):
# 简单的语言检测实现
if any(word in text.lower() for word in ["the", "and", "to"]):
return "en"
elif any(word in text.lower() for word in ["le", "la", "et"]):
return "fr"
elif any(word in text.lower() for word in ["der", "die", "das"]):
return "de"
else:
return self.default_language
def format(self, **kwargs):
# 自动检测语言并获取对应提示
language = kwargs.get("language", self.default_language)
prompt_template = self.get_prompt(language)
if not prompt_template:
raise ValueError(f"未找到语言为{language}的提示模板")
return prompt_template.format(**kwargs)
通过语言检测和模板管理实现多语言支持。
12.2 翻译适配
翻译适配通过TranslationAdapter类实现：
class TranslationAdapter:
def __init__(self, translator, target_language):
self.translator = translator
self.target_language = target_language
def translate_prompt(self, prompt):
# 翻译提示
return self.translator.translate(prompt, target_language=self.target_language)
def translate_response(self, response):
# 翻译模型响应
return self.translator.translate(response, target_language=self.source_language)
def format_translated_prompt(self, prompt_template, **kwargs):
# 先格式化模板，再翻译
formatted_prompt = prompt_template.format(**kwargs)
return self.translate_prompt(formatted_prompt)
# 示例：使用DeepL API的翻译适配器
class DeepLTranslator:
def __init__(self, api_key):
self.api_key = api_key
self.client = DeepL.Client(api_key)
def translate(self, text, target_language):
result = self.client.translate_text(text, target_lang=target_language)
return result.text
通过翻译层实现跨语言提示适配。
12.3 文化差异处理
文化差异处理通过CultureAdapter类实现：
class CultureAdapter:
def __init__(self, culture_config):
self.culture_config = culture_config
def adjust_prompt(self, prompt, culture_code):
# 根据文化配置调整提示
if culture_code in self.culture_config:
config = self.culture_config[culture_code]
# 调整问候语
if "greeting" in config:
prompt = config["greeting"] + "\n" + prompt
# 调整语气
if "tone" in config:
if config["tone"] == "formal":
prompt = prompt.replace("you", "您")
elif config["tone"] == "informal":
prompt = prompt.replace("您", "你")
# 调整示例
if "examples" in config:
example_section = "\n\n示例:\n" + "\n".join(config["examples"])
prompt += example_section
return prompt
def validate_response(self, response, culture_code):
# 验证响应是否符合文化规范
if culture_code in self.culture_config:
config = self.culture_config[culture_code]
# 检查禁忌词汇
if "taboo_words" in config:
for word in config["taboo_words"]:
if word in response.lower():
return False
# 检查语气是否合适
if "tone" in config:
if config["tone"] == "formal" and any(word in response.lower() for word in ["随便", "大概"]):
return False
return True
通过文化配置实现符合当地习惯的提示设计。
12.4 多语言评估
多语言评估通过MultilingualEvaluator类实现：
class MultilingualEvaluator:
def __init__(self, evaluators):
self.evaluators = evaluators # 按语言映射的评估器
def evaluate(self, response, language):
# 根据语言选择评估器
if language in self.evaluators:
return self.evaluators[language].evaluate(response)
# 使用默认评估器
default_evaluator = self.evaluators.get("en")
if default_evaluator:
return default_evaluator.evaluate(response)
raise ValueError("未找到合适的评估器")
def add_evaluator(self, language, evaluator):
self.evaluators[language] = evaluator
# 示例：针对不同语言的评估器
class ChineseEvaluator:
def evaluate(self, response):
# 中文评估逻辑
score = 0
# 检查关键词匹配
if "正确" in response:
score += 1
# 检查句子完整性
if response.endswith("。") or response.endswith("！") or response.endswith("？"):
score += 1
return {"score": score, "details": "中文评估结果"}
class EnglishEvaluator:
def evaluate(self, response):
# 英文评估逻辑
score = 0
# 检查关键词匹配
if "correct" in response.lower():
score += 1
# 检查句子完整性
if response.endswith(".") or response.endswith("!") or response.endswith("?"):
score += 1
return {"score": score, "details": "英文评估结果"}
通过语言特定的评估器确保跨语言评估的准确性。
十三、与其他LangChain组件的集成原则
13.1 与记忆组件的集成
与记忆组件的集成通过MemoryEnhancedPrompt类实现：
class MemoryEnhancedPrompt:
def __init__(self, base_prompt, memory):
self.base_prompt = base_prompt
self.memory = memory
def format(self, **kwargs):
# 从记忆中获取历史信息
history = self.memory.load_memory_variables(kwargs)
# 将历史信息整合到提示中
formatted_history = self._format_history(history)
# 格式化基础提示
formatted_prompt = self.base_prompt.format(**kwargs)
# 组合最终提示
return f"{formatted_history}\n\n{formatted_prompt}"
def _format_history(self, history):
# 将历史信息格式化为可读文本
if not history:
return ""
formatted = []
for key, value in history.items():
formatted.append(f"{key}:\n{value}")
return "\n\n".join(formatted)
def update_memory(self, inputs, outputs):
# 更新记忆
self.memory.save_context(inputs, outputs)
通过记忆组件增强提示的上下文感知能力。
13.2 与工具的集成
与工具的集成通过ToolAwarePrompt类实现：
class ToolAwarePrompt:
def __init__(self, base_prompt, tools):
self.base_prompt = base_prompt
self.tools = tools
def format(self, **kwargs):
# 生成工具描述
tool_descriptions = self._get_tool_descriptions()
# 格式化基础提示
formatted_prompt = self.base_prompt.format(**kwargs)
# 组合最终提示
return f"{tool_descriptions}\n\n{formatted_prompt}"
def _get_tool_descriptions(self):
if not self.tools:
return ""
descriptions = ["可用工具:"]
for tool in self.tools:
tool_desc = f"- {tool.name}: {tool.description}"
if tool.parameters:
params = ", ".join([f"{k}: {v}" for k, v in tool.parameters.items()])
tool_desc += f" (参数: {params})"
descriptions.append(tool_desc)
return "\n".join(descriptions)
def get_tool(self, name):
# 根据名称获取工具
for tool in self.tools:
if tool.name == name:
return tool
return None
通过工具描述引导模型合理调用外部功能。
13.3 与链的集成
与链的集成通过ChainablePrompt类实现：
class ChainablePrompt:
def __init__(self, prompt_template, input_mapping=None):
self.prompt_template = prompt_template
self.input_mapping = input_mapping or {}
def format(self, **kwargs):
# 映射输入参数
mapped_kwargs = {
template_var: kwargs[input_var]
for input_var, template_var in self.input_mapping.items()
}
# 补充未映射的参数
for key in kwargs:
if key not in self.input_mapping.values():
mapped_kwargs[key] = kwargs[key]
# 格式化提示
return self.prompt_template.format(**mapped_kwargs)
def as_input(self, output_key="output"):
# 创建链输入映射
return {output_key: self.prompt_template.input_variables[0]}
# 示例：链式调用
def create_qa_chain():
# 创建问题生成提示
question_prompt = ChainablePrompt(
PromptTemplate(
input_variables=["context", "topic"],
template="根据以下内容生成关于{topic}的问题：\n{context}"
)
)
# 创建回答提示
answer_prompt = ChainablePrompt(
PromptTemplate(
input_variables=["question", "context"],
template="回答问题：{question}\n参考内容：{context}"
),
input_mapping={"output": "question"} # 将上一步输出映射到question
)
# 创建链
return SequentialChain(
chains=[question_prompt, answer_prompt],
input_variables=["context", "topic"],
output_variables=["output"]
)
通过链式结构实现复杂任务的分步处理。
13.4 与代理的集成
与代理的集成通过AgentPrompt类实现：
class AgentPrompt:
def __init__(self, base_prompt, tools=None, prefix="", suffix=""):
self.base_prompt = base_prompt
self.tools = tools or []
self.prefix = prefix
self.suffix = suffix
def format(self, **kwargs):
# 生成工具描述
tool_descriptions = self._get_tool_descriptions()
# 生成工具名称列表
tool_names = ", ".join([tool.name for tool in self.tools])
# 格式化基础提示
formatted_prompt = self.base_prompt.format(**kwargs)
# 组合最终提示
return f"""
{self.prefix}
{tool_descriptions}
{formatted_prompt}
{self.suffix.format(tool_names=tool_names)}
"""
def _get_tool_descriptions(self):
if not self.tools:
return ""
descriptions = []
for tool in self.tools:
params = json.dumps(tool.parameters, ensure_ascii=False, indent=2)
descriptions.append(f"""
工具名称: {tool.name}
描述: {tool.description}
参数: {params}
""")
return "\n".join(descriptions)
# 示例：代理提示模板
agent_prompt = AgentPrompt(
base_prompt=PromptTemplate(
input_variables=["input", "agent_scratchpad"],
template="用户输入: {input}\n\n{agent_scratchpad}"
),
prefix="你是一个智能助手，可以使用以下工具解决问题:",
suffix="请选择合适的工具解决问题。可用工具: {tool_names}"
)
通过代理提示引导模型自主选择和使用工具。
十四、提示词设计的最佳实践
14.1 提示词工程工作流
一个完整的提示词工程工作流包括以下步骤：
- 需求分析：明确任务目标和期望输出
- 初始设计：基于任务类型创建基础提示模板
- 原型测试：在小规模数据上验证提示效果
- 错误分析：分析失败案例，识别问题类型
- 迭代优化：根据分析结果调整提示结构
- A/B测试：比较不同提示策略的性能
- 部署上线：将优化后的提示集成到生产环境
- 监控反馈：持续收集用户反馈和系统日志
- 持续改进：定期分析数据，优化提示策略
14.2 提示词库管理
有效的提示词库管理包括：
- 版本控制：使用Git等工具管理提示词版本
- 分类组织：按任务类型、应用场景等维度分类
- 元数据标注：为每个提示添加使用说明、适用模型等信息
- 测试覆盖：为每个提示编写单元测试，确保功能稳定
- 文档完善：提供详细的使用文档和示例
- 安全审核：定期审核提示词库，确保符合安全标准
14.3 团队协作模式
提示词工程中的团队协作模式：
- 角色分工：明确产品经理、提示工程师、数据科学家等角色职责
- 协作流程：建立从需求提出到上线的标准化流程
- 知识共享：定期组织内部培训和经验分享
- 代码审查：对提示词修改进行代码审查，确保质量
- 工具支持：使用共享平台管理提示词和实验数据
- 跨团队协作：与开发、运维等团队保持密切沟通
14.4 伦理与安全考虑
提示词设计中的伦理与安全考虑：
- 偏见检测：使用工具检测提示词中的潜在偏见
- 内容审核：建立内容审核机制，避免生成有害信息
- 隐私保护：避免在提示中包含用户敏感信息
- 合规检查：确保提示词符合相关法律法规
- 应急响应：制定应急预案，处理可能的安全漏洞
- 透明性：向用户明确说明AI系统的能力和限制
14.5 性能与成本优化
提示词设计中的性能与成本优化：
- 提示词精简：去除冗余信息，降低token消耗
- 批量处理：使用批量API调用，减少请求次数
- 缓存策略：对重复请求使用缓存，提高响应速度
- 模型选择：根据任务复杂度选择合适的模型
- 异步处理：使用异步编程提升并发处理能力
- 流式输出：使用流式API提升用户体验
14.6 与其他技术的结合
提示词设计可与以下技术结合：
- 知识图谱：利用知识图谱增强提示的结构化程度
- 检索增强：结合向量数据库实现上下文检索增强
- 多模态输入：处理图像、音频等非文本输入
- 强化学习：使用强化学习优化提示策略
- 大模型微调：结合提示词与模型微调，提升特定任务性能
- 联邦学习：在隐私保护前提下利用多方数据优化提示
通过深入理解和应用这些核心原则，开发者可以设计出更加高效、安全、可扩展的提示词，充分发挥LangChain框架的强大能力，构建出更加智能、灵活的AI应用系统。提示词工程作为连接人类意图与AI能力的桥梁，将在未来的AI发展中扮演越来越重要的角色。
