04 | 实战——用 Prompt Engineering Guide 搭建你的第一个 LLM 应用

pip install openai python-dotenv

OPENAI_API_KEY=sk-your-api-key-here
# 如果用 DeepSeek，改为：
# OPENAI_BASE_URL=https://api.deepseek.com
# OPENAI_API_KEY=sk-your-deepseek-key

import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI(
    api_key=os.getenv("OPENAI_API_KEY"),
    base_url=os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
)

response = client.chat.completions.create(
    model="gpt-4o-mini",  # 或 "deepseek-chat"
    messages=[
        {"role": "user", "content": "用一句话解释什么是 LLM"}
    ]
)

print(response.choices[0].message.content)

system_prompt = """你是一位资深技术编辑，擅长将复杂的技术文章浓缩为简洁的摘要。

你的摘要应该：
1. 第一句话概括文章核心观点
2. 列出 2-3 个关键要点
3. 最后一句话说明适用人群

不要使用"本文介绍了..."这种开头，直接说重点。"""

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": "请为以下文章写摘要：..."}
    ]
)

messages = [
    {"role": "system", "content": system_prompt},

    # Few-shot 示例
    {"role": "user", "content": "文章：《Attention Is All You Need》论文解读"},
    {"role": "assistant", "content": """Transformer 架构用自注意力机制完全取代了 RNN 的循环结构，在机器翻译任务上取得 SOTA。
关键要点：
- Self-Attention 让每个 token 能关注序列中任意位置
- 多头注意力捕捉不同层次的语言关系
- 并行计算大幅提升训练效率
适合关注 NLP 架构演进的研究者和工程师。"""},

    # 实际请求
    {"role": "user", "content": f"文章：{article_text}"}
]

cot_prompt = f"""请分析以下技术文章并生成摘要。

先思考以下问题（不需要输出思考过程）：
1. 文章的核心问题是什么？
2. 提出了什么解决方案？
3. 关键技术细节有哪些？
4. 目标读者是谁？

然后按以下 JSON 格式输出：
{{
    "one_liner": "一句话核心观点",
    "key_points": ["要点1", "要点2", "要点3"],
    "audience": "适用人群",
    "difficulty": "入门/中级/高级"
}}

文章内容：
{article_text}"""

import json
from pathlib import Path

class ArticleSummarizer:
    def __init__(self, model="gpt-4o-mini"):
        self.client = OpenAI(
            api_key=os.getenv("OPENAI_API_KEY"),
            base_url=os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
        )
        self.model = model
        self.system_prompt = """你是一位资深技术编辑..."""  # 同上文

    def summarize(self, article_text: str) -> dict:
        """生成单篇文章的结构化摘要"""
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": self.system_prompt},
                {"role": "user", "content": self._build_prompt(article_text)}
            ],
            temperature=0.3,  # 摘要任务要确定性高
            response_format={"type": "json_object"}  # 强制 JSON 输出
        )
        return json.loads(response.choices[0].message.content)

    def batch_summarize(self, articles: list[str]) -> list[dict]:
        """批量生成摘要"""
        results = []
        for i, article in enumerate(articles):
            print(f"处理第 {i+1}/{len(articles)} 篇...")
            result = self.summarize(article)
            result["token_usage"] = self._get_last_usage()
            results.append(result)
        return results

    def _build_prompt(self, article_text: str) -> str:
        return f"""请分析以下技术文章并生成摘要...

文章内容：
{article_text}"""

    def _get_last_usage(self) -> dict:
        # 获取本次调用的 token 使用量
        pass  # 实际实现中从 response.usage 获取

# 使用
summarizer = ArticleSummarizer()

# 读取文章
articles = [
    Path("articles/article1.md").read_text(),
    Path("articles/article2.md").read_text(),
]

# 批量生成
results = summarizer.batch_summarize(articles)

# 保存结果
for article, result in zip(articles, results):
    print(json.dumps(result, ensure_ascii=False, indent=2))

article = "这里放一篇 500 字以上的技术文章..."

# 实验 1: Zero-shot（最简）
print("=== Zero-shot ===")
print(call_llm(f"总结这篇文章：{article}"))

# 实验 2: + System Prompt
print("\n=== + System Prompt ===")
print(call_llm(f"总结这篇文章：{article}", system=system_prompt))

# 实验 3: + Few-shot
print("\n=== + Few-shot ===")
print(call_llm(few_shot_messages + [user_msg(article)]))

# 实验 4: + CoT
print("\n=== + CoT ===")
print(call_llm(cot_prompt.format(article_text=article)))

# 实验 5: 用推理模型 (o1-mini / deepseek-reasoner)
print("\n=== 推理模型 ===")
print(call_llm(f"总结这篇文章：{article}", model="o1-mini"))