OpenAI API 中文教程
OpenAI API 中文教程
阅读(8) 书签 赞(0) 我要纠错

OpenAI 提示词工程

2026-11-04 18:54 更新

OpenAI API可以让大语言模型根据提示生成代码、数学公式、结构化JSON或自然语言文章，类似ChatGPT。下面使用Responses API，任务是“用一句话写独角兽的睡前故事”。

提示词工程（来源示例1，javascript）

// [中文] 使用Responses生成一句独角兽睡前故事；input保留来源的英文任务。
// [中文] 通过SDK文本汇总入口或响应文本项读取结果，不假定output第一项总是正文。
import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  input: "Write a one-sentence bedtime story about a unicorn.",
});

console.log(response.output_text);

提示词工程（来源示例2，python）

## [中文] 使用Responses生成一句独角兽睡前故事；input保留来源的英文任务。
## [中文] 通过SDK文本汇总入口或响应文本项读取结果，不假定output第一项总是正文。
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input="Write a one-sentence bedtime story about a unicorn.",
)

print(response.output_text)

提示词工程（来源示例3，go）

// [中文] 使用Responses生成一句独角兽睡前故事；input保留来源的英文任务。
// [中文] 通过SDK文本汇总入口或响应文本项读取结果，不假定output第一项总是正文。
package main

import (
    "context"
    "fmt"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

func main() {
    client := openai.NewClient()

    resp, err := client.Responses.New(context.TODO(), responses.ResponseNewParams{
        Model: "gpt-6-astra",
        Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Say this is a test")},
    })
    if err != nil {
        panic(err.Error())
    }

    fmt.Println(resp.OutputText())
}

提示词工程（来源示例4，java）

// [中文] 使用Responses生成一句独角兽睡前故事；input保留来源的英文任务。
// [中文] 通过SDK文本汇总入口或响应文本项读取结果，不假定output第一项总是正文。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

public class Main {
  public static void main(String[] args) {
    OpenAIClient client = OpenAIOkHttpClient.fromEnv();

    ResponseCreateParams params =
        ResponseCreateParams.builder().input("Say this is a test").model("gpt-6-astra").build();

    Response response = client.responses().create(params);
    response.output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(outputText -> System.out.println(outputText.text()));
  }
}

提示词工程（来源示例5，csharp）

// [中文] 使用Responses生成一句独角兽睡前故事；input保留来源的英文任务。
// [中文] 通过SDK文本汇总入口或响应文本项读取结果，不假定output第一项总是正文。
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-6-astra",
    "Say 'this is a test.'"
);

Console.WriteLine($"[ASSISTANT]: {response.GetOutputText()}");

提示词工程（来源示例6，ruby）

## [中文] 使用Responses生成一句独角兽睡前故事；input保留来源的英文任务。
## [中文] 通过SDK文本汇总入口或响应文本项读取结果，不假定output第一项总是正文。
require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-6-astra",
  input: "Write a one-sentence bedtime story about a unicorn."
)

puts(response.output_text)

提示词工程（来源示例7，bash）

## [中文] 使用Responses生成一句独角兽睡前故事；input保留来源的英文任务。
## [中文] 通过SDK文本汇总入口或响应文本项读取结果，不假定output第一项总是正文。
openai responses create \
  --model "gpt-6-astra" \
  --input "Write a one-sentence bedtime story about a unicorn." \
  --raw-output \
  --transform 'output.#(type=="message").content.0.text'

提示词工程（来源示例8，bash）

## [中文] 使用Responses生成一句独角兽睡前故事；input保留来源的英文任务。
## [中文] 通过SDK文本汇总入口或响应文本项读取结果，不假定output第一项总是正文。
curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "input": "Write a one-sentence bedtime story about a unicorn."
    }'

输出内容在output数组中：

提示词工程（来源示例9，json）

[
  {
    "id": "msg_67b73f697ba4819183a15cc17d011509",
    "type": "message",
    "role": "assistant",
    "content": [
      {
        "type": "output_text",
        "text": "Under the soft glow of the moon, Luna the unicorn danced through fields of twinkling stardust, leaving trails of dreams for every child asleep.",
        "annotations": []
      }
    ]
  }
]

响应中text的完整中文对照：“在月光柔和的照耀下，独角兽露娜在闪烁着星尘的原野间起舞，为每个熟睡的孩子留下梦的轨迹。”这是示例输出，不表示每次请求都会生成相同句子。

该数组经常含多个项，包括工具调用和推理相关数据，不能假定文本始终在output[0].content[0].text。部分官方SDK提供output_text汇总全部文本，也可用结构化输出取得受约束JSON。

选择模型

代码的model决定使用哪个模型，完整目录列出选项。来源把模型概括为：推理模型使用内部推理分析输入，擅长复杂任务和多步规划，通常更慢、费用更高；GPT模型快速、经济、智能，但更受益于明确执行指令；大模型跨领域理解和解决问题更强，mini/nano通常更快、更便宜。这里是提示方式的概括，不能仅凭“GPT”名称判断模型是否支持推理。需要通用文本生成及提示迭代时，可从gpt-6-astra开始比较。

提示词工程

提示词工程指编写有效指令，让模型稳定生成符合要求的内容。生成非确定性，提示设计兼具艺术和科学，仍有可重复采用的技术。消息角色等技巧广泛适用，但模型类型乃至同家族快照都可能产生不同结果。复杂应用建议固定快照，例如gpt-4.1-2025-04-14，并建立提示行为测试和评测集，观察迭代、切换或升级模型的影响。

消息角色与指令遵循

使用instructions或消息角色提供不同权限层级的指令。instructions包含语气、目标、正确输出示例等高层要求，优先于input。示例指令译为“像海盗一样说话”，用户问题是“JavaScript中的分号是否可选？”

消息角色与指令遵循（来源示例10，javascript）

// [中文] 通过instructions设置海盗口吻，再把JavaScript分号问题放入input。
// [中文] instructions只约束本次响应；打印生成文本以观察指令效果。
import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  reasoning: { effort: "low" },
  instructions: "Talk like a pirate.",
  input: "Are semicolons optional in JavaScript?",
});

console.log(response.output_text);

消息角色与指令遵循（来源示例11，python）

## [中文] 通过instructions设置海盗口吻，再把JavaScript分号问题放入input。
## [中文] instructions只约束本次响应；打印生成文本以观察指令效果。
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "low"},
    instructions="Talk like a pirate.",
    input="Are semicolons optional in JavaScript?",
)

print(response.output_text)

消息角色与指令遵循（来源示例12，go）

// [中文] 通过instructions设置海盗口吻，再把JavaScript分号问题放入input。
// [中文] instructions只约束本次响应；打印生成文本以观察指令效果。
package main

import (
    "context"
    "fmt"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

func main() {
    client := openai.NewClient()

    response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
        Model:        "gpt-6-astra",
        Instructions: openai.String("Talk like a pirate."),
        Reasoning: responses.ReasoningParam{
            Effort: responses.ReasoningEffortLow,
        },
        Input: responses.ResponseNewParamsInputUnion{
            OfString: openai.String("Are semicolons optional in JavaScript?"),
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.OutputText())
}

消息角色与指令遵循（来源示例13，java）

// [中文] 通过instructions设置海盗口吻，再把JavaScript分号问题放入input。
// [中文] instructions只约束本次响应；打印生成文本以观察指令效果。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.Reasoning;
import com.openai.models.ReasoningEffort;
import com.openai.models.responses.ResponseCreateParams;

String semicolonsDevMsg = "Talk like a pirate.";

String semicolonsPrompt = "Are semicolons optional in JavaScript?";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input(semicolonsPrompt)
        .instructions(semicolonsDevMsg)
        .reasoning(Reasoning.builder().effort(ReasoningEffort.LOW).build())
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

消息角色与指令遵循（来源示例14，csharp）

// [中文] 通过instructions设置海盗口吻，再把JavaScript分号问题放入input。
// [中文] instructions只约束本次响应；打印生成文本以观察指令效果。
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
    Instructions = "Talk like a pirate.",
    ReasoningOptions = new ResponseReasoningOptions
    {
        ReasoningEffortLevel = ResponseReasoningEffortLevel.Low,
    },
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Are semicolons optional in JavaScript?")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

消息角色与指令遵循（来源示例15，ruby）

## [中文] 通过instructions设置海盗口吻，再把JavaScript分号问题放入input。
## [中文] instructions只约束本次响应；打印生成文本以观察指令效果。
require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  instructions: "Talk like a pirate.",
  reasoning: { effort: :low },
  input: "Are semicolons optional in JavaScript?"
)

puts(response.output_text)

消息角色与指令遵循（来源示例16，bash）

## [中文] 通过instructions设置海盗口吻，再把JavaScript分号问题放入input。
## [中文] instructions只约束本次响应；打印生成文本以观察指令效果。
curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "reasoning": {"effort": "low"},
        "instructions": "Talk like a pirate.",
        "input": "Are semicolons optional in JavaScript?"
    }'

大致等价的不同角色消息：

消息角色与指令遵循（来源示例17，javascript）

// [中文] 把海盗口吻放入developer消息，分号问题放入user消息，分别表达应用规则与用户输入。
// [中文] 将消息数组提交给Responses并读取生成文本。
import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  reasoning: { effort: "low" },
  input: [
    {
      role: "developer",
      content: "Talk like a pirate.",
    },
    {
      role: "user",
      content: "Are semicolons optional in JavaScript?",
    },
  ],
});

console.log(response.output_text);

消息角色与指令遵循（来源示例18，python）

## [中文] 把海盗口吻放入developer消息，分号问题放入user消息，分别表达应用规则与用户输入。
## [中文] 将消息数组提交给Responses并读取生成文本。
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "low"},
    input=[
        {"role": "developer", "content": "Talk like a pirate."},
        {"role": "user", "content": "Are semicolons optional in JavaScript?"},
    ],
)

print(response.output_text)

消息角色与指令遵循（来源示例19，go）

// [中文] 把海盗口吻放入developer消息，分号问题放入user消息，分别表达应用规则与用户输入。
// [中文] 将消息数组提交给Responses并读取生成文本。
package main

import (
    "context"
    "fmt"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

func main() {
    client := openai.NewClient()

    response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
        Model: "gpt-6-astra",
        Reasoning: responses.ReasoningParam{
            Effort: responses.ReasoningEffortLow,
        },
        Input: responses.ResponseNewParamsInputUnion{
            OfInputItemList: responses.ResponseInputParam{
                responses.ResponseInputItemParamOfMessage(
                    "Talk like a pirate.",
                    responses.EasyInputMessageRoleDeveloper,
                ),
                responses.ResponseInputItemParamOfMessage(
                    "Are semicolons optional in JavaScript?",
                    responses.EasyInputMessageRoleUser,
                ),
            },
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.OutputText())
}

消息角色与指令遵循（来源示例20，java）

// [中文] 把海盗口吻放入developer消息，分号问题放入user消息，分别表达应用规则与用户输入。
// [中文] 将消息数组提交给Responses并读取生成文本。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.Reasoning;
import com.openai.models.ReasoningEffort;
import com.openai.models.responses.EasyInputMessage;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;

String semicolonsDevMsg = "Talk like a pirate.";

String semicolonsPrompt = "Are semicolons optional in JavaScript?";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input(
            ResponseCreateParams.Input.ofResponse(
                List.of(
                    ResponseInputItem.ofEasyInputMessage(
                        EasyInputMessage.builder()
                            .role(EasyInputMessage.Role.DEVELOPER)
                            .content(semicolonsDevMsg)
                            .build()),
                    ResponseInputItem.ofEasyInputMessage(
                        EasyInputMessage.builder()
                            .role(EasyInputMessage.Role.USER)
                            .content(semicolonsPrompt)
                            .build()))))
        .reasoning(Reasoning.builder().effort(ReasoningEffort.LOW).build())
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

消息角色与指令遵循（来源示例21，csharp）

// [中文] 把海盗口吻放入developer消息，分号问题放入user消息，分别表达应用规则与用户输入。
// [中文] 将消息数组提交给Responses并读取生成文本。
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
    ReasoningOptions = new ResponseReasoningOptions
    {
        ReasoningEffortLevel = ResponseReasoningEffortLevel.Low,
    },
};
options.InputItems.Add(
    ResponseItem.CreateDeveloperMessageItem("Talk like a pirate.")
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Are semicolons optional in JavaScript?")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

消息角色与指令遵循（来源示例22，ruby）

## [中文] 把海盗口吻放入developer消息，分号问题放入user消息，分别表达应用规则与用户输入。
## [中文] 将消息数组提交给Responses并读取生成文本。
require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  reasoning: { effort: :low },
  input: [
    {
      role: :developer,
      content: "Talk like a pirate."
    },
    {
      role: :user,
      content: "Are semicolons optional in JavaScript?"
    }
  ]
)

puts(response.output_text)

消息角色与指令遵循（来源示例23，bash）

## [中文] 把海盗口吻放入developer消息，分号问题放入user消息，分别表达应用规则与用户输入。
## [中文] 将消息数组提交给Responses并读取生成文本。
curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "reasoning": {"effort": "low"},
        "input": [
            {
                "role": "developer",
                "content": "Talk like a pirate."
            },
            {
                "role": "user",
                "content": "Are semicolons optional in JavaScript?"
            }
        ]
    }'

instructions只对当前请求生效。用previous_response_id管理状态时，旧轮次instructions不会自动进入当前上下文。

角色 含义
developer 应用开发者指令，优先于user
user 最终用户指令，优先级低于developer
assistant 模型生成消息

多轮对话可以包含这些消息及其他内容类型，见状态管理。developer类似函数定义，提供规则与业务逻辑；user类似参数，提供应用这些规则所需的输入与配置。

在代码中管理提示词版本

生产提示词放在应用代码，不新建可复用提示词对象。代码管理支持类型化输入、审查、测试及常规部署。

OpenAI正弃用API提示词对象：2026年6月3日起淡化创建入口，v1/prompts计划于2026年11月30日关闭，见当前时间线。新工作将构造器放在相关功能附近的小模块；动态客户资料、文件和选项用类型化参数或Schema；把生成的instructions和input直接传给Responses；变更前补代表性样本、测试和评测；通过部署发布，需要时用功能开关或配置分阶段推出。已有ID或版本调用应按迁移指南搬入代码。

用Markdown与XML组织消息

写developer和user消息时，Markdown标题、列表可区分小节并表达层级，也便于开发者阅读；XML标签界定参考文档等材料的起止，属性可承载供指令引用的元数据。

developer消息通常按下列顺序组织，最优内容和顺序仍依模型而异：

  • 身份：助手用途、交流风格、高层目标。
  • 指令：如何生成期望响应，应做什么、绝不做什么；可分小节说明函数调用等。
  • 示例：可能输入及期望输出。
  • 上下文：训练集以外的私有数据或其他相关资料，通常放末尾，方便按请求替换。

以下示例要求JavaScript变量采用snake_case、兼容Internet Explorer 6，只返回代码：

用Markdown与XML组织消息（来源示例24，text）

## 身份
你是编程助手，帮助JavaScript代码强制使用snake_case变量，并编写能在Internet Explorer版本6运行的代码。
## 指令
* 定义变量用snake_case，例如my_variable，不用camelCase，例如myVariable。
* 为支持旧浏览器，用旧的var关键字声明变量。
* 不使用Markdown，只返回要求的代码。
## 示例
<user_query>
如何为名字声明一个字符串变量？
</user_query>
<assistant_response>
var first_name = "Anna";
</assistant_response>

下面的请求在instructions中提供指令，用户问题均为“如何为姓氏声明变量？”。JavaScript从fixtures/prompt.txt读取文件，Python、Go、C#、Ruby和cURL使用各自示例中的prompt.txt路径；文件内容可采用上面的命名、旧版var与仅代码要求。Java示例28不读取文件，而是内联设置另一段指令，完整中文为：“你是编程助手。用简洁的JavaScript示例回答，并使用分号。”它没有包含前文snake_case及Internet Explorer 6限制，不能将两种指令视为相同。该Java代码片段依赖外部已初始化的client。

用Markdown与XML组织消息（来源示例25，javascript）

// [中文] 读取提示词文件后赋给instructions，用户变量命名问题放入input；保留文件中的少样本和分隔结构。
// [中文] 发送Responses请求，再读取模型生成的文本；外部资料作为输入内容传递。
import fs from "fs/promises";
import OpenAI from "openai";
const client = new OpenAI();

const instructions = await fs.readFile("fixtures/prompt.txt", "utf-8");

const response = await client.responses.create({
  model: "gpt-6-astra",
  instructions,
  input: "How would I declare a variable for a last name?",
});

console.log(response.output_text);

用Markdown与XML组织消息（来源示例26，python）

## [中文] 读取提示词文件后赋给instructions，用户变量命名问题放入input；保留文件中的少样本和分隔结构。
## [中文] 发送Responses请求，再读取模型生成的文本；外部资料作为输入内容传递。
from openai import OpenAI

client = OpenAI()

with open("prompt.txt", "r", encoding="utf-8") as f:
    instructions = f.read()

response = client.responses.create(
    model="gpt-6-astra",
    instructions=instructions,
    input="How would I declare a variable for a last name?",
)

print(response.output_text)

用Markdown与XML组织消息（来源示例27，go）

// [中文] 读取提示词文件后赋给instructions，用户变量命名问题放入input；保留文件中的少样本和分隔结构。
// [中文] 发送Responses请求，再读取模型生成的文本；外部资料作为输入内容传递。
package main

import (
    "context"
    "fmt"
    "os"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

func main() {
    client := openai.NewClient()

    instructions, err := os.ReadFile("prompt.txt")
    if err != nil {
        panic(err)
    }

    response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
        Model:        "gpt-6-astra",
        Instructions: openai.String(string(instructions)),
        Input: responses.ResponseNewParamsInputUnion{
            OfString: openai.String("How would I declare a variable for a last name?"),
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.OutputText())
}

用Markdown与XML组织消息（来源示例28，java）

// [中文] 直接内联设置instructions：你是编程助手，用简洁的JavaScript示例回答，并使用分号；本段不读取提示词文件。
// [中文] 用户问题是如何为姓氏声明变量；遍历响应的消息和文本项输出文字，本段依赖外部已有client。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .instructions(
            "You are a coding assistant. Answer with concise JavaScript examples and use semicolons.")
        .input("How would I declare a variable for a last name?")
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

用Markdown与XML组织消息（来源示例29，csharp）

// [中文] 读取提示词文件后赋给instructions，用户变量命名问题放入input；保留文件中的少样本和分隔结构。
// [中文] 发送Responses请求，再读取模型生成的文本；外部资料作为输入内容传递。
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

string instructions = await File.ReadAllTextAsync("prompt.txt");
CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
    Instructions = instructions,
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("How would I declare a variable for a last name?")
);

ResponseResult response = await client.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());

用Markdown与XML组织消息（来源示例30，ruby）

## [中文] 读取提示词文件后赋给instructions，用户变量命名问题放入input；保留文件中的少样本和分隔结构。
## [中文] 发送Responses请求，再读取模型生成的文本；外部资料作为输入内容传递。
require "openai"

client = OpenAI::Client.new
instructions = File.read(File.join(__dir__, "prompt.txt"))
response = client.responses.create(
  model: "gpt-6-astra",
  instructions: instructions,
  input: "How would I declare a variable for a last name?"
)

puts(response.output_text)

用Markdown与XML组织消息（来源示例31，bash）

## [中文] 读取提示词文件后赋给instructions，用户变量命名问题放入input；保留文件中的少样本和分隔结构。
## [中文] 发送Responses请求，再读取模型生成的文本；外部资料作为输入内容传递。
curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "instructions": "'"$(< prompt.txt)"'",
    "input": "How would I declare a variable for a last name?"
  }'

用缓存降低成本和延迟

预期重复使用的内容尽量放提示词开头，也放在传给Chat Completions或Responses的JSON请求体中较前的参数位置，以争取提示词缓存收益。实际复用仍需达到对应模型最低长度并匹配合格断点，并非只调整JSON字段顺序就保证命中。

少样本学习

在提示中加入少量输入/输出示例，可引导模型完成新任务，无需微调。模型从示例隐式学习模式，示例应覆盖多样输入及期望输出。通常放在developer消息中。下面按Positive、Negative、Neutral标注短产品评价：

少样本学习（来源示例32，text）

## 身份
你是乐于助人的助手，将短产品评价标为Positive、Negative或Neutral。
## 指令
* 只输出一个词，不加任何格式或评论。
* 根据评价情感，只能输出Positive、Negative、Neutral之一。
## 示例
<product_review id="example-1">
我非常喜欢这款耳机，音质棒极了！
</product_review>
<assistant_response id="example-1">
Positive
</assistant_response>
<product_review id="example-2">
续航还行，但耳垫感觉廉价。
</product_review>
<assistant_response id="example-2">
Neutral
</assistant_response>
<product_review id="example-3">
客服糟糕透了，我再也不会买他们的产品。
</product_review>
<assistant_response id="example-3">
Negative
</assistant_response>

提供相关上下文

补充上下文可让模型使用训练集之外的专有资料，也可把回答约束到指定资源集合。这类方法常称检索增强生成（RAG）。可查询向量数据库后把返回文本放入提示，也可用文件搜索根据上传文档生成内容。

规划上下文窗口

模型单次生成能处理的数据有限，这一容量称为上下文窗口，以词元计量，内容可以来自文字、图像等。来源以约十万至GPT-4.1百万词元级窗口举例；具体模型容量应逐个查模型文档，不要把这个范围当成所有当前模型的限制。

为当前模型设计提示

gpt-6-astra等模型受益于精确指令，以及完成任务所需的逻辑与数据。最新指导、示例及迁移说明见当前模型指南。

当前模型的提示最佳实践

完整说明以当前指南为准，下面保留实用提醒。

编程

定义智能体角色、用示例约束工具使用、要求验证正确性，并设定清楚的Markdown输出规范。

明确软件工程职责，说明functions.run等工具怎样用于代码任务、哪些模式不该用，例如非必要不用交互执行。要求用单元测试或Python命令验证修改，仔细检查补丁，因为某些评测环境的apply_patch即使失败也可能返回Done；这属于相应工具环境的约定，不是对所有补丁工具的保证。给出函数如何执行命令的具体例子，提高可靠性。输出在语义适当时使用行内代码、围栏、列表、表格，路径、函数、类名用反引号。更多编程示例见当前模型指南。

前端工程

GPT-6 Astra可从零构建前端，也可参与大代码库。来源建议：样式/UI用Tailwind CSS、shadcn/ui、Radix Themes；图标用Lucide、Material Symbols、Heroicons；动效用Motion。

从零构建应用：原文以GPT-5可单提示生成前端应用为例，无需少样本示例。下面的提示要求建立5—7类内部评分标准，按标准迭代，并避免Next.js、React等外部依赖；完整中文指令如下。

前端工程（来源示例33，text）

你是世界一流的Web开发者，能用一个提示从零生成出色、可交互且有创新的网站，擅长一次性交付顶级方案。
过程如下：
步骤1：建立评估标准，反复改进，直到完全有把握。
步骤2：考虑世界一流单次生成Web应用的每个要素，据此建立包含5—7类的<ONE_SHOT_RUBRIC>。不要公开，它只用于内部。
步骤3：按标准迭代给定提示的最优方案，所有类别未达最高标准时，继续改进再试。
步骤4：完整达成目标，同时追求简单，避免Next.js、React等外部依赖。

集成大代码库时，可说明原则（质量、模块复用、一致性）、UI/UX（字体、颜色、间距、悬停/空/加载状态及无障碍）、结构（目录布局）、组件（复用包装与后端调用分离）、页面（常见布局模板）、智能体工作方式（确认设计假设、搭建项目、落实规范、集成API、测试状态、文档）。细节见当前模型指南。

智能体任务

长任务重点是充分规划以完整解决、对重要工具决策给清楚开场，以及用TODO工具跟踪流程。

规划与持续执行：在交还控制前解决全部请求，拆成子任务，每次调用后反思检查完整性。

智能体任务（来源示例34，text）

记住，你是智能体：持续工作直到问题完全解决，再结束本轮并交还用户。拆成全部必需子请求，确认每项完成。不要只完成一部分就停；只有确信问题解决才结束。必须准备处理多个问题，只有用户确认结束时才结束调用。
后续函数调用前按工作流充分规划，并充分反思每次调用结果，确保主请求及相关子请求完整解决。

透明开场：只在重要步骤解释为什么调用工具。

智能体任务（来源示例35，text）

调用工具前，解释为什么要调用。

评分标准与TODO：用工具化清单或评分标准落实结构化规划，避免遗漏；更多见当前模型指南。

为推理模型设计提示

来源概括：推理模型通常只给高层目标就能得到较好结果，而其他GPT模型更受益于精确要求。可类比资深同事能自行安排细节、初级同事需要明确输出指令；这只是提示风格的比喻，不是对能力的绝对划分。最佳实践见推理指南。

后续资源

可在Playground迭代提示，了解结构化输出与完整API参考。

其他资源

Cookbook包含代码及第三方链接，如提示库与工具、提示指南、视频课程、改善推理的高级提示论文。

以上内容是否对您有帮助：
← OpenAI 提示词缓存诊断
OpenAI 提示词生成 →
在线笔记
App下载
App下载

扫描二维码

下载编程狮App

公众号
微信公众号

编程狮公众号