GPT-5.5 高级 Prompt 工程实战：从迁移策略到 verbosity 参数的全面指南

import openai

# ❌ 错误做法：直接替换 model 名字，复用旧 prompt
old_system_prompt = """You are an AI assistant. Follow these instructions carefully:
1. Always think step by step and show your reasoning...
2. When answering, use markdown formatting with headers...
3. Include relevant code examples with comments...
4. Add disclaimers when information might be outdated...
5. Structure responses with bullet points for clarity...
6. Never mention your knowledge cutoff...
7. Always provide multiple perspectives...
8. Use formal, professional language...
[还有20多条其他指令]
"""

# ✅ 正确做法：从最小化 prompt 开始
minimal_prompt = """你是一个 AI 编程助手。帮助用户解决编程问题，
提供清晰的解释和可运行的代码示例。"""

client = openai.OpenAI()

# 用代表性测试用例验证 baseline
test_cases = [
    "用 Python 实现一个 LRU Cache",
    "解释 Python 的装饰器是如何工作的",
    "帮我 debug 这段代码的并发 bug",
]

for test in test_cases:
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "system", "content": minimal_prompt},
            {"role": "user", "content": test},
        ],
        temperature=0.7,
    )
    print(f"输入: {test}")
    print(f"输出长度: {len(response.choices[0].message.content)} 字符")
    print("---")

import openai
import tiktoken

client = openai.OpenAI()

def get_response(verbosity: str, question: str) -> dict:
    """测试不同 verbosity 级别的效果"""
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "system", "content": "你是一个 AI 助手。"},
            {"role": "user", "content": question},
        ],
        extra_body={
            "verbosity": verbosity,  # low, medium, high
        },
    )
    
    # 统计 token 消耗
    enc = tiktoken.encoding_for_model("gpt-5.5")
    output_text = response.choices[0].message.content
    output_tokens = len(enc.encode(output_text))
    
    # 计算成本（GPT-5.5: 输入 $5/M, 输出 $30/M）
    input_tokens = response.usage.prompt_tokens
    cost = (input_tokens / 1_000_000 * 5) + (output_tokens / 1_000_000 * 30)
    
    return {
        "verbosity": verbosity,
        "output_tokens": output_tokens,
        "output_chars": len(output_text),
        "cost_usd": round(cost, 6),
        "first_line": output_text.split("\n")[0][:80],
    }

# 测试问题
question = "解释 Python 的全局解释器锁 (GIL) 是什么，它的影响是什么，以及如何绕过它？"

print(f"问题: {question[:60]}...\n")
print(f"{'级别':<8} {'Tokens':>6} {'字符':>6} {'成本($)':>8}  首行摘要")
print("-" * 80)

for level in ["low", "medium", "high"]:
    result = get_response(level, question)
    print(
        f"{result['verbosity']:<8} "
        f"{result['output_tokens']:>6} "
        f"{result['output_chars']:>6} "
        f"{result['cost_usd']:>8.6f}  "
        f"{result['first_line']}"
    )

# 成本对比分析
print("\n--- 成本对比 ---")
low = get_response("low", question)
high = get_response("high", question)
savings = (1 - low["cost_usd"] / high["cost_usd"]) * 100
print(f"使用 low vs high: 节省 {savings:.1f}% 的输出 token 成本")

import openai
from typing import Generator

client = openai.OpenAI()

def chat_with_updates(
    user_message: str,
    system_prompt: str = "你是一个 AI 助手。",
) -> Generator[str, None, str]:
    """
    支持用户可见更新的流式聊天。
    
    在工具调用前发送进度更新，改善长链路任务的 UX。
    """
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_message},
    ]
    
    # 使用 stream=True 获取流式响应
    stream = client.chat.completions.create(
        model="gpt-5.5",
        messages=messages,
        stream=True,
        stream_options={"include_usage": True},
        extra_body={"verbosity": "medium"},
    )
    
    full_response = ""
    tool_calls_buffer = []
    current_content = ""
    
    for chunk in stream:
        delta = chunk.choices[0].delta if chunk.choices else None
        
        if not delta:
            continue
            
        # 检测工具调用开始
        if hasattr(delta, "tool_calls") and delta.tool_calls:
            # 在工具调用前发送可见更新
            if current_content:
                yield f"[进度] {current_content[:100]}...\n"
            tool_calls_buffer.extend(delta.tool_calls)
            continue
        
        # 累积内容
        if hasattr(delta, "content") and delta.content:
            current_content += delta.content
            yield delta.content
    
    # 如果有工具调用，发送最终总结
    if tool_calls_buffer:
        yield "\n[提示] 模型调用了 {} 个工具完成此任务\n".format(
            len(tool_calls_buffer)
        )

# 使用示例
user_query = "帮我搜索并总结 2026 年 Q1 全球 AI 芯片市场的最新趋势"

print(f"用户: {user_query}\n")
print("AI: ", end="")

for chunk in chat_with_updates(user_query):
    print(chunk, end="", flush=True)

print()

import openai
import base64

client = openai.OpenAI()

def analyze_image(image_path: str, detail: str = "auto") -> dict:
    """
    使用不同 image_detail 级别分析图像。
    
    参数:
        image_path: 图像文件路径
        detail: low, high, auto, original
    """
    with open(image_path, "rb") as f:
        image_data = base64.b64encode(f.read()).decode()
    
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": "描述这张图片的内容。",
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{image_data}",
                            "detail": detail,
                        },
                    },
                ],
            },
        ],
        max_tokens=500,
    )
    
    return {
        "detail_level": detail,
        "input_tokens": response.usage.prompt_tokens,
        "output_tokens": response.usage.completion_tokens,
        "total_tokens": response.usage.total_tokens,
        "description": response.choices[0].message.content[:200],
    }

# 对比测试
image_file = "test_image.jpg"

print(f"{'级别':<10} {'输入Tokens':>10} {'输出Tokens':>10} {'总Tokens':>8}")
print("-" * 45)

for detail in ["low", "auto", "high", "original"]:
    try:
        result = analyze_image(image_file, detail)
        print(
            f"{result['detail_level']:<10} "
            f"{result['input_tokens']:>10} "
            f"{result['output_tokens']:>10} "
            f"{result['total_tokens']:>8}"
        )
    except Exception as e:
        print(f"{detail:<10} 错误: {str(e)[:40]}")

import openai
import json

client = openai.OpenAI()

# ❌ 旧的冗长系统提示词（12条规则，约500 tokens）
old_system = """You are an AI programming assistant. Follow these rules:
1. Always think step by step before answering
2. Use markdown formatting for all code blocks
3. Include comments in all code examples
4. Never mention your knowledge cutoff date
5. Provide multiple solutions when applicable
6. Explain trade-offs for each solution
7. Use formal, professional language
8. Include error handling in code examples
9. Add type hints to Python code
10. Never output incomplete code
11. Always cite sources for factual claims
12. Ask clarifying questions when requirements are unclear
... (more rules)
"""

# ✅ GPT-5.5 优化后的精简系统提示词（约50 tokens）
new_system = """你是一个 AI 编程助手。帮助用户解决编程问题，
提供清晰的解释和可运行的代码示例。"""

test_question = "用 Python 实现一个线程安全的计数器"

def test_prompt(system: str, name: str):
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": test_question},
        ],
        temperature=0.7,
    )
    
    output = response.choices[0].message.content
    return {
        "name": name,
        "system_tokens": len(system.split()),
        "output_tokens": response.usage.completion_tokens,
        "total_cost": response.usage.total_tokens,
        "has_error_handling": "try" in output or "except" in output or "Lock" in output,
        "has_type_hints": ":" in output and "->" in output,
        "output_length": len(output),
    }

print(f"测试问题: {test_question}\n")
print(f"{'方案':<8} {'系统Tokens':>10} {'输出Tokens':>10} {'总Tokens':>8} {'有错误处理':>10} {'有类型提示':>10}")
print("-" * 70)

for system, name in [(old_system, "冗长"), (new_system, "精简")]:
    result = test_prompt(system, name)
    print(
        f"{result['name']:<8} "
        f"{result['system_tokens']:>10} "
        f"{result['output_tokens']:>10} "
        f"{result['total_cost']:>8} "
        f"{'✅' if result['has_error_handling'] else '❌':>10} "
        f"{'✅' if result['has_type_hints'] else '❌':>10}"
    )

print("\n结论：精简系统提示词在保持代码质量的同时，显著降低了 token 消耗。")

import openai
from pydantic import BaseModel, Field
from typing import Literal

client = openai.OpenAI()

# ✅ GPT-5.5 优化的工具定义
tools = [
    {
        "type": "function",
        "function": {
            "name": "search_knowledge_base",
            "description": (
                "在知识库中执行语义搜索。返回最相关的文档片段，"
                "按相关性分数降序排列。当用户询问特定主题、"
                "概念或需要查找信息时使用此工具。"
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": (
                            "搜索查询。使用用户问题的核心关键词，"
                            "而不是完整的问题句子。例如：'Python GIL 影响' "
                            "而不是 'Python 的全局解释器锁有什么影响？'"
                        ),
                    },
                    "top_k": {
                        "type": "integer",
                        "description": "返回结果数量。默认 5，最大 20。",
                        "default": 5,
                        "minimum": 1,
                        "maximum": 20,
                    },
                    "filter": {
                        "type": "object",
                        "description": "可选的过滤条件。",
                        "properties": {
                            "category": {
                                "type": "string",
                                "enum": ["programming", "ai", "devops", "data"],
                                "description": "按类别过滤。",
                            },
                            "date_range": {
                                "type": "string",
                                "description": "日期范围，格式：YYYY-MM-DD to YYYY-MM-DD",
                            },
                        },
                    },
                },
                "required": ["query"],
            },
        },
    }
]

# 测试工具调用
messages = [
    {"role": "system", "content": "你是一个技术助手，可以搜索知识库回答问题。"},
    {"role": "user", "content": "Python 的 GIL 对多线程性能有什么影响？"},
]

response = client.chat.completions.create(
    model="gpt-5.5",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

# 检查是否调用了工具
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    print(f"工具: {tool_call.function.name}")
    print(f"参数: {tool_call.function.arguments}")
else:
    print("模型直接回答了，未调用工具")
    print(f"回答: {response.choices[0].message.content[:200]}")

import openai
import time

client = openai.OpenAI()

def chat_with_reasoning_control(
    question: str,
    complexity: str = "medium",
) -> dict:
    """
    根据问题复杂度选择合适的推理模式。
    
    complexity: "low" | "medium" | "high"
    """
    # 推理模式映射
    reasoning_map = {
        "low": {"reasoning_effort": "low"},
        "medium": {"reasoning_effort": "medium"},
        "high": {"reasoning_effort": "high"},
    }
    
    start = time.time()
    
    response = client.chat.completions.create(
        model="gpt-5.5",
        messages=[
            {"role": "system", "content": "你是一个 AI 助手。"},
            {"role": "user", "content": question},
        ],
        extra_body=reasoning_map.get(complexity, reasoning_map["medium"]),
        verbosity="medium",
    )
    
    elapsed = time.time() - start
    
    return {
        "complexity": complexity,
        "latency_ms": round(elapsed * 1000, 1),
        "input_tokens": response.usage.prompt_tokens,
        "output_tokens": response.usage.completion_tokens,
        "total_tokens": response.usage.total_tokens,
        "answer_preview": response.choices[0].message.content[:150],
    }

# 测试不同复杂度场景
test_questions = [
    ("Python 的 list 和 tuple 有什么区别？", "low"),
    ("用 Python 实现一个 LRU Cache，要求 O(1) 时间复杂度", "medium"),
    ("分析这段并发代码中的 race condition，并给出修复方案", "high"),
]

print(f"{'场景':<10} {'延迟(ms)':>8} {'总Tokens':>8}  回答预览")
print("-" * 70)

for question, complexity in test_questions:
    result = chat_with_reasoning_control(question, complexity)
    print(
        f"{complexity:<10} "
        f"{result['latency_ms']:>8} "
        f"{result['total_tokens']:>8}  "
        f"{result['answer_preview'][:50]}..."
    )

import openai
import json
import os
from pathlib import Path

client = openai.OpenAI()

def check_gpt55_readiness(project_dir: str) -> dict:
    """
    检查项目是否已准备好迁移到 GPT-5.5。
    """
    issues = []
    suggestions = []
    
    # 检查 1: 搜索旧的模型名引用
    for filepath in Path(project_dir).rglob("*.py"):
        content = filepath.read_text()
        if "gpt-5.2" in content or "gpt-5.4" in content:
            issues.append(f"发现旧模型名引用: {filepath}")
            suggestions.append(f"将 {filepath} 中的模型名更新为 gpt-5.5")
        
        # 检查 2: 是否缺少 verbosity 参数
        if "chat.completions.create" in content and "verbosity" not in content:
            issues.append(f"缺少 verbosity 参数: {filepath}")
            suggestions.append(
                f"在 {filepath} 的 API 调用中添加 verbosity 参数"
            )
        
        # 检查 3: 检查系统提示词长度
        if 'system", "content"' in content:
            # 简单估算系统提示词长度
            import re
            system_prompts = re.findall(
                r'"system".*?"content":s*"([^"]+)"', content
            )
            for sp in system_prompts:
                word_count = len(sp.split())
                if word_count > 200:
                    issues.append(
                        f"系统提示词过长 ({word_count} words): {filepath}"
                    )
                    suggestions.append(
                        f"精简 {filepath} 中的系统提示词，"
                        f"建议不超过 100 words"
                    )
    
    return {
        "issues": issues,
        "suggestions": suggestions,
        "ready": len(issues) == 0,
    }

# 使用示例
result = check_gpt55_readiness(".")

print("=== GPT-5.5 迁移检查报告 ===\n")

if result["ready"]:
    print("✅ 项目已准备好迁移到 GPT-5.5！")
else:
    print(f"❌ 发现 {len(result['issues'])} 个问题：\n")
    for i, issue in enumerate(result["issues"], 1):
        print(f"{i}. {issue}")
    
    print(f"\n💡 建议：")
    for i, suggestion in enumerate(result["suggestions"], 1):
        print(f"  {i}. {suggestion}")