팁 생성

존재 놀이터 정곡을 찌르세요 생성 버튼을 사용하면 작업 설명에서 프롬프트를 생성할 수 있습니다,함수 (수학.)노래로 응답빌드. 이 가이드에서는 작동 방식을 단계별로 설명합니다.

개요

프롬프트와 아키텍처를 처음부터 생성하는 것은 시간이 많이 소요될 수 있으며, 생성 버튼을 사용하면 빠르게 시작할 수 있습니다.생성 버튼은 다음 두 가지 주요 방법을 사용합니다:

1. STH에 주목하세요.사용힌트모범 사례를 통합하여 팁을 생성하거나 개선하세요.
2. 빌드사용메타 아키텍처유효한 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 아키텍처 사양 제공되는 메타 아키텍처는 다음과 같은 엄격한 모델에 의존합니다. 현재 지원되지 않는 기능. 이로 인해 입력 및 출력 아키텍처에 문제가 발생합니다.

1. 입력 아키텍처: 입력 아키텍처를 사용할 수 없습니다. 지원되지 않는 기능 를 사용하여 출력 아키텍처를 설명합니다.
2. 출력 아키텍처: 생성된 아키텍처에는 다음을 포함할 수 없습니다. 지원되지 않는 기능.

출력 아키텍처에서 새 키를 생성해야 하므로 입력 메타 아키텍처는 반드시 additionalProperties. 즉, 현재 엄격한 패턴을 사용하여 아키텍처를 생성할 수 없습니다. 하지만 엄격한 패턴의 제약 조건을 준수하는 아키텍처를 생성하고자 합니다.

이러한 한계를 극복하기 위해 다음과 같이 정의합니다. 의사 요소 아키텍처(컴퓨팅) -- 엄격한 스키마를 지원하지 않는 기능을 사용하여 엄격한 스키마에서만 지원되는 기능을 설명하는 메타 아키텍처입니다. 기본적으로 이 접근 방식은 메타 아키텍처를 정의할 때 엄격 모드에서 벗어나면서 결과 아키텍처가 엄격 모드 제한을 따르도록 합니다.

심도 있는 토론

의사-메타 아키텍처를 설계한 방법

제약된 메타 아키텍처를 구축하는 것은 어려운 작업이므로 유니티는 모델을 활용하여 이를 지원합니다.

먼저 JSON 모드로 다음 주소로 메시지를 전송합니다. o1-preview 노래로 응답 gpt-4o 는 결과물을 구조화한 문서를 사용하여 우리의 목표를 설명했습니다. 몇 번의 반복 끝에 실행 가능한 첫 번째 메타 아키텍처를 개발했습니다.

그런 다음 gpt-4o 를 제공하는 구조화된 출력초기 구조작업 설명 및 문서와 함께 더 나은 후보 아키텍처를 생성합니다. 반복할 때마다 더 나은 아키텍처를 사용하여 다음 단계를 생성하고 최종적으로 수동 조사를 수행합니다.

마지막으로, 결과물을 정리한 후 일련의 평가 테스트를 통해 아키텍처를 검증하여 아키텍처 및 기능에 대한 적용 가능성을 확인합니다.

출력 정리

엄격한 모드는 완벽한 아키텍처 준수를 보장합니다. 하지만 생성 중에는 엄격 모드를 사용할 수 없으므로 생성 후에는 출력의 유효성을 검사하고 변환해야 합니다.

아키텍처를 생성한 후 다음 단계를 수행합니다:

1. 의 모든 객체를 설정합니다. additionalProperties 로 설정 false.
2. 모든 속성을 필수로 표시.
3. 구조화된 출력 아키텍처의 경우패키지는 json_schema 를 추가합니다.
4. 기능의 경우패키지는 function 를 추가합니다.

= 실시간 API의 함수 (수학.) 객체는 채팅 완료 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)