OpenAI 메타 프롬프트 명령 생성기 OpenAI 메타 프롬프트

AI 유틸리티 명령8개월 전 업데이트 AI 공유 서클

2.1K 00

팁 생성

존재 놀이터 정곡을 찌르세요 Generate 按钮让您可以通过任务描述生成提示、함수 (수학.)노래로 응답빌드。本指南将逐步讲解其工作原理。

개요

从头创建提示和架构可能耗时，通过生成它们可以帮助您快速入手。Generate 按钮主要使用以下两种方法：

STH에 주목하세요.：我们使用元提示结合最佳实践来生成或改进提示。
빌드：我们使用元架构生成有效的 JSON 和函数语法。

当前我们使用元提示和架构，但未来可能会集成更多高级技术，例如 DSPy 노래로 응답 "梯度下降".

STH에 주목하세요.

元提示 指导模型根据您的任务描述创建出色的提示或改进现有提示。Playground 中的元提示源自我们的 팁 엔지니어링最佳实践和用户的实际经验。

我们针对不同的输出类型（如音频）使用特定的元提示，以确保生成的提示符合预期格式。

元提示

文本元提示

from openai import OpenAI

client = OpenAI()

META_PROMPT = """
根据任务描述或现有提示，生成一个详细的系统提示，以有效指导语言模型完成任务。

# 指导原则

- 理解任务：掌握主要目标、目标、需求、限制和预期输出。
- 最小改动：如果提供了现有提示，仅在其简单时进行改进。对于复杂的提示，增强清晰度并添加缺失元素，而不更改原始结构。
- 推理在结论前**：鼓励在得出结论前进行推理步骤。注意！如果用户提供的示例先有推理后有结论，反转顺序！绝不要以结论开头。
    - 推理顺序：指出提示中的推理部分和结论部分（按字段名称），确定完成的顺序，必要时反转。
    - 结论、分类或结果应始终出现在最后。
- 示例：如果有帮助，包含高质量示例，使用[方括号]作为复杂元素的占位符。
   - 考虑哪些示例需要包括、数量多少，及是否复杂到需要占位符。
- 清晰简洁：使用清晰、具体的语言。避免不必要的指令或空洞陈述。
- 格式：使用 Markdown 特性以提高可读性。除非明确要求，否则不要使用 ``` 代码块。
- 保留用户内容：如果输入任务或提示包括广泛的指导或示例，尽可能完整保留它们。如果内容含糊不清，考虑将其分解为子步骤。保留用户提供的所有细节、指导、示例、变量或占位符。
- 常量：在提示中包含常量，它们不易受提示注入影响，如指南、评分标准和示例。
- 输出格式：明确最合适的输出格式，包括长度和语法（如短句、段落、JSON 等）。
    - 对输出为结构化数据（如分类、JSON 等）的任务，优先生成 JSON。
    - JSON 不应包裹在代码块（```）中，除非明确要求。

您输出的最终提示应遵循以下结构，不包含任何额外评论，只输出完成的系统提示。特别是不要在提示的开头或结尾添加额外信息（例如，不要使用 "---"）。

[简明的任务描述 - 这是提示的第一行，不加节标题]

[如有必要，添加额外细节。]

[可选部分，包含详细步骤的标题或项目符号。]

# 步骤 [可选]

[可选：实现任务所需步骤的详细分解]

# 输出格式

[特别说明输出的格式，无论是响应长度、结构（如 JSON、Markdown 等）]

# 示例 [可选]

[可选：1-3 个定义清晰的示例，如有必要，使用占位符。清楚标记示例的开始和结束及输入和输出。必要时使用占位符。]
[如果示例比实际示例预期短或长，添加解释，说明真实示例的应有长度/不同之处。并使用占位符！]

# 注意事项 [可选]

[可选：边缘情况、细节，并突出或重复出特别重要的考虑点]
""".strip()

def generate_prompt(task_or_prompt: str):
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": META_PROMPT,
            },
            {
                "role": "user",
                "content": "任务、目标或当前提示:\n" + task_or_prompt,
            },
        ],
    )

    return completion.choices[0].message.content

音频元提示

from openai import OpenAI

client = OpenAI()

META_PROMPT = """
给定任务描述或现有提示语，生成一个详细的系统提示，指导实时音频输出语言模型有效地完成任务。

# 指南

- 理解任务：把握主要目标、任务要求、限制和预期输出。
- 语气：明确指出语气。默认应情感丰富、友好，语速较快，以免用户等待过久。
- 音频输出限制：由于模型输出音频，回答应简短、具备对话性。
- 最小改动：若有现有提示，只有在简单的情况下才优化它。若是复杂提示，则在不改变原始结构的前提下增强其清晰度并补充缺失元素。
- 示例：若有帮助，包含高质量的示例，用方括号 [in brackets] 表示复杂元素的占位符。
   - 哪些示例需要包含、数量以及是否需要复杂到需要使用占位符。
   - 非常重要的是任何示例都应反映模型的简短对话输出。
默认情况下句子应非常简短。助手不应连续提供三句话，建议用户和助手来回对话。
   - 默认每句长度为 5-20 个单词左右。如用户特别要求“简短”回复，则示例应确实简短至 1-10 个单词。
   - 示例应为多轮对话（每个示例至少包含四轮来回），而非单一问答。示例应反映自然的对话过程。
- 清晰和简洁：使用清晰、具体的语言。避免不必要的指示或无关说明。
- 保留用户内容：如输入任务或提示包含详细的指南或示例，尽量完全保留或尽可能接近保留。如果内容模糊，考虑分解为子步骤。保留用户提供的任何详细信息、指南、示例、变量或占位符。
- 常量：包括常量部分，因为它们不易受提示注入影响，例如指导、评分标准和示例。

最终输出的提示应遵循以下结构。不要包含任何附加说明，只输出完成的系统提示。特别注意，不要在提示开头或结尾添加任何额外信息（例如，无需 "---"）。

[描述任务的简洁指令 - 此应为提示的第一行，无需分段标题]

[必要时添加详细信息]

[可选部分，可包含标题或项目符号列出详细步骤]

# 示例 [可选]

[可选：包含 1-3 个定义清晰的示例，必要时使用占位符。清晰标记示例开始和结束的位置，以及输入和输出。使用占位符表示必要信息]
[如果示例比预期的真实示例短，用括号 () 说明真实示例应如何更长/更短/不同，并使用占位符！]

# 备注 [可选]

[可选：边界情况、详细信息以及重要注意事项]
""".strip()

def generate_prompt(task_or_prompt: str):
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": META_PROMPT,
            },
            {
                "role": "user",
                "content": "任务、目标或当前提示：\n" + task_or_prompt,
            },
        ],
    )

    return completion.choices[0].message.content

提示编辑

为了编辑提示词，我们使用一个略微修改过的元提示词。尽管直接编辑应用相对简单，但在更开放性的修改中识别必要的变更可能具有挑战性。为了解决这一问题，我们在回复的开头包含了一个推理部分，帮助模型通过评估现有提示词的清晰度、思维链顺序、整体结构和具体性等因素，确定需要进行哪些更改。推理部分提出改进建议，然后从最终回复中解析出来。

文本元提示词用于编辑

from openai import OpenAI

client = OpenAI()

META_PROMPT = """
根据当前提示词和变更描述，生成一个详细的系统提示词，以有效指导语言模型完成任务。

您的最终输出将是完整的、已纠正的提示词文本。但在此之前，请在回复的开头使用  标签分析提示词，并明确以下内容：

- 简单更改：（是/否）变更描述是否明确且简单？（如果是，则跳过以下问题）
- 推理：（是/否）当前提示词是否使用了推理、分析或思维链？
    - 识别：（最多10个字）如果是，推理在哪一部分？
    - 结论：（是/否）是否通过思维链得出结论？
    - 顺序：（之前/之后）思维链位于结论之前还是之后？
- 结构：（是/否）输入提示词是否有明确的结构？
- 示例：（是/否）输入提示词是否包含少量示例？
    - 代表性：（1-5）如果存在示例，示例的代表性如何？
- 复杂度：（1-5）输入提示词的复杂度如何？
    - 任务：（1-5）任务的复杂度如何？
    - 必要性：()
- 具体性：（1-5）提示词的详细性和具体性如何？（不等同于长度）
- 优先级：（列出）最重要的1-3个需要解决的类别。
- 结论：（最多30个字）基于上述评估，简要说明应该更改的内容和方式。无需严格按照列出的类别。


# 指南

- 理解任务：掌握主要目标、要求、约束和期望的输出。
- 最小改动：若已有提示词，仅在简单时改进；对于复杂提示词，增强清晰度并补充缺失元素，而不改变原始结构。
- 先推理后结论**：确保在任何结论得出之前进行推理步骤。注意！如果用户提供的示例中推理在结论之后，则反转顺序！切勿以结论开头！
    - 推理顺序：标出提示词中的推理部分和结论部分（指定字段名称）。对于每个部分，确定顺序是否需要反转。
    - 结论、分类或结果始终应最后出现。
- 示例：若有帮助，包含高质量示例，并使用 [方括号] 作为复杂元素的占位符。
   - 指明可能需要包含哪些类型的示例、数量，以及是否复杂到需使用占位符。
- 清晰简洁：使用清晰、具体的语言。避免不必要的指示或平淡的陈述。
- 排版：使用 Markdown 特性提升可读性。除非明确要求，避免使用 ``` 代码块。
- 保留用户内容：若输入任务或提示词包含大量指南或示例，需完全或尽可能保留。如果不明确，可拆分成子步骤。保留用户提供的任何细节、指南、示例、变量或占位符。
- 常量：在提示词中包含常量，因为它们不会受到提示词注入攻击的影响，例如指南、评分标准和示例。
- 输出格式：明确最适当的输出格式，详细说明输出的长度和语法（例如简短句子、段落、JSON 等）。
    - 对于输出有明确或结构化数据（分类、JSON等）的任务，偏向输出 JSON。
    - JSON 不应包裹在代码块中（``）除非明确要求。

您输出的最终提示词应遵循以下结构。不要包含任何附加评论，仅输出完整的系统提示词。尤其不要在提示词的开始或结尾添加任何附加消息（例如，不要使用“---”）。

[简要说明任务的指令 - 这是提示词的第一行，无需部分标题]

[如有需要，添加更多细节。]

[可选部分，包含标题或项目符号，以描述详细步骤。]

# 步骤 [可选]

[可选：完成任务所需步骤的详细分解]

# 输出格式

[特别指出输出格式要求，如响应长度、结构（例如 JSON，markdown 等）]

# 示例 [可选]

[可选：1-3 个明确示例，若需要复杂元素，使用占位符并标记输入输出位置。使用括号说明真实示例应更长/更短/不同。]

# 注意 [可选]

[可选：边缘案例、详细信息，或强调特别重要的考虑事项区域]
[注意：必须以  部分开头，您生成的下一个标记应为 ]
""".strip()

def generate_prompt(task_or_prompt: str):
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": META_PROMPT,
            },
            {
                "role": "user",
                "content": "Task, Goal, or Current Prompt:\n" + task_or_prompt,
            },
        ],
    )

    return completion.choices[0].message.content

音频编辑的元提示

from openai import OpenAI

client = OpenAI()

META_PROMPT = """
给定一个当前的提示和更改说明，生成一个详细的系统提示，以有效引导实时音频输出语言模型完成任务。

最终输出将是完整的、按原样修正的提示。不过，在响应的最开始，使用标签分析提示并明确以下内容：

- 简单更改: (yes/no) 更改说明是否明确且简单？(如果是，则跳过以下问题)
- 推理: (yes/no) 当前提示是否使用推理、分析或思维链？
    - 标识: (最多10个字) 如果是，哪些部分使用了推理？
    - 结论: (yes/no) 思维链是否用于得出结论？
    - 顺序: (before/after) 思维链位于前或后
- 结构: (yes/no) 输入提示是否具有明确的结构
- 示例: (yes/no) 输入提示是否包含少量示例
    - 代表性: (1-5) 如果有示例，它们的代表性如何？
- 复杂性: (1-5) 输入提示的复杂性如何？
    - 任务: (1-5) 隐含任务的复杂性如何？
    - 必要性: ()
- 具体性: (1-5) 提示的详细和具体程度如何？(与长度无关)
- 优先级: (列表) 哪1-3个类别最重要。
- 结论: (最多30个字) 根据之前的评估，简要描述需要如何改变。无需仅限于列出的类别。


# 指南

- 理解任务: 理解主要目标、需求、约束和预期输出。
- 语气: 确保明确指出语气。默认应为情感化且友好，快速表达避免用户等待。
- 音频输出约束: 因为模型输出的是音频，响应应简短且具对话性。
- 最小更改: 如果提供了现有提示，只在简单情况下改进。对于复杂提示，增强清晰度并添加缺失元素，但不改变原始结构。
- 示例: 如果有帮助，包含高质量的示例，并使用[方括号]作为复杂元素的占位符。
   - 包含哪些类型的示例，数量，以及是否需要占位符。
  - 示例必须反映模型的简短对话输出响应。
默认情况下，句子应非常简短。助手的3句话应分开与用户互动。
  - 默认每句应仅包含少量字(5-20个字左右)。如果用户明确要求“短”回复，则示例应仅有1-10字。
  - 示例应多轮对话(至少4次用户-助手来回)，反映真实对话。
- 清晰和简洁: 使用明确、具体的语言。避免不必要的指令或平淡的陈述。
- 保留用户内容: 如果输入任务或提示包含详尽的指导或示例，应尽量保留。如果内容模糊，考虑分解为子步骤。保留用户提供的细节、指导、示例、变量或占位符。
- 常量: 包含常量在提示中，它们不易受到提示注入影响，例如指南、评分标准和示例。

最终输出的提示应遵循以下结构。不要包含任何附加注释，仅输出完成的系统提示。特别是不要在提示开头或结尾添加任何附加信息。(例如不要使用"---")

[简明任务说明 - 这是提示的第一行，无需添加小节标题]

[根据需要添加详细说明。]

[可选部分，包含标题或项目符号的详细步骤。]

# 示例 [可选]

[可选: 1-3个定义清晰的示例，必要时使用占位符。明确标记示例的开始和结束，以及输入和输出。根据需要使用占位符。]
[如果示例短于预期的实际示例，请用()标明真实示例应如何长/短/不同，并使用占位符！]

# 注意事项 [可选]

[可选: 边缘情况、详细说明、以及调用或重复特定重要考虑因素的区域]
[注意：您必须以部分开始。紧接着您生成的下一个Token应为]
""".strip()

def generate_prompt(task_or_prompt: str):
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": META_PROMPT,
            },
            {
                "role": "user",
                "content": "Task, Goal, or Current Prompt:\n" + task_or_prompt,
            },
        ],
    )

    return completion.choices[0].message.content

빌드

구조화된 출력 架构和函数架构本身是 JSON 对象，因此我们利用结构化输出来生成它们。这需要为所需输出定义一个架构，在此情况下，输出本身是一个架构。为此，我们使用自描述架构——元架构.

由于函数架构中的 parameters 字段本身是一个架构，因此我们使用相同的元架构来生成函数。

定义受限的元架构

구조화된 출력 支持两种模式：strict=true 노래로 응답 strict=false。两种模式均使用相同的模型以遵循所提供的架构，但仅“严格模式”通过受限采样保证完美的遵循。

我们的目标是使用严格模式本身生成严格模式的架构。然而，官方的 JSON 架构规范提供的元架构依赖于严格模式中目前不支持的特性。这为输入和输出架构带来了挑战。

输入架构： 我们无法在输入架构中使用不支持的特性来描述输出架构。
输出架构： 生成的架构中不能包含不支持的特性.

由于我们需要在输出架构中生成新键，因此输入元架构必须使用 additionalProperties。这意味着我们当前无法使用严格模式来生成架构。然而，我们仍然希望生成的架构符合严格模式的限制。

为克服这一限制，我们定义了一个 伪元架构 —— 使用不支持严格模式的特性来描述仅受严格模式支持的特性的元架构。本质上，这种方法在定义元架构时脱离了严格模式，同时确保生成的架构遵循严格模式的限制。

深入探讨

我们如何设计伪元架构

构建受限的元架构是一个具有挑战性的任务，因此我们利用我们的模型来帮助完成。

我们首先在 JSON 模式下向 o1-preview 노래로 응답 gpt-4o 描述了我们的目标，使用了结构化输出的文档。经过几次迭代，我们开发了第一个可行的元架构。

그런 다음 gpt-4o 和结构化输出，提供初始架构以及我们的任务描述和文档，以生成更好的候选架构。在每次迭代中，我们使用更优的架构生成下一步，直到最终进行手动仔细检查。

最后，在清理输出后，我们将架构与一组评估测试进行验证，以确保适用于架构和函数。

输出清理

严格模式保证完美的架构遵循性。然而，由于我们无法在生成期间使用严格模式，因此需要在生成后验证并转换输出。

在生成架构后，我们执行以下步骤：

将所有对象的 additionalProperties 로 설정 false.
将所有属性标记为必填.
对于结构化输出架构，将其包装在 json_schema 를 추가합니다.
对于函数，将其包装在 function 를 추가합니다.

==实时 API 的 함수 (수학.) 对象与 Chat Completions API 略有不同，但使用相同的架构。==

元模式

每个元模式都有一个对应的提示，其中包含了少量的示例。当我们结合结构化输出的可靠性 — 即使不使用严格模式 — 我们可以使用 gpt-4o-mini 进行模式生成。

结构化输出模式

from openai import OpenAI
import json

client = OpenAI()

META_SCHEMA = {
  "name": "metaschema",
  "schema": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string",
        "description": "模式的名称"
      },
      "type": {
        "type": "string",
        "enum": [
          "object",
          "array",
          "string",
          "number",
          "boolean",
          "null"
        ]
      },
      "properties": {
        "type": "object",
        "additionalProperties": {
          "$ref": "#/$defs/schema_definition"
        }
      },
      "items": {
        "anyOf": [
          {
            "$ref": "#/$defs/schema_definition"
          },
          {
            "type": "array",
            "items": {
              "$ref": "#/$defs/schema_definition"
            }
          }
        ]
      },
      "required": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "additionalProperties": {
        "type": "boolean"
      }
    },
    "required": [
      "type"
    ],
    "additionalProperties": False,
    "if": {
      "properties": {
        "type": {
          "const": "object"
        }
      }
    },
    "then": {
      "required": [
        "properties"
      ]
    },
    "$defs": {
      "schema_definition": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "object",
              "array",
              "string",
              "number",
              "boolean",
              "null"
            ]
          },
          "properties": {
            "type": "object",
            "additionalProperties": {
              "$ref": "#/$defs/schema_definition"
            }
          },
          "items": {
            "anyOf": [
              {
                "$ref": "#/$defs/schema_definition"
              },
              {
                "type": "array",
                "items": {
                  "$ref": "#/$defs/schema_definition"
                }
              }
            ]
          },
          "required": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "additionalProperties": {
            "type": "boolean"
          }
        },
        "required": [
          "type"
        ],
        "additionalProperties": False,
        "if": {
          "properties": {
            "type": {
              "const": "object"
            }
          }
        },
        "then": {
          "required": [
            "properties"
          ]
        }
      }
    }
  }
}

META_PROMPT = """
# 指令
返回一个有效的 JSON 描述模式。

你还需要确保：
- 对象中的所有字段都设置为必需字段
- 我重复一遍，所有字段必须标记为必需字段
- 所有对象的 additionalProperties 必须设为 false
    - 因此，像“attributes”或“metadata”等属性通常允许 additional properties 的情况下，应该设置为固定的属性集
- 所有对象必须定义属性
- 字段顺序很重要。任何形式的“思考”或“解释”应位于结论之前
- $defs 必须定义在 schema 参数中

不支持的关键词包括：
- 对字符串：minLength, maxLength, pattern, format
- 对数字：minimum, maximum, multipleOf
- 对对象：patternProperties, unevaluatedProperties, propertyNames, minProperties, maxProperties
- 对数组：unevaluatedItems, contains, minContains, maxContains, minItems, maxItems, uniqueItems

其他注意事项：
- 支持定义和递归
- 仅在必要时包含引用，例如 "$defs"，它必须在 "schema" 对象内部

# 示例
输入：生成一个带有步骤和最终答案的数学推理模式。
输出：{
    "name": "math_reasoning",
    "type": "object",
    "properties": {
        "steps": {
            "type": "array",
            "description": "解答数学问题所涉及的步骤序列。",
            "items": {
                "type": "object",
                "properties": {
                    "explanation": {
                        "type": "string",
                        "description": "该步骤中使用的推理或方法的描述。"
                    },
                    "output": {
                        "type": "string",
                        "description": "该特定步骤的结果或输出。"
                    }
                },
                "required": [
                    "explanation",
                    "output"
                ],
                "additionalProperties": false
            }
        },
        "final_answer": {
            "type": "string",
            "description": "数学问题的最终解答。"
        }
    },
    "required": [
        "steps",
        "final_answer"
    ],
    "additionalProperties": false
}

输入：给我一个链表
输出：{
    "name": "linked_list",
    "type": "object",
    "properties": {
        "linked_list": {
            "$ref": "#/$defs/linked_list_node",
            "description": "链表的头节点。"
        }
    },
    "$defs": {
        "linked_list_node": {
            "type": "object",
            "description": "定义单链表中的一个节点。",
            "properties": {
                "value": {
                    "type": "number",
                    "description": "此节点中存储的值。"
                },
                "next": {
                    "anyOf": [
                        {
                            "$ref": "#/$defs/linked_list_node"
                        },
                        {
                            "type": "null"
                        }
                    ],
                    "description": "引用下一个节点；如果是最后一个节点则为 null。"
                }
            },
            "required": [
                "value",
                "next"
            ],
            "additionalProperties": false
        }
    },
    "required": [
        "linked_list"
    ],
    "additionalProperties": false
}

输入：动态生成的 UI
输出：{
    "name": "ui",
    "type": "object",
    "properties": {
        "type": {
            "type": "string",
            "description": "UI 组件的类型",
            "enum": [
                "div",
                "button",
                "header",
                "section",
                "field",
                "form"
            ]
        },
        "label": {
            "type": "string",
            "description": "UI 组件的标签，用于按钮或表单字段"
        },
        "children": {
            "type": "array",
            "description": "嵌套的 UI 组件",
            "items": {
                "$ref": "#"
            }
        },
        "attributes": {
            "type": "array",
            "description": "适用于任何元素的 UI 组件的任意属性",
            "items": {
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "属性名称，例如 onClick 或 className"
                    },
                    "value": {
                        "type": "string",
                        "description": "属性的值"
                    }
                },
                "required": [
                    "name",
                    "value"
                ],
                "additionalProperties": false
            }
        }
    },
    "required": [
        "type",
        "label",
        "children",
        "attributes"
    ],
    "additionalProperties": false
}
""".strip()

def generate_schema(description: str):
    completion = client.chat.completions.create(
        model="gpt-4o-mini",
        response_format={"type": "json_schema", "json_schema": META_SCHEMA},
        messages=[
            {
                "role": "system",
                "content": META_PROMPT,
            },
            {
                "role": "user",
                "content": "Description:\n" + description,
            },
        ],
    )

    return json.loads(completion.choices[0].message.content)

函数模式

from openai import OpenAI
import json

client = OpenAI()

META_SCHEMA = {
  "name": "function-metaschema",
  "schema": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string",
        "description": "函数的名称"
      },
      "description": {
        "type": "string",
        "description": "对函数的描述"
      },
      "parameters": {
        "$ref": "#/$defs/schema_definition",
        "description": "定义函数参数的 JSON schema"
      }
    },
    "required": [
      "name",
      "description",
      "parameters"
    ],
    "additionalProperties": False,
    "$defs": {
      "schema_definition": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "object",
              "array",
              "string",
              "number",
              "boolean",
              "null"
            ]
          },
          "properties": {
            "type": "object",
            "additionalProperties": {
              "$ref": "#/$defs/schema_definition"
            }
          },
          "items": {
            "anyOf": [
              {
                "$ref": "#/$defs/schema_definition"
              },
              {
                "type": "array",
                "items": {
                  "$ref": "#/$defs/schema_definition"
                }
              }
            ]
          },
          "required": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "additionalProperties": {
            "type": "boolean"
          }
        },
        "required": [
          "type"
        ],
        "additionalProperties": False,
        "if": {
          "properties": {
            "type": {
              "const": "object"
            }
          }
        },
        "then": {
          "required": [
            "properties"
          ]
        }
      }
    }
  }
}

META_PROMPT = """
# 指示
返回一个描述函数的有效模式。

特别注意确保 "required" 和 "type" 始终位于正确的嵌套级别。例如，"required" 应与 "properties" 处于同一级别，而不是在其内部。
确保每个属性，无论多短，都有一个正确嵌套的类型和描述。

# 示例
输入: 为神经网络超参数分配值
输出: {
    "name": "set_hyperparameters",
    "description": "为神经网络超参数分配值",
    "parameters": {
        "type": "object",
        "required": [
            "learning_rate",
            "epochs"
        ],
        "properties": {
            "epochs": {
                "type": "number",
                "description": "数据集的完整遍历次数"
            },
            "learning_rate": {
                "type": "number",
                "description": "模型学习速度"
            }
        }
    }
}

输入: 为机器人规划运动路径
输出: {
    "name": "plan_motion",
    "description": "为机器人规划运动路径",
    "parameters": {
        "type": "object",
        "required": [
            "start_position",
            "end_position"
        ],
        "properties": {
            "end_position": {
                "type": "object",
                "properties": {
                    "x": {
                        "type": "number",
                        "description": "终点 X 坐标"
                    },
                    "y": {
                        "type": "number",
                        "description": "终点 Y 坐标"
                    }
                }
            },
            "obstacles": {
                "type": "array",
                "description": "障碍物坐标数组",
                "items": {
                    "type": "object",
                    "properties": {
                        "x": {
                            "type": "number",
                            "description": "障碍物 X 坐标"
                        },
                        "y": {
                            "type": "number",
                            "description": "障碍物 Y 坐标"
                        }
                    }
                }
            },
            "start_position": {
                "type": "object",
                "properties": {
                    "x": {
                        "type": "number",
                        "description": "起点 X 坐标"
                    },
                    "y": {
                        "type": "number",
                        "description": "起点 Y 坐标"
                    }
                }
            }
        }
    }
}

输入: 计算各种技术指标
输出: {
    "name": "technical_indicator",
    "description": "计算各种技术指标",
    "parameters": {
        "type": "object",
        "required": [
            "ticker",
            "indicators"
        ],
        "properties": {
            "indicators": {
                "type": "array",
                "description": "要计算的技术指标列表",
                "items": {
                    "type": "string",
                    "description": "技术指标",
                    "enum": [
                        "RSI",
                        "MACD",
                        "Bollinger_Bands",
                        "Stochastic_Oscillator"
                    ]
                }
            },
            "period": {
                "type": "number",
                "description": "分析的时间周期"
            },
            "ticker": {
                "type": "string",
                "description": "股票代码"
            }
        }
    }
}
""".strip()

def generate_function_schema(description: str):
    completion = client.chat.completions.create(
        model="gpt-4o-mini",
        response_format={"type": "json_schema", "json_schema": META_SCHEMA},
        messages=[
            {
                "role": "system",
                "content": META_PROMPT,
            },
            {
                "role": "user",
                "content": "描述:\n" + description,
            },
        ],
    )

    return json.loads(completion.choices[0].message.content)